Python封装及解构

python封装及解构

Python的封装与其他语言的封装箱不同,python中没有装箱的概念,一切皆对象

将多个值使用逗号进行分割,本质上是返回元组

In [1]: a = 1,2

In [2]: type(a)

Out[2]: tuple

In [3]: a

Out[3]: (1, 2)

封装

在进行交换的时候,已经被封装为元组

在赋值的过程中,看似什么都没有做,但是在右值将其封装为元组,因为其值不变

In [9]: a = 1,2

In [10]: a??

Type:       tuple

String form: (1,2)

Length:     2

Docstring:

tuple() ->empty tuple

tuple(iterable)-> tuple initialized from iterable‘s items

If the argumentis a tuple, the return value is the same object.

为什么使用元组进行解构?

元组在实现中比list轻巧的多,在内存占用上考虑更小的空间,所以使用元组

元组的定义

a = 1,2

a = (1,2)

封装的过程

In [23]: a = 1

In [24]: b = 2

In [25]: a,b

Out[25]: (1, 2)    #

In [26]: a,b =b,a

先将值封装为元组,然后将新的元组将新值进行重新赋值

In [30]: c = a,b

In [31]: c

Out[31]: (1, 2)

解构:

线性结构元组解开,并按照顺序方式赋值给其他变量

左右顺序:左边接纳的变量和右边解构的元素个数必须一致

In [44]: lst =[3,5]

In [45]: lst

Out[45]: [3, 5]

In [46]: f,s =lst

In [47]:print(f,s)

3 5

解构的过程

在解构之前需要先进行封装,然后对右值进行封装,再对左值进行解构

解构的时候则使用list进行,因为在解构的时候,其不知空间占用多少,所以在设计结构的时候优先使用列表

正与封装的时候相反,在封装的时候因为已知数据占用情况,所以在内存占用上考虑更小的空间

例:

*号位当前去掉占位变量其余所有数据全部进行赋值,类似贪婪模式

In [49]: a,*b =1,2,3,4,5

In [50]: a

Out[50]: 1

In [51]: b

Out[51]: [2, 3,4, 5]

例2

n [53]: [a,b] =(1,2)

In [54]: a

Out[54]: 1

In [55]: b

Out[55]: 2

In [56]: a,b

Out[56]: (1, 2)

python3的解构

使用*+变量名,但是*不能单独使用

In [71]: a =list(range(10))

In [72]: *b = a

File"<ipython-input-72-a92a123ff659>", line 1

*b= a

^

SyntaxError: starred assignment target must be in alist or tuple

*必须跟多变量进行赋值

In [73]: n,*b =a

In [74]: n

Out[74]: 0

In [75]: b

Out[75]: [1, 2,3, 4, 5, 6, 7, 8, 9]

In [76]: n,b

Out[76]: (0, [1,2, 3, 4, 5, 6, 7, 8, 9])

本身*不能独立去接收,原因在于*不能单独出现

*号本身定义就是为了尽可能的多收集,但是并不能全部收集

In [77]: *b,o =a

In [78]: b,o

Out[78]: ([0, 1,2, 3, 4, 5, 6, 7, 8], 9)

*在解构的时候做尽可能重复去接收更多的元素,例:

In [88]:head,*_,tail = lst

In [89]: head

Out[89]: 0

In [90]: _

Out[90]: [1, 2,3, 4, 5, 6, 7, 8]

In [91]: tail

Out[91]: 9

_丢弃变量

_号  ,下划线是合法的标识符,但是一般使用_只引用来测,因为根本看不明白其要做什么事

In [92]: lst

Out[92]: [0, 1,2, 3, 4, 5, 6, 7, 8, 9]

In [93]:head,*_,tial = lst

In [94]:head,tail

Out[94]: (0, 9)

在开发习惯中,一般_表示丢弃,以上例子,我们只想取头部和尾部,_为丢弃

例:以下_为赋值两次,最后一次*_将前面的_值覆盖

In [95]:_,*_,tail = lst

In [96]: tail

Out[96]: 9

In [97]: _

Out[97]: [1, 2,3, 4, 5, 6, 7, 8]

In [98]: lst

Out[98]: [0, 1,2, 3, 4, 5, 6, 7, 8, 9]

_变量本身没有任何语义,并没有可读性

例:取出第二个,第四个,和倒数第二个

In [108]: lst

Out[108]: [0, 1,2, 3, 4, 5, 6, 7, 8, 9]

In [108]:_,two,_,four,*_,nine,_ = lst

从lst = [1,(2,3,4),5] 将4提取出来

In [120]: lst

Out[120]: [1,(2, 3, 4), 5]

In [121]: _,[*_,a],_= lst

In [122]: a

Out[122]: 4

In [136]:_,(*_,a),_ = lst

In [137]: a

Out[137]: 4

取出路径

In [144]:name,_,path  = a.partition(‘=‘)

In [145]: path

Out[145]:‘/usr/bin‘

