可變不可變：
1.可變：列表、字典、例如列表類型是可變的，我修改了列表中的元素的值，但是列表本身在內存中的地址是沒有變化的，所以列表的元素是可以被改變的
>>> name=["gouguoqi","beiye"] >>> id(name) 6828808 >>> name[0]="123" >>> print (name) ['123', 'beiye'] >>> id(name) 6828808 >>>
2、不可變：字符串 、數字、元組（本身就不能變）之前也講過，字符串在內存中定義之后就不可以變了，而列表就可以變，就是因為那個鏈表的概念
>>> name="gouguoqi" >>> id(name) 7227568 >>> name="hehe" >>> id(name) 7222192
訪問順序：
1.直接訪問：數字
2.順序訪問：字符串、列表、元組
3、映射方式訪問：字典 key value
存放元素個數：
容器類型：列表、元素、字典 （可以存放多個元素）
原子（只能存在一種數據類型）：數字、字符串
一、什么是集合
1、由不同元素的組成的集合，可作為字典的key
2、無序排列的可hash的值
3、集合中的元素必須是不可變類型
>>> s={1,2,3,4,5,6} 這是一個集合不是字典。字典是這樣的s = {"key":"value","key2":"value2"}
集合用set表示，有去重特性
>>> s={1,2,3,4,5,6,6,6,6,6,6}
>>> type(s)
<class 'set'>
>>> print (s)
{1, 2, 3, 4, 5, 6}
集合是無序的（hello world本來是在前面的，打印出來就后面去了）
>>> s={"hello","world","gouguoqi","beiye"}
>>> for n in s:
... print (n)
...
gouguoqi
beiye
hello
world
集合當中必須是不可變類型
把列表放到集合里面直接就報錯了。因為列表是可變的
>>> s={[1,2,3],"hello"}
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'list'
二、創建集合(重復就會去除，然后以for循環的方式把元素一個一個添加到集合里面)
>>> s = set("goguoqi") >>> print (s) {'o', 'g', 'i', 'q', 'u'} s = set("hello") print(s) s = set(["gouguoqi", "gouguoqi", "sb"]) print(s) C:\python35\python3.exe D:/pyproject/day12列表/set-集合.py {'l', 'e', 'h', 'o'} {'sb', 'gouguoqi'}
三、集合的內置方法
1.add(self, *args, **kwargs) (只能更新一個值)
Add an element to a set. element [ˈelɪmənt] 元素
This has no effect if the element is already present. effect [ɪˈfekt] 影響
添加一個元素到集合里面，如果這個元素已經有了，不影響
增加一個集合元素"11"
s = set(["gouguoqi", "gouguoqi", "sb"]) s.add("11") print(s) C:\python35\python3.exe D:/pyproject/day12列表/set-集合.py {'gouguoqi', 'sb', '11'}
為什么如果已經有了，在添加，就不會顯示呢，因為集合本來就有去重的特性呀，你加個一樣的，自然就會自動去重了
s = set(["gouguoqi", "gouguoqi", "sb"]) s.add("11") 這是一個字符串 s.add(11) 這是一個數字 s.add("11") 這是一個字符串 print(s) 結果就是多了一個數字11和一個字符串"11" C:\python35\python3.exe D:/pyproject/day12列表/set-集合.py {'11', 11, 'gouguoqi', 'sb'}
2. clear(self, *args, **kwargs)
Remove all elements from this set element [ˈelɪmənt] 元素
從這個集合里面移除所有元素
s = set(["gouguoqi", "gouguoqi", "sb"]) s.clear() print(s) C:\python35\python3.exe D:/pyproject/day12列表/set-集合.py set()
3. copy(self, *args, **kwargs)
Return a shallow copy of a set shallow [ˈʃæləʊ] 淺
淺拷貝一個集合
s = set(["gouguoqi", "gouguoqi", "sb"]) v = s.copy() print (s) print (v) C:\python35\python3.exe D:/pyproject/day12列表/set-集合.py {'gouguoqi', 'sb'} {'gouguoqi', 'sb'}
4. pop(self, *args, **kwargs)
Remove and return an arbitrary set element. arbitrary [ˈɑ:bɪtrəri] 任意的
Raises KeyError if the set is empty.
刪除集合中任意的一個元素（）
如果集合為空，報錯 TypeError: pop expected at least 1 arguments, got 0
s = {1,2,3,4,5,6,"s"}
s.pop()
print (s)
C:\python35\python3.exe D:/pyproject/day12列表/set-集合.py
{1, 2, 3, 4, 5, 6}
5. remove(self, *args, **kwargs)
Remove an element from a set; it must be a member. [ˈmembə(r)] 成員
If the element is not a member, raise a KeyError
刪除指定的元素，如果指定的刪除的元素不在集合里面，則報錯
a = {1,2,3,4,5,6,"s"}
a.remove("s")
print (a)
C:\python35\python3.exe D:/pyproject/day12列表/set-集合.py
{1, 2, 3, 4, 5, 6}
當指定被刪除元素不存在時
a = {1,2,3,4,5,6,"s"}
a.remove("ss")
print (s)
KeyError: 'ss'
6. discard(self, *args, **kwargs) discard 丟棄
Remove an element from a set if it is a member.
If the element is not a member, do nothing
如果指定元素存在，就從集合中刪除，如果不是集合中的一個元素(等價於被指定刪除的元素不存在)，就什么也不做
a = {1,2,3,4,5,6,"s"}
a.discard("s")
v = a.discard("sss")
print (a)
print (v)
C:\python35\python3.exe D:/pyproject/day12列表/set-集合.py
{1, 2, 3, 4, 5, 6}
None
四、集合的運算
7.集合關系。運算交，差，並集
取2個列表的交集 既會python，又會linux的人
這叫2個列表的關系運算
python_1 = ["ggq","ytj","mr"] linux_1 = ["ggq","ytj"] python_1_and_linux1 = [] 既會py又會linux開始的時候不知道定義一個空列表 for p_name in python_1: 開始循環python_1里面的名字 if p_name in linux_1: 如果python_1里面的名字也在linux_1 python_1_and_linux1.append(p_name)我就把這個名字追加到既會py又會linux print (python_1_and_linux1) C:\python35\python3.exe D:/pyproject/day12列表/set-集合.py ['ggq', 'ytj']
如果沒有集合的話，就只能像上面這樣寫了，很low也很麻煩
python_1 = ["ggq","ytj","mr","mr","ggq"] p_s = set(python_1) print (p_s) C:\python35\python3.exe D:/pyproject/day12列表/set-集合.py {'ytj', 'ggq', 'mr'}
8.集合可以去重，如果有這樣的需求想去除列表里面的重復元素的話就很簡單了，直接把列表轉換成集合就行了，但是有個弊端，就只轉換之后，集合是無序的了
9. intersection(self, *args, **kwargs) [ˌɪntəˈsekʃn] 交叉
Return the intersection of two sets as a new set
求2個集合的交集（也就是取出來既會py又會linux的人）
python_1 = ["ggq","ytj","mr","mr","ggq"] linux_1 = ["ggq","ytj"] p_s = set(python_1) #把列表轉換為集合 l_s = set(linux_1) #把列表轉換為集合 print (p_s,l_s) print (p_s.intersection(l_s)) #可以用集合的intersection方法 print (p_s&l_s) #用&也是一樣的效果 這是求交集的符號 & C:\python35\python3.exe D:/pyproject/day12列表/set-集合.py {'ggq', 'mr', 'ytj'} {'ggq', 'ytj'} {'ggq', 'ytj'} {'ggq', 'ytj'}
10. union(self, *args, **kwargs) 並集
Return the union of sets as a new set
求2個集合的並集（就是把2個集合合並成一個集合，因為集合有去重特性，所以就是把2個集合合並成一個集合並去除重復的）
python_1 = ["ggq","ytj","mr","mr","ggq"] linux_1 = ["ggq","ytj","sb"] p_s = set(python_1) l_s = set(linux_1) print (p_s,l_s) print (p_s.union(l_s)) #求並集的方法 print (p_s|l_s) #求並集的符號 | C:\python35\python3.exe D:/pyproject/day12列表/set-集合.py {'ytj', 'ggq', 'mr'} {'ytj', 'ggq', 'sb'} {'ggq', 'mr', 'sb', 'ytj'} {'ggq', 'mr', 'sb', 'ytj'}
11. difference(self, *args, **kwargs) 差集
Return the difference of two or more sets as a new set
求差集
python_1 = ["ggq","ytj","mr","mr","ggq"] linux_1 = ["ggq","ytj","sb"] p_s = set(python_1) l_s = set(linux_1) print (p_s,l_s) print (p_s.difference(l_s)) #差集的方法 print (p_s-l_s) #求差集的符號 - C:\python35\python3.exe D:/pyproject/day12列表/set-集合.py {'ytj', 'ggq', 'mr'} {'ytj', 'ggq', 'sb'} {'mr'} {'mr'}
12. symmetric_difference(self, *args, **kwargs) 交叉補集
Return the symmetric difference of two sets as a new set
就是2個集合交叉一下，扣掉兩者共有的，剩下的就是
python_1 = ["ggq","ytj","mr","mr","ggq"] linux_1 = ["ggq","ytj","sb"] p_s = set(python_1) l_s = set(linux_1) print (p_s,l_s) print (p_s.symmetric_difference(l_s)) #交叉補集的方法 print (p_s^l_s) #交叉補集的符號 ^ C:\python35\python3.exe D:/pyproject/day12列表/set-集合.py {'mr', 'ggq', 'ytj'} {'ggq', 'sb', 'ytj'} {'mr', 'sb'} {'mr', 'sb'}
13. difference_update(self, *args, **kwargs)
Remove all elements of another set from this set
python_1 = ["ggq","ytj","mr","mr","ggq"] linux_1 = ["ggq","ytj","sb"] p_s = set(python_1) l_s = set(linux_1) print (p_s,l_s) p_s = p_s-l_s p_s.difference_update(l_s)#這個方法相當於給p_s重新賦值了p_s = p_s-l_s p_s -= l_s #用符號來表示 -= print (p_s) C:\python35\python3.exe D:/pyproject/day12列表/set-集合.py {'mr', 'ytj', 'ggq'} {'ytj', 'sb', 'ggq'} {'mr'}
14. intersection_update(self, *args, **kwargs)
Update a set with the intersection of itself and another.
python_1 = ["ggq","ytj","mr","mr","ggq"] linux_1 = ["ggq","ytj","sb"] p_s = set(python_1) l_s = set(linux_1) print (p_s,l_s) p_s = p_s&l_s p_s.intersection_update()#這個方法相當於給ps重新賦值了 p_s = p_s&l_s print (p_s) p_s &= l_s #用符號來表示就是 &= print (p_s) C:\python35\python3.exe D:/pyproject/day12列表/set-集合.py {'ggq', 'mr', 'ytj'} {'sb', 'ggq', 'ytj'} {'ggq', 'ytj'} {'ggq', 'ytj'}
15. isdisjoint(self, *args, **kwargs)
Return True if two sets have a null intersection
如果2個集合沒有交集（相同的元素），就返回True
如果2個集合有交集（相同的元素），就返回False
S1 = {1,2,3}
S2 = {4,5,6,1}
print (S1.isdisjoint(S2))
C:\python35\python3.exe D:/pyproject/day12列表/set-集合.py
False
16. issubset(self, *args, **kwargs)
Report whether another set contains this set。 whether 是否 contains 包含
報告是否另一個集合包含這個集合
相當於 s1<=s2 就為True
專業說法就是 s1 是s2的子集，或者是s2是s1的父集
S1 = {1,2,3}
S2 = {1,2,3,4.5}
print (S1.issubset(S2)) #這個方法是判斷S1是否是S2的子集
print (s1<=s2) #用符號表示 <=
C:\python35\python3.exe D:/pyproject/day12列表/set-集合.py
True
True
如果S1不是S2的子集，就Flase了
很明顯，現在S1是S2的父集了，所以就為False了
S1 = {1,2,3,4.5}
S2 = {1,2,3}
print (S1.issubset(S2))
C:\python35\python3.exe D:/pyproject/day12列表/set-集合.py
False
17. issuperset (self, *args, **kwargs)
Report whether this set contains another set
報告是否這個集合包含另一個集合
相當於S1 >= S2 就為True
專業說法就是S1是S2的父集。
S1 = {1,2,3,4.5}
S2 = {1,2,3}
print (S1.issuperset(S2)) #這個方法是判斷S1是否是S2的父集
print (S1 >= S2) #用符號表示就是 >=
C:\python35\python3.exe D:/pyproject/day12列表/set-集合.py
True
True
如果S1不是S2的父集，就返回False
這很明顯了，S1是S2的子集了，所以就是False
S1 = {1,2,3}
S2 = {1,2,3,4.5}
print (S1.issuperset(S2))
C:\python35\python3.exe D:/pyproject/day12列表/set-集合.py
False
18. update(self, *args, **kwargs) 用來更新多個值，參數是可迭代對象
Update a set with the union of itself and others
就是把S2中的所有元素更新到S1里面去，給S1重新賦值了，以前那些求交集、合集的並沒有真實改變S1的值，而這個update就改變了S1的值
當參數是一個集合的時候
S1 = {1,2,3}
S2 = {1,2,4.5}
S1.update(S2)
print (S1)
C:\python35\python3.exe D:/pyproject/day12列表/set-集合.py
{1, 2, 3, 4.5}
當參數是一個元組的時候
S1 = {1,2,3}
S1.update(("gouguoqi",6,))
print (S1)
C:\python35\python3.exe D:/pyproject/day12列表/set-集合.py
{'gouguoqi', 1, 2, 3, 6}
當參數是一個集合的時候
S1 = {1,2,3}
S1.update([11,22,"hehe"])
print (S1)
C:\python35\python3.exe D:/pyproject/day12列表/set-集合.py
{1, 2, 3, 11, 22, 'hehe'}
五、不可變集合，這就是不可變集合
S1 = frozenset("hello") print (S1) C:\python35\python3.exe D:/pyproject/day12列表/set-集合.py frozenset({'l', 'h', 'e', 'o'})
把列表用集合進行去重之后，在變回列表的類型
names = ["gouguoqi","miaoye","gouguoqi"] # a = set(names) # print (a) # b = list(a) # print (b) print (list(set(names))) #把上面四行改成一行 C:\python35\python3.exe D:/pyproject/day12列表/set-集合.py ['gouguoqi', 'miaoye']