01-Python中的數據類型-04-tuple,dict,set
文章目錄
總體 要講的大綱內容 如下
- 數字類型- int float complex
- 字符串類型 Text Sequence Type- str
- 序列類型 - list range
- tuple dict
- 集合類型 -
setfrozenset - 上下文管理器類型 - 比較複雜暫時 不用掌握
- 二進制序列類型 bytes bytesarray memoryview
- 真值檢測
- 比較運算符
- 邏輯運算符
- 如何判斷 一個對象 是什麼類型- type(xxx)
今天 我們繼續講 python中基礎 數據類型 元祖 ，字典 ，集合，不可變集合。 內容 挺多的，要理解每種數據結構 的特點，不一定所有的方法 都要記住，只要常用的方法可以記住即可。內容比較多，多多實踐，多多練習。
元祖 tuple
元祖是一種 可以存放元素的一個容器，這點 和list 有點像。元祖 也是支持 索引的 。即也可以通過索引 訪問 元素。
元祖最大的特點 就是不可變性。 就是元祖一旦創建完成後，就不能改變。 不能添加元素，不能刪除元素，不能修改元素，不能排序元素 等等。
所以元祖 給你的感覺就是一種 ‘只讀’ 模式。
元祖 也可以存放不同類型的元素的。
元祖的創建方法
創建一個元祖有3種方式
注意創建只有一個元素的元祖 的寫法 最後要加逗號
>>> # 第一種方式
>>> t = 'apple','orange','banana'
>>> t
('apple', 'orange', 'banana')
>>> type(t)
<class 'tuple'>
>>> # 支持索引
>>> t[0]
'apple'
>>> t[1]
'orange'
>>> t[1:3]
('orange', 'banana')
>>> # 第二種方式，創建一個空的元祖
>>> t = tuple()
>>> t
()
>>> type(t)
<class 'tuple'>
>>> ##
>>> t = tuple([1,2,3])
>>> t
(1, 2, 3)
>>> type(t)
<class 'tuple'>
>>> # 第三種方式
>>> t = (1,2,3,4,5)
>>> type(t)
<class 'tuple'>
>>> t
(1, 2, 3, 4, 5)
創建只有一個元素的元祖
>>> t = (1,) # 注意這裏
>>> type(t)
<class 'tuple'>
>>> t
(1,)
>>> # 沒有 加逗號， 就不能變成 一個元祖，這點要注意
>>> t = (1)
>>> type(t)
<class 'int'>
>>> t
1
元祖的不可變性的理解
來嘗試 修改一下元素
>>> t = (1,2,3,4,5)
>>> t
(1, 2, 3, 4, 5)
>>> type(t)
<class 'tuple'>
>>> t[0]
1
>>> t[0] = 'one'
Traceback (most recent call last):
File "<input>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment
當我嘗試修改了 這個值的時候，發現 報錯 TypeError ， 這是因爲 tuple內的元素不允許修改。
注意 不允許修改是指 這個位置的不允許 別的元素替換掉。 上面的例子 0 號位置， ‘one’ 想要替換 0號位置的元素 是不允許的 。
但是如果 0 位置的元素本身是一個可變類型比如 list , 這個時候 list.append 就可以 添加元素。
來看下例子：
t[1] 的元素 是一個 list , 這個時候 我就可以 調用list.append 來添加元素了 。
>>> t = (1,[2,3,4],5,6)
>>> t
(1, [2, 3, 4], 5, 6)
>>> t[1]
[2, 3, 4]
>>> t[1].append('new')
>>> t
(1, [2, 3, 4, 'new'], 5, 6)
元祖是不可變的嗎？ 爲啥這裏就可以變了？
首先你要理解 我說的不可變的含義 。 只在t[1] = xxxxx, 而t[1] 這個元素本身 他是可變類型，所以當然可以添加元素，修改元素的。
看下例子
>>> t
(1, [2, 3, 4, 'new'], 5, 6)
>>> t[1]='frank'
Traceback (most recent call last):
File "<input>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment
好了 我想 你應該 能夠理解了吧。
元祖的方法
對 tuple 有哪些可以操作呢？
首先 可以for 去遍歷
t = (1, [2, 3, 4, 'new'], 5, 6)
for item in t:
print(item)
>>> t
(1, [2, 3, 4, 'new'], 5, 6)
>>> for item in t:
... print(item)
...
1
[2, 3, 4, 'new']
5
6
元祖解包
解包 : 把元素分到不同變量上面
這樣就可以把 元祖的元素 取出來， 當然也可以用索引的方式。
>>> t
(1, 2, 3)
>>> a,b,c = t
>>> a
1
>>> b
2
>>> c
3
解包 有的時候 你只想要 開頭，和結尾 這兩個元素 .
>>> t
(1, [2, 3, 4, 'new'], 5, 6)
>>> first,*mid,end = t
>>> first
1
>>> end
6
>>> mid
[[2, 3, 4, 'new'], 5]
python 解包小技巧. 如何 獲取 開始和末尾的位置的元素。
還可以 獲取 元素的長度 len
這裏要注意，這裏是 一個元素的位置 就是一個長度。 如果一個位置上 有100個元素，也只能算1 。
就像下面的例子 ，長度不是7 ，而是4 ，因爲 [2, 3, 4, ‘new’] 這是一個元素，一個整體，作爲元祖的一個元素。
>>> t
(1, [2, 3, 4, 'new'], 5, 6)
>>> len(t)
4
好 咱們繼續 下一個數據結構 字典
字典 dict
字典 是python中的一個映射類型， 並且也是可變的 。 字典 是由 一對 鍵值對來組成的 。d = {key:value} 字典裏面的元素 一般 用 key:value 這種形式來表示。
爲啥會有字典呢？
比如我有一個人的信息 存儲了個人的一些 信息 ，
分別是 姓名 身高，愛好，體重等。
如果沒有字典 這種結構 ，我們可以使用 list,tuple 來保存這些信息
p = ['frank', 165, 'swimming', 60]
# or
p = ('frank', 165, 'swimming', 60)
如果獲取 這個人姓名，我們直接去第一個元素p[0]，獲取體重 直接去最後一個元素p[-1]
但這樣 也沒有問題， 但是如果這個人的信息 越來越多， 我們很難 清晰的知道 第幾號位置 代表是什麼含義， 只記錄位置 信息 獲取元素的方式 對我來說 不夠友好
我希望 p[‘name’] 獲取的就是這個人的姓名， p[‘hobby’] 就是這個人的愛好。
這個時候 字典 就誕生了。
現在 來定義一個字典,通過 key:value 這種形式 既可。
person = {
'name': 'frank',
'height': 165,
'hobby': 'swimming',
'weight': 60
}
在consle 裏面看下
>>> person
{'name': 'frank', 'height': 165, 'hobby': 'swimming', 'weight': 60}
>>> person['name']
'frank'
>>> person['weight']
60
>>> person['hobby']
'swimming'
>>> person
{'name': 'frank', 'height': 165, 'hobby': 'swimming', 'weight': 60}
看這樣是不是很方便， 我們可以通過過名稱(key), 獲取我們想要的值。 這樣相對來說 是不是更友好點，而不是通過下標 去找 對應的值, 向 list 那樣，你需要記住每個屬性的位置，就比較麻煩。
字典的創建方法
>>>
>>> a = dict(one=1, two=2, three=3)
... b = {'one': 1, 'two': 2, 'three': 3}
... c = dict(zip(['one', 'two', 'three'], [1, 2, 3]))
... d = dict([('two', 2), ('one', 1), ('three', 3)])
... e = dict({'three': 3, 'one': 1, 'two': 2})
>>>
>>> a
{'one': 1, 'two': 2, 'three': 3}
>>> b
{'one': 1, 'two': 2, 'three': 3}
>>> c
{'one': 1, 'two': 2, 'three': 3}
>>> d
{'two': 2, 'one': 1, 'three': 3}
>>> e
{'three': 3, 'one': 1, 'two': 2}
>>> #創建一個空字典
>>> f = dict()
對於第一，第二種 比較常用的，後面的知道，用的時候看看就行了。
字典的特點
- 字典 是由鍵值對組成的， 對鍵 的要求是一個不可變類型也行， 不是所有的 類型都能作爲鍵。
- 字典是可變類型，可以修改字典key 對應的值 。但是key 本身是不可變的。
- 字典 是無序的，永遠不要希望 字典 key 按照一定順序返回，即使你看起來是有序的，也不要依靠這個特性。如果 你真的需要 字典有序，以後會介紹一種數據結構來解決這個問題，這裏提一下
OrderedDict這個是 字典的子類 。 你可能對子類 沒有的認識，就是和字典很像。
好來說明一下：
來構造一個字典
>>> p ={[1,2,3]:1}
Traceback (most recent call last):
File "<input>", line 1, in <module>
TypeError: unhashable type: 'list'
這裏我想用 list 作爲一個 key ， 來創建一個字段， 發現報錯了， TypeError 爲啥，說 list 是 不可哈希的類型。
這裏不可哈希的類型，意思就說list 本身是可以修改的，不能作爲key 來使用。
我來改一下,把list 換成 一個tuple 發現可以。 因爲 tuple 不可變類型。
>>> p ={(1,2,3):1}
>>> p
{(1, 2, 3): 1}
>>> p[(1,2,3):1]
>>> p[(1,2,3)]
1
好，讓我們總結一下，字典中的key 必須是不可變類型，比如 tuple ,str 可以作爲key，list 是不可以作爲key 的。
你可能 以爲你知道了key 的不可變性 ， 真是 tuple 作爲一個字典的key 嗎？
如果 我的key= (1,2,3,[4,5,6]) 這是一個tuple ，那麼這個 可以作爲字典的key 嗎？ 實踐出真知，來看下吧
>>> p ={(1,2,3,[4,5,6]):1}
Traceback (most recent call last):
File "<input>", line 1, in <module>
TypeError: unhashable type: 'list'
發現並不能 作爲key , 我是一個元祖，爲啥卻不能作爲key 呢？
原因其實通過報錯信息 已經比較清楚，tuple 有一個元素 是list 這種key 是可以改變的。這樣 tuple 整體 就是一個不可哈希的。
>>> key
(1, 2, 3, [4, 5, 6])
>>> type(key)
<class 'tuple'>
>>> hash(key)
Traceback (most recent call last):
File "<input>", line 1, in <module>
TypeError: unhashable type: 'list'
所以判斷一個 元素 可以作爲字典的key, 只要 **hash(元素) ** 如果可以 返回值，說明這個元素是可以作爲key 的。
好了，關於字典的key 的限制，我希望你可以慢慢理解。
第二個特點 字典 是可以修改的.
>>> person = {
... 'name': 'frank',
... 'height': 165,
... 'hobby': 'swimming',
... 'weight': 60
... }
...
>>>
>>> person['height']
165
>>> # 修改 height
>>> person['height']=166
>>> person
{'name': 'frank', 'height': 166, 'hobby': 'swimming', 'weight': 60}
第三個 字典的無序性
是指 key 的無序性，雖然我定義的key 的時候 是 name,height,hobby weight 這個順序， 但是這不代表 字典是有序的。
來遍歷 一下字典，發現結果
person = {
'name': 'frank',
'height': 165,
'hobby': 'swimming',
'weight': 60
}
for k, v in person.items():
print(k, v)
"""結果如下
name frank
height 165
hobby swimming
weight 60
"""
返回的樣子，和我們定義key 的順序 是一樣的， 但是 我坦然告訴你 這只是一個巧合，不能說明 字典是有序的。
字典 的遍歷
由於字典是有 key,value 組成了， 想到遍歷，可能你已經想到用 for 語句了，對哦，我們是可以用 for 語句遍歷字典的。
直接遍歷 ，則會 返回字典的key
>>> person
{'weight': 60, 'name': 'frank', 'height': 165, 'hobby': 'swimming'}
>>> for key in person:
... print(key)
...
weight
name
height
hobby
>>> # 這樣可以的。
>>> for key in person.keys():
... print(key)
...
weight
name
height
hobby
如果想遍歷字典的 value
>>> for key in person.values():
... print(key)
...
60
frank
165
swimming
同時遍歷 key ,value 的值
>>> for k,v in person.items():
... print(k,v)
...
weight 60
name frank
height 165
hobby swimming
字典視圖對象
Dictionary view objects
其實 只要看下 keys() ,values() ,items() 返回就明白了。
這些返回 都是 dict_keys dict_values , dict_items ,這些類型都是可以迭代的.
>>> person.items()
dict_items([('weight', 60), ('name', 'frank'), ('height', 165), ('hobby', 'swimming')])
>>> person.keys()
dict_keys(['weight', 'name', 'height', 'hobby'])
>>> person.values()
dict_values([60, 'frank', 165, 'swimming'])
字典的常用方法
獲取字典長度
即 字典中key 的個數 ,len()
>>> p
{'weight': 60, 'name': 'frank', 'height': 165, 'hobby': 'swimming'}
>>> len(p)
4
判斷一個key ,是否屬於字典中的 key
in , not in
>>> p ={'weight': 60, 'name': 'frank', 'height': 165, 'hobby': 'swimming'}
>>> 'anme' in p
False
>>> 'name' in p
True
>>> p
{'weight': 60, 'name': 'frank', 'height': 165, 'hobby': 'swimming'}
>>> 'aaa' not in p
True
>>> 'name ' in p # 這裏name 後面有空格，索引這個和name 不一樣的
False
>>> 'name' in p
True
獲取 字典的keys, values ,k_v
>>> p.keys()
dict_keys(['weight', 'name', 'height', 'hobby'])
>>> p.values()
dict_values([60, 'frank', 165, 'swimming'])
>>> p.items()
dict_items([('weight', 60), ('name', 'frank'), ('height', 165), ('hobby', 'swimming')])
添加一對鍵值對 ,直接 指定 k,v 賦值 就可以了。
這裏要注意 如果你指定的key 已經在 字典中的， 會被覆蓋的。 並且不會有任何提示，這樣就要注意 你的數據安全問題， 這個一般要檢查 有沒有key ，在進行 操作。
>>> p['gender']='male'
>>> p
{'weight': 60, 'name': 'frank', 'height': 165, 'hobby': 'swimming', 'gender': 'male'}
>>> p['name']='xiaoming'
>>> p
{'weight': 60, 'name': 'xiaoming', 'height': 165, 'hobby': 'swimming', 'gender': 'male'}
刪除一對鍵值對 pop ，popitem
popitem() 會隨機返回一對鍵值對，(key,value) 是一個元祖 ，然後從字典中刪除 。
如果字典是空的，則會報錯 KeyError
>>> p
{'weight': 60, 'name': 'frank', 'height': 165, 'hobby': 'swimming'}
>>> r = p.popitem()
>>> r
('hobby', 'swimming')
>>> type(r)
<class 'tuple'>
>>> r = p.popitem()
>>> type(r)
<class 'tuple'>
>>> p.popitem()
('name', 'frank')
>>> p.popitem()
('weight', 60)
>>> p.popitem()
Traceback (most recent call last):
File "<input>", line 1, in <module>
KeyError: 'popitem(): dictionary is empty'
>>> p
{}
pop(key) 可以指定刪除 指定的key ,返回對應的value 值。 如果指定的key 不存在 字典中，會報錯 KeyError 的錯誤。
>>> p
{'weight': 60, 'name': 'frank', 'height': 165, 'hobby': 'swimming'}
>>> p.pop('name')
'frank'
>>> p
{'weight': 60, 'height': 165, 'hobby': 'swimming'}
>>> p.pop('hobby')
'swimming'
>>> p
{'weight': 60, 'height': 165}
淺拷貝 copy
還記得 如何查看 內存地址嗎， id(對象) ，這樣 就可以看到了，下面的例子 發現兩個值不一樣的。
>>> p
{'weight': 60, 'height': 165}
>>> p2 = p.copy()
>>> p2
{'weight': 60, 'height': 165}
>>> p
{'weight': 60, 'height': 165}
>>> id(p),id(p2)
(1404177795016, 1404177796776)
合併兩個字典
dict.update(other_dict)
>>> p
{'weight': 60, 'height': 165}
>>> nums = {"one":1,"two":2}
>>> p
{'weight': 60, 'height': 165}
>>> p.update(nums)
>>> p
{'weight': 60, 'height': 165, 'one': 1, 'two': 2}
向字典中添加元素
直接賦值就可以了，如果沒有key 會創建一個新的鍵值對 。如果有 會覆蓋掉原來的鍵值對。
>>> p
{'weight': 60, 'name': 'frank'}
>>> p['one']=1
>>> p['two'] = 2
>>> p
{'weight': 60, 'name': 'frank', 'one': 1, 'two': 2}
獲取 字典的key 對應的值 get vs. []
關於字典獲取 值 有兩種方式 get [] 操作符來獲取。
兩種稍微有一點區別
如果是get 如果key 不在字典裏面 get(key,default) 會返回 default .不會報錯
[] 這種 獲取的時候，如果 key 不在字典中 會報錯KeyError
>>> p
{'weight': 60, 'height': 165, 'one': 1, 'two': 2}
>>> p.get('one')
1
>>> p['one']
1
來獲取一個不存在的key 顯然會報錯的。
>>> p = {'weight': 60, 'height': 165, 'one': 1, 'two': 2}
>>> p['hhh']
Traceback (most recent call last):
File "<input>", line 1, in <module>
KeyError: 'hhh'
>>> p.get('hhh')
>>> p.get('hhh',111)
111
setdefault 操作
setdefault(key,default)
有的時候 我們想給字典設置一個默認值 ，如果key 已經存在了，那麼使用現在已經有的值. 不會對字典有任何改變 ，同時返回這個字典 key 對應的value
如果沒有這個key, 那麼把這個值 key=default 放到字典中 ,同時返回這個新設置的值 value .
>>> p
{'weight': 60, 'height': 165, 'one': 1, 'two': 2}
>>> p.setdefault('one')
1
>>> p.setdefault('one',10)
1
>>> p
{'weight': 60, 'height': 165, 'one': 1, 'two': 2}
>>> p.setdefault('three',3)
3
>>> # 這裏 three=3 放入到字典中了
>>> p
{'weight': 60, 'height': 165, 'one': 1, 'two': 2, 'three': 3}
字典這種結構 在python 中會經常使用 需要好好掌握。這種數據結構很方便，也是未來 工作中使用最常用的 數據結構 要好好掌握一下。
集合 set
集合是可以存放 一種 無序 ，不重複的元素的一種數據結構 。 如果理解了 字典的結構，那麼集合就很好理解了，
集合結構相當於 字典中只有key ,沒有value 的 這種結構。
來創建一個集合
可以使用大括號 { } 或者 set() 函數創建集合.
注意：創建一個空集合必須用set() , 而不是 { }，因爲 { } 是用來創建一個空字典。
>>> s = {"one", "two", 'three', 'four', 'five'}
>>> s
{'one', 'four', 'five', 'two', 'three'}
>>> # 第二種創建方式 通過傳入一個list 來創建
>>> attrs = set(['name','gender','hobby'])
>>> attrs
{'name', 'hobby', 'gender'}
集合特點
無序性
首先 說明一下無序性 ，集合的所有元素是無序的。就像字典的key 一樣 是無序的。
s = {"one", "two", 'three', 'four', 'five'}
for i in range(5):
print(f"第{i}次 打印s ={s}")
"""結果如下：
第0次 打印s ={'three', 'four', 'five', 'one', 'two'}
第1次 打印s ={'three', 'four', 'five', 'one', 'two'}
第2次 打印s ={'three', 'four', 'five', 'one', 'two'}
第3次 打印s ={'three', 'four', 'five', 'one', 'two'}
第4次 打印s ={'three', 'four', 'five', 'one', 'two'}
"""
定義 set 的時候,是按照數字的順序定義的，但是打印的時候卻沒有按照數字的順序打印，如果 是list 肯定是 按照 定義的順序打印的。
>>> s = {"one", "two", 'three', 'four', 'five'}
... nums = ["one", "two", 'three', 'four', 'five']
>>>
>>> s
{'one', 'four', 'five', 'two', 'three'}
>>> nums
['one', 'two', 'three', 'four', 'five']
不可重複性
我們知道在list 中 元素是可以放任何類型的，並且可以是重複的元素。原因是因爲 在list中 每個元素 都會有一個 索引，通過索引 找到這個元素，不論這個元素放在哪裏 只要知道 這個元素的索引，我就可以獲取到值。
而在集合中 沒有 索引這個東西。 它並不能區別對待 相同的元素，
看下面的例子
>>> nums= ['one', 'two', 'three', 'four', 'one']
>>> nums
['one', 'two', 'three', 'four', 'one']
>>> # 存入了 兩個 one 元素
>>> s = {'one', 'two', 'three', 'four', 'one'}
>>> s
{'one', 'two', 'three', 'four'}
發現 當我打印的時候 只有一個one，這就是 集合元素的不可重複性。有時候需要對一些數據去重操作 ，這種數據結構 天生 適合做這些事情。
可變性
這個好理解，可以向集合裏面 添加元素 ，刪除元素 ，修改元素等。
>>> s = {'one'}
>>> s
{'one'}
>>> s.add('two')
>>> s
{'one', 'two'}
元素本身的不可變性
還有一個小問題 要注意，不是所有的元素 都是可以放入 到 集合中的，爲啥，因爲 集合中的元素 要求 不可變性，即集合中的每一個元素 都是 可以哈希的。
現在向集合中 添加一個 list
>>> s = {"one", "two"}
>>> s
{'one', 'two'}
>>> s.add([3,4,5])
Traceback (most recent call last):
File "<input>", line 1, in <module>
TypeError: unhashable type: 'list'
發現報錯了，原因 就是list 是可變的，所以不能放在 集合裏面。
集合常用方法
增刪改查 ，集合運算
# 創建一個set
s = set([3,5,9,10])
s
{9, 10, 3, 5}
t = set("Hello") #創建一個唯一字符的集合
t
{'H', 'o', 'e', 'l'}
# 也可以這樣創建一個集合
# s = {3,5,9,10}
#創建一個空集合
s = set()
# 添加元素
#如果 已經存在的元素,不會重新添加
s = {3,5,9,10}
s.add(5)
s
{9, 10, 3, 5}
s.add(66)
s
{66, 3, 5, 9, 10}
#判斷一個元素是否在 集合可以用 in
5 in s
True
6 in s
False
66 in s
True
# 求集合長度
len(s)
5
# 刪除元素集合中的一個元素
>>> s.remove(66)
>>> s
{3, 5, 9, 10}
# remove 刪除一個不存在的元素 會報錯 KeyError
s.remove('frank')
Traceback (most recent call last):
File "<input>", line 1, in <module>
KeyError: 'frank'
# discard 也可以用來刪除 元素, 如果不存在不會報錯, 不會對集合做任何操作直接返回None.
# Remove an element from a set if it is a member.
# If the element is not a member, do nothing.
>>> s = {3, 5, 9, 10}
>>> s.discard('frank')
>>> s
{3, 5, 9, 10}
# 集合的拷貝 s.copy 這是一個淺拷貝
>>> s = set()
>>> s.add(1)
>>> s.add(10)
>>> s.add(5)
>>> s
{1, 10, 5}
>>> s.add(7)
>>> s
{1, 10, 5, 7}
>>> s.copy()
{1, 10, 5, 7}
>>> s2 = s.copy()
>>> s2
{1, 10, 5, 7}
#集合運算裏面 有交 並 補 差集 運算
>>> s={1,2,3,4}
>>> s2 = {3,4,5,6,7}
>>> s,s2
({1, 2, 3, 4}, {3, 4, 5, 6, 7})
>>> s
{1, 2, 3, 4}
>>> s2
{3, 4, 5, 6, 7}
>>> s& s2
{3, 4}
>>> s.intersection(s2) # 交集
{3, 4}
>>> s
{1, 2, 3, 4}
>>> s
{1, 2, 3, 4}
>>> s2
{3, 4, 5, 6, 7}
>>> s.difference(s2) # 差集
{1, 2}
>>> s - s2
{1, 2}
# 集合的並集
>>> s.union(s2)
{1, 2, 3, 4, 5, 6, 7}
>>> s|s2
{1, 2, 3, 4, 5, 6, 7}
**注意 ** 集合刪除元素 remove 和discard 的區別
集合的交集 和差集 運算
交集 s & s2 或 s.intersection(s2) 交集運算
差集 s - s2 或 s.difference(s2) 差集運算
並集 s |s2 或 s.union(s2) 並集運算
>>> s
{1, 2, 3, 4}
>>> s2
{3, 4, 5, 6, 7}
>>> s.symmetric_difference(s2)
{1, 2, 5, 6, 7}
>>> s^s2
{1, 2, 5, 6, 7}
刪除 兩個集合相同的元素,其他的元素構成一個集合返回. 比如上面的例子, 3,4 是公共元素,去掉兩個集合的公共元素,其他的元素構成一個新的集合返回. {1,2,5,6,7}
s^s2 或 s.symmetric_difference(s2)
判斷集合之間的關係
s.issubset(other) 判斷 自己是不是 other 的子集.即判斷 s <= other 返回 True or False
s.issuperset(other) 判斷 s >= other 返回 True or False
issubset(other)
set <= other
Test whether every element in the set is in other.
# 這個方法是判斷 自己是不是 另一個集合的子集
issuperset(other)
Report whether this set contains another set.
# 這個方法 判斷 自己 是否包含另一個集合.
>>> s
{1, 2, 3, 4}
>>> s2
{1, 2, 3, 4, 5, 6}
>>>
>>> s.issubset(s2)
True
>>> s2.issuperset(s)
True
xxxx_update 方法
set裏面 還有很多 xxxxx_update 方法
這裏 的作用 把更新的結果 直接寫回到原集合裏面.就相當於原地修改集合
s.difference_update(other) # 求差集把結果更新到 s 集合裏面
s.intersection_update(other) # 求交集把結果更新到 s 集合裏面
s.symmetric_difference_update(other) # 求 這個運算的結果 把結果寫到s裏面.
下面 舉個例子:
# 差集更新
s = {1, 2, 3, 4}
s2 = {3, 4, 5, 6, 7}
s - s2
{1, 2}
s.difference(s2)
{1, 2}
s
{1, 2, 3, 4}
s2
{3, 4, 5, 6, 7}
s.difference_update(s2)
# 交集更新
s = {1, 2, 3, 4}
s2 = {3, 4, 5, 6, 7}
s.intersection(s2)
{3, 4}
s.intersection_update(s2)
s
{3, 4}
# symmetric_difference_update 我也不知道叫什麼運算,暫且叫異或運算吧, 把結果更新到 s 裏面.
s
{1, 2, 3, 4}
s2
{3, 4, 5, 6, 7}
s.symmetric_difference(s2)
{1, 2, 5, 6, 7}
s.symmetric_difference_update(s2)
s
{1, 2, 5, 6, 7}
# s.update(other)
# update 方法, 將一個其他的集合 更新到自己的集合裏面. 相當於批量add 操作
# 如果有相同的元素, 也只會有一個更新的到集合裏面. 不會報錯. (集合本身是不重複的特性)
>>> s
{1, 2, 7}
>>> s2 = {11,22,33}
>>> s.update(s2)
>>> s
{1, 2, 33, 22, 7, 11}
>>> s2
{33, 11, 22}
方法 pop()
s.pop () 隨機 刪除 集合中的元素 ,並且返回該元素 , 如果集合是空的,會拋異常KeyError
>>> s = {1,34,56,32,11,35,67,89,56}
>>> s
{32, 1, 34, 35, 67, 11, 56, 89}
>>> s.pop()
32
>>> s.pop()
1
>>> s.pop()
34
>>> s.pop()
35
>>> s.pop()
67
>>> s.pop()
11
>>> s.pop()
56
# 清空集合
# s.clear() 清空集合,使其變成一個空集合.
s = {1,34,56,32,11,35,67,89,56}
s.clear()
s
set()
集合差不多 就說的這裏，工作中用到這種結構 大部分 都是用來去重操作，偶爾也會用到集合的運算 。
不可變集合 frozenset
還有一種 結構 frozenset 看到這個名字，可能 你就能猜到，這種結構是一種不可變集合。
就是不允許修改集合本身，不能添加，修改，刪除。相當於 set 的 只讀模式
創建一個只讀集合
>>> read_only_nums = frozenset(["one", "two", 'three', 'four'])
>>> read_only_nums
frozenset({'one', 'two', 'three', 'four'})
>>> read_only_nums.copy()
frozenset({'one', 'two', 'three', 'four'})
>>> s2 = read_only_nums.copy()
frozenset 的常用方法 幾乎和set 一樣，對於改變集合的方法 都沒有 ,其他的方法都有。
比如 判斷 是否在元素是否在集合中，獲取集合長度，複製一個集合等
常用的方法 如下
[‘copy’, ‘difference’, ‘intersection’, ‘isdisjoint’, ‘issubset’, ‘issuperset’, ‘symmetric_difference’, ‘union’]
拷貝，求差集，交集，判斷有沒有公共元素，判斷是不是子集，判斷是不是父集 ，對稱差分，並集
總結
今天 我們來學習python 最常用的數據結構，瞭解常用的方法。 這些都是我們 用來操作數據的武器，所以要好好學習，知道每種數據結構的特性，以及適用場景。這樣 遇到一個問題的時候 ，才能想起來去適用這樣的數據結構。 加油 ，好好學。