封裝和結構及set
封裝
- 將多個值使用逗號分割，組合在一起
- 本質上返回一個元組，只是省略了小括號
- python特有語法
In [56]: a=1
In [57]: b=2
In [58]: c=3
In [59]: c,b,a=b,c,a#左側為解構，右側為封裝
In [60]: a
Out[60]: 1
In [61]: b
Out[61]: 3
In [62]: c
Out[62]: 2
In [63]: t=1,2#將1,2封裝成元組
In [64]: t
Out[64]: (1, 2)
解構
- 把線性結構的元素解開，并序列的賦給其他變量
- 左邊接納的變量數要和右邊解開的元素個數一致
In [66]: lst=[3,5]
In [67]: first,second=lst
In [68]: first
Out[68]: 3
In [69]: second
Out[69]: 5
—————————————————————————-
In [81]: a,b={100,66}#由于set是無序結構所以a,b會隨機從列表中拿取元素
In [82]: a
Out[82]: 66
In [83]: b
Out[83]: 100
In [84]: a,b={10,20,30}#右側value多左側解構少于值所以報錯
—————————————————————————
ValueError Traceback (most recent call last)
<ipython-input-84-658256ee5b54> in <module>()
—-> 1 a,b={10,20,30}
ValueError: too many values to unpack (expected 2)
———————————————————————————–
In [89]: a,*b={19,20,21,22}#*號可以接收0個或多個數值
In [90]: a
Out[90]: 19
In [91]: b
Out[91]: [20, 21, 22]
————————————————————————————
In [92]: [a,b]=(10,29)#左右的類型不做要求
In [93]: a
Out[93]: 10
In [94]: b
Out[94]: 29
In [95]: (c,d)={100,200}
In [96]: c
Out[96]: 200
In [97]: d
Out[97]: 100
python3的解構
- 使用*變量名接收，但不能單獨使用
- 被*變量名收集后組成一個列表
In [99]: lst
Out[99]: [1, 3, 5, 7, 9, 11, 13, 15, 17, 19]
In [100]: a,*b,c=lst
In [101]: a
Out[101]: 1
In [102]: b##*b接收下來多個元素組成列表
Out[102]: [3, 5, 7, 9, 11, 13, 15, 17]
In [103]: c
Out[103]: 19
““
<div class=”se-preview-section-delimiter”></div>
#####丟棄變量
* 如果不關心一個變量，就可以定義該變量的名字為_
* _是個合法標識符，也可以作為一個有效的變量使用，但是定義成下劃線就是希望不要被使用，除非明確知道這個數據需要使用
* 總結：_ 這個變量本身無任何語義，沒有任何可讀性，python中很多庫都在使用這個變量，請不要在不明確變量作用域的情況下使用 _ 導致和庫中的 _ 沖突
<div class=”se-preview-section-delimiter”></div>
“`python
In [111]: lst
Out[111]: [1, 3, 5, 7, 9, 11, 13, 15, 17, 19]
In [112]: head,*_,tail=lst#當只想取出開頭和結尾值時可以這樣使用
In [113]: head
Out[113]: 1
In [114]: _
Out[114]: [3, 5, 7, 9, 11, 13, 15, 17]
In [115]: tail
Out[115]: 19
#應用：只想取出某個值時可以這樣匹配_的值雖然不用但是最后賦值應該是5，因為賦值即定義
In [116]: lst=[1,2,(3,4),5]
In [117]: *_,(*_,a),_=lst
In [118]: a
Out[118]: 4
練習
1.環境變量JAVA_HOME=/usr/bin,返回變量名和路徑
In [119]: key,val=”JAVA_HOME=/usr/bin”.split(“=”)
In [120]: key
Out[120]: ‘JAVA_HOME’
In [121]: val
Out[121]: ‘/usr/bin’
2.對列表[1,9,8,5,6,7,4,3,2]使用冒泡法排序，要求使用封裝和解構來交互數據
lst=[1,9,8,5,6,7,4,3,2]
length=len(lst)
for i in range(length):
for j in range(length-i-1):
if lst[j] > lst[j+1]:
lst[j],lst[j+1]=lst[j+1],lst[j]
print(lst)
集set
- set翻譯成集合
- collection翻譯為集合類型，是一個大概念
- 可變的，無序的，不重復的元素集合
- set()定義一個新的空集合
- set(iterable)定義一個新的集合，注意：此處可以set([list]),因為set函數只是將列表的值插入到set中而非list本身
- set 元素要求必須可以hash(),list、set、bytearray不可hash
- 元素不可以索引
- set可以迭代
In [123]:s1=set()
In [124]: s1
Out[124]: set()
In [125]: s2=set(list(range(10)))
In [126]: s2
Out[126]: {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
In [127]: s3=set(range(10))
In [128]: s3
Out[128]: {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
In [129]: s4={}######（此處證明使用空的大括號代表類型為字典）
In [130]: type(s4)
Out[130]: dict
In [131]: s5={4,5,6,’a’}
In [132]: s6={(1,2,3),4}
In [133]: s7={[1,2,3],”a”}###報錯證明list不可以被hash，同樣bytearray，set這種可變類型的集合也不可以hash
—————————————————————————
TypeError Traceback (most recent call last)
<ipython-input-133-4d6d1503b10e> in <module>()
—-> 1 s7={[1,2,3],”a”}
TypeError: unhashable type: ‘list’
set增加、刪除、修改查詢
- add(elem):增加元素到set中，如果存在不做操作
- update(*others):合并其他元素到set集合中來，參數others必須是可迭代的對象，就地修改
- remove(elem):從set中移除一個元素，如果不存在拋出keyerror
- discard(elem):從set中移除一個元素，不存在什么都不做。不拋錯
- pop()->item:移除并返回任意的元素，空集返回keyerroe
- clear():移除所有元素
- 修改：無此操作，要么刪除要么加入.(無索引)
- 查詢：非線性結構，無法索引
- 遍歷：可以迭代所有元素
- 成員運算符：in和not in 判斷元素是否在set中.復雜度為O(1)
#增
In [41]: a
Out[41]: set()
In [42]: a.add(b)#add無法添加可迭代類型
—————————————————————————
TypeError Traceback (most recent call last)
<ipython-input-42-a1cb1b03d031> in <module>()
—-> 1 a.add(b)
TypeError: unhashable type: ‘list’
In [43]: b
Out[43]: [1, 2, 3]
In [44]: a.add(1)
In [45]: a
Out[45]: {1}
In [46]: a.update(b)##update只能添加可迭代類型
In [47]: a
Out[47]: {1, 2, 3}
——————————————————————————–
#刪：
In [50]: a
Out[50]: {1, 2, 3, ‘abcd’}
In [51]: a.remove(1)#刪除單個元素
In [52]: a.remove(1)#刪除不存在單個元素，報錯
—————————————————————————
KeyError Traceback (most recent call last)
<ipython-input-52-b0bac4dc7509> in <module>()
—-> 1 a.remove(1)
KeyError: 1
In [53]: a.discard(1)#刪除不存在的元素，不反回內容
In [54]: a.discard(2)
In [55]: a
Out[55]: {3, ‘abcd’}
In [56]: a.pop()#隨機刪除
Out[56]: 3
In [57]: a
Out[57]: {‘abcd’}
set成員運算符的比較
擴展：list，set效率比較
#增
In [41]: a
Out[41]: set()
In [42]: a.add(b)#add無法添加可迭代類型
—————————————————————————
TypeError Traceback (most recent call last)
<ipython-input-42-a1cb1b03d031> in <module>()
—-> 1 a.add(b)
TypeError: unhashable type: ‘list’
In [43]: b
Out[43]: [1, 2, 3]
In [44]: a.add(1)
In [45]: a
Out[45]: {1}
In [46]: a.update(b)##update只能添加可迭代類型
In [47]: a
Out[47]: {1, 2, 3}
——————————————————————————–
#刪：
In [50]: a
Out[50]: {1, 2, 3, ‘abcd’}
In [51]: a.remove(1)#刪除單個元素
In [52]: a.remove(1)#刪除不存在單個元素，報錯
—————————————————————————
KeyError Traceback (most recent call last)
<ipython-input-52-b0bac4dc7509> in <module>()
—-> 1 a.remove(1)
KeyError: 1
In [53]: a.discard(1)#刪除不存在的元素，不反回內容
In [54]: a.discard(2)
In [55]: a
Out[55]: {3, ‘abcd’}
In [56]: a.pop()#隨機刪除
Out[56]: 3
In [57]: a
Out[57]: {‘abcd’}
擴展：list，set效率比較
set和線性結構
- 線性結構的查詢時間復雜度為O(n)，即隨著數據規模的增大而增加耗時
- set，dict等結構，內部使用hash值作為key，時間復雜度為O(1)，查詢時間和數據規模無關
- 可hash類型數據：
- 數值型int，float，complex
- 布爾型True，False
- 字符串string，bytes
- tuple
- None
- 一上都是不可變類型，成為可哈希類型，hashable
- set的元素必須是可hash的
集合
- 基本概念：
- 全集：所有元素的集合。例如實數集，所有實數組成的集合就是全集
- 子集subset&超集superset：一個集合A所有元素都在另一個集合B內，A是B的子集，B是A的超集
- 真子集&真超集：A是B子集，且A不等于B，A就是B的真子集，B是A的真超集
- 并集：多個集合合并的結果
- 交集：多個集合的公共部分
- 差集：集合中除去和其他集合公共部分
- 運算：
- 并集：將兩個集合A和B的所有元素合并到一起，組成的集合稱為集合A與集合B的并集
- union(*others):返回和多個集合合并后的新集合
- |運算符重載，等同于union
- update(*other):和多個集合合并，就地修改
- |=等同于update
In [31]: A={“a”,”b”,’c’,’d’}
In [32]: B={‘e’,’f’,’a’,’b’}
In [33]: A | B#返回合并后的結果，并不會對原數據做修改
Out[33]: {‘a’, ‘b’, ‘c’, ‘d’, ‘e’, ‘f’}
In [34]: A
Out[34]: {‘a’, ‘b’, ‘c’, ‘d’}
In [35]: B
Out[35]: {‘a’, ‘b’, ‘e’, ‘f’}
In [36]: A |= B#將合并后的結果賦值給A，原地更改。
In [37]: A
Out[37]: {‘a’, ‘b’, ‘c’, ‘d’, ‘e’, ‘f’}
In [38]: B
Out[38]: {‘a’, ‘b’, ‘e’, ‘f’}
In [40]: A.union(B)#同一
Out[40]: {‘a’, ‘b’, ‘c’, ‘d’, ‘e’, ‘f’}
In [41]: A.update(B)#同二
In [42]: A
Out[42]: {‘a’, ‘b’, ‘c’, ‘d’, ‘e’, ‘f’}
- 交集：集合A和B，由所有屬于A且屬于B的元素組成的集合
* intersection(*other):返回多個集合交集
* &：等同于intersection
* intersection_update(*other):獲取多個集合的交集，并就地修改
* &=：等同于intersection_update
In [43]: A
Out[43]: {‘a’, ‘b’, ‘c’, ‘d’, ‘e’, ‘f’}
In [44]: B
Out[44]: {‘a’, ‘b’, ‘e’, ‘f’}
In [45]: A&B#求出兩個集合的交集，返回結果，不對元數據修改
Out[45]: {‘a’, ‘b’, ‘e’, ‘f’}
In [46]: A&=B#就地修改A的值
In [47]: A
Out[47]: {‘a’, ‘b’, ‘e’, ‘f’}
In [48]: B
Out[48]: {‘a’, ‘b’, ‘e’, ‘f’}
In [49]: A.intersection(B)#同一
Out[49]: {‘a’, ‘b’, ‘e’, ‘f’}
In [50]: A.intersection_update(B)#同二
In [51]: A
Out[51]: {‘a’, ‘b’, ‘e’, ‘f’}
In [52]: B
Out[52]: {‘a’, ‘b’, ‘e’, ‘f’}
- 差集：集合A和B，由所有屬于A且不屬于B的元素組成的集合
- difference(*other)：返回多個集合的差集
- -：等同difference
- difference_update(*other)：獲取多個集合的差集并就地修改
- -=：等同于difference_update
In [54]: A
Out[54]: {‘e’, ‘x’, ‘y’, ‘z’}
In [55]: B
Out[55]: {‘a’, ‘b’, ‘e’, ‘f’}
In [56]: A-B#求A于B的差集
Out[56]: {‘x’, ‘y’, ‘z’}
In [57]: A.difference(B)#同上
Out[57]: {‘x’, ‘y’, ‘z’}
In [58]: B.difference(A)#求B于A的差集
Out[58]: {‘a’, ‘b’, ‘f’}
In [59]: A-=B#求A于B的差集并將結果原地修改
In [60]: A
Out[60]: {‘x’, ‘y’, ‘z’}
In [61]: B
Out[61]: {‘a’, ‘b’, ‘e’, ‘f’}
In [64]: A.difference_update(B)#同上
In [65]: A
Out[65]: {‘x’, ‘y’, ‘z’}
- 對稱差集：集合A和B，由所有不屬于A和B的交集元素組成的集合，(A-B)U(B-A)
* symmetric_differece(other):返回和另一個集合的差集
* ^：等同于symmetric_differece
* symmetric_differece_update(other):獲取和另一個集合的差集并就地修改
* ^=：等同于symmetric_differece_update.
In [70]: A
Out[70]: {‘a’, ‘x’, ‘y’, ‘z’}
In [71]: B
Out[71]: {‘a’, ‘b’, ‘e’, ‘f’}
In [72]: A^B#求出對稱差集的集合，并打印
Out[72]: {‘b’, ‘e’, ‘f’, ‘x’, ‘y’, ‘z’}
In [73]: A.symmetric_difference(B)#同上
Out[73]: {‘b’, ‘e’, ‘f’, ‘x’, ‘y’, ‘z’}
In [74]: A^=B#求出對稱集合并將結果賦予A，原地修改==A.symmetric_differece_update(B)
In [75]: A
Out[75]: {‘b’, ‘e’, ‘f’, ‘x’, ‘y’, ‘z’}
In [76]: B
Out[76]: {‘a’, ‘b’, ‘e’, ‘f’}
集合運算
- issubset(other)、<=:判斷當前集合是否是另一個集合的子集
- set1<set2:判斷set1是否是set2的真子集
- issuperset(other)、>=:判斷當前集合是否是other的超集
- set1>set2:判斷set1是否是set2的真超集
- isdisjoint(other):當前集合和另一個集合沒有交集，沒有交集則返回True
In [83]: A
Out[83]: {‘a’, ‘b’, ‘e’, ‘f’, ‘x’, ‘y’, ‘z’}
In [84]: B
Out[84]: {‘a’, ‘b’, ‘e’, ‘f’}
In [86]: A<=B#判斷A是不是B的子集
Out[86]: False
In [87]: B<=A#判斷B是不是A的子集
Out[87]: True
In [88]: A>B#判斷A是不是B的真超集
Out[88]: True
In [89]: A>=B#判斷A是不是B的超集
Out[89]: True
In [90]: A.isdisjoint(B)#如果沒有交集返回True，此處有交集
Out[90]: False
集合應用：
1.共同好友：你的好友A、B、C,他的好友C、B、D，求共同的好友
In [104]: user1={‘A’,’B’,’C’}
In [105]: user2={‘B’,’C’,’D’}
In [106]: user1 & user2#共同的好友，求交集問題。
Out[106]: {‘B’, ‘C’}
2.微信群提醒：XXX與群里其他人都不是微信朋友關系
userID in/isdisjoint （A|B|C…..） == False,A、B、C等是微信好友的并集，用戶ID不在這個并集中，說明他和任何人都是不朋友
3.權限判斷：
有一個API，要求權限同時具備A、B、C才能訪問，用戶權限是B、C、D，判斷用戶能否訪問該API
API集合A，權限集合P
A-P={},A-P為空集，說明P包含A
A.issubset(P),A是P的子集
A&P=A也行
有一個API，要求權限具備A、B、C任意一項就可訪問，用戶權限時B、C、D,判斷用戶能否訪問該API
1.API集合A，權限集合P
2.A&P != {}就可以
3.A.isdisjoint(P)==False表示有交集
4.一個總任務列表，存儲所有任務，一個完成的任務列表。找出未完成的任務
業務中，任務ID一般不可以重復
所有任務ID放到一個set中，假設為ALL
所有已完成的任務ID放到一個set中，假設為COMPLETED，他是ALL的子集
ALL-COMPLETED=UNCOMPLETED
集合練習：
1.隨機產2組各10個數字列表，要求：
每個數字取值范圍[10,20]
統計20個數字中，一共有多少個不同的數字
2組中，不重復的數字有幾個？分別是什么？
2組中，重復的數字有幾個？分別是什么？
import random
num1=list()
num2=list()
for _ in range(10):
num1.append(random.randint(10,20))
num2.append(random.randint(10,20))
#print(num1,num2)
#print(“diff number is {}”.format(len(set(num1+num2))))
#not repeat number is :
#print(“Not repeat nubmer is:{}not repeat count:{}”.format(set(num1)|set(num2),len(set(num1)|set(num2))))
#repeat number is :
#print(“repeat nuber is :{}repeat count:{}”.format(set(num1)&set(num2),len(set(num1)&set(num2))))
s1=set(num1)
s2=set(num2)
print(s1.union(s2))
print(s1.symmetric_difference(s2))
print(s1.intersection(s2))
本文來自投稿，不代表Linux運維部落立場，如若轉載，請注明出處：http://www.www58058.com/87688
