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'