时间: 2024-10-10 00:24:33

Python封装及解构的相关文章

封装与解构

在IPython中可以使用 %timeit  计算程序运行时间 1.单行: %timeit  statement 2.多行:%%timeit 例如: def asfd(n): # 定义一个函数 for i in range(n): return(i) 单行:%timeit(20) 多行:%%timeit  m=20 asfd(m)   封装与解构: 封装: #  等号右边多个值使用逗号分割组合返回一个元组 例如: t = 1,2,3 print(t) 为(1,2,3) 解构: # 把线性结构(非

python的封装与解构

封装 将多个值使用逗号分割,组合在一起 本质上,返回一个元祖,只是省掉了小括号 python特有语法,被很多语言学习和借鉴 t1 = (1,2) #定义为元祖 t2 = 1,2 #将1和2封装成元祖 print(type(t1)) print(type(t2)) 返回类型都为元组: <class 'tuple'> <class 'tuple'> 使用方法: a = 4 b = 5 temp = a a = b b = temp # 等价于 a,b = b,a #等号右边使用了封装,

python内置函数封装、解构

一.封装 将多个值使用逗号分割,组合在一起,本质上返回一个元组,只是省掉了小括号 python特有语法,被很多言语学习和借鉴 二.解构 把线性结构的元素解开,并顺序的赋给其他变量 左边接纳的变量数要和右边解开的元素个数一致 举例: >>> lst = [3,5]  >>> a,b = lst  >>> print(a,b)  3 5  >>> 三.python3版本的解构 使用*变量名接收,但不能单独使用 被*变量名收集后组成一个列表

Python-封装与解构

1.封装: 定义: 将多个值用括号分割,组合在一起 本质上,返回一个元组,只是省掉了小括号 1 In [99]: t = 1,2,3 # 封装成元组! t = (1,2,3) 2 3 In [100]: t 4 Out[100]: (1, 2, 3) 1 a = 4 2 b = 5 3 tmp = a 4 a = b 5 b = tmp 6 等价于 7 a, b = b, a 8 9 注:但并不是真正的等价,这里右侧是一个封装的元组,对左侧使用了解构 2.解构: 把线性结构的元素解开,并顺序的赋

封装解构,集合,字典,内建函数和简单选择排序相关知识及习题

封装 将多个值使用逗号分割,组合在一起本质上,返回一个元组,只是省掉了小括号python特有语法,被很多语言学习和借鉴 解构 把线性结构的元素解开,并顺序的赋给其它变量左边接纳的变量数要和右边解开的元素个数一致 转置矩阵 方阵利用封装解构完成代码矩阵先开辟空间再利用封装解构完成代码利用enumerate函数得到索引值完成代码 集合 可变的 . 无序的 . 不重复 的元素的集合set的元素要求必须可以hash元素不可以索引set可以迭代set增加 add(elem)增加一个元素到set中,如果元素

python 函数、参数及参数解构

函数 数学定义 y=f(x), y是x函数,x是自变量.y=f(x0,x1...xn) Python函数 由若干语句组成的语句块,函数名称,参数列表构成,它是组织代码的最小单位 完成一定的功能 函数作用 结构化编程对代码的最基本的封装,一般按照功能组织一段代码 封装的目的为了复用,减少冗余代码 代码更加简洁美观,可读易懂 函数分类 内建函数,如max(),reversed()等 库函数,如math.ceil()等 函数定义.调用 def语句定义函数 def 函数名(参数列表): 函数体(代码块)

Python封装和结构

在Python中有封装和解构的概念.封装 ——是将将多个值使用逗号分割,组合在一起 .本质上,返回一个元组,只是省掉了小括号.这是Python特有的概念,现在被很多语言借鉴. a = (1,2)#元组 b = 1,2#元组 print(type(a)) print(type(b)) 结果为: <class 'tuple'> <class 'tuple'> 解构是把线性结构(也可以是非线性结构)的元素解开,并顺序的赋给其它变量,应该注意的是左边接纳的变量数要和右边解开的元素个数一致.

ES6--变量的声明及解构赋值

ES6的目标是使得JavaScript语言可以用来编写大型的复杂的应用程序,成为企业级开发语言:该标准已于2015年6月17日正式发布.但是真正的普及我认为还得需要一段时间,然而这并不是理由让我们不去了解ES6.更重要的一点是,Google公司的V8引擎已经部署了ES6部分特性,对于NodeJS的开发者来说应该熟练掌握. 在浏览器没有全面支持的情况下,Google公司推出了Traceur转码器(https://github.com/google/traceur-compiler),可将ES6编译

C++对象模型——构造,解构,拷贝语意学(第五章)

第5章 构造,解构,拷贝语意学 (Semantics of Construction, Destruction, and Copy) 考虑下面这个abstract base class 声明: class Abstract_base { public: virtual ~Abstract_base() = 0; virtual void interface() const = 0; virtual const char * mumble() const { return _mumble; } p