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'