容器型別的進階使用（字典、集合）

字典的相關函式

fromkeys

將一個容器中的全部元素都作為字典的鍵，并設定默認值，批量的創建鍵值對

lst = ['key0', 'key1', 'key2']
dct = {}.fromkeys(lst, None)
print(dct)  # {'key0': None, 'key1': None, 'key2': None}

但是我們要注意一個問題，因為這些鍵值對的值都是來自于同一個記憶體地址當中的，如果我們設定的默認值是一個可變的資料型別的話，那么修改其中的一個值，所有的鍵值的值都會發生改變，這是災難性的，

lst = ['key0', 'key1', 'key2']
dct = {}.fromkeys(lst, [1])
print(dct)  # {'key0': [1], 'key1': [1], 'key2': [1]}

# 我們只是修改了key0的值，但是整個所有使用fromkeys創建的資料全部被修改了
dct['key0'][0] = 2
print(dct)  # {'key0': [2], 'key1': [2], 'key2': [2]}

所以我們一般的情況下可以設定默認值為None，因為None默認開辟一個小資料池的地址，永遠不會發生變化，且None表示什么也沒有，對于記憶體地址的占用是獨一致的，當None變成任何的資料型別的時候，都不用擔心其它的None也一起修改，類似的資料型別還有1、2等數字型別，這些資料型別的特點就是具有記憶體的快取機制作為保護，

詳情可見，記憶體的快取機制，

lst = ['key0', 'key1', 'key2']
dct = {}.fromkeys(lst, None)
print(dct)  # {'key0': None, 'key1': None, 'key2': None}

dct['key0'] = 'msr20666'
print(dct)	# {'key0': 'msr20666', 'key1': None, 'key2': None}

pop

通過鍵洗掉指定的鍵值對，如果沒有該鍵就會報錯，但是可以設定默認值，防止找不到指定鍵而報錯，

# 指定key0鍵洗掉
dct = {'key0': None, 'key1': None, 'key2': None}
dct.pop('key0')
print(dct)  # {'key1': None, 'key2': None}


# 指定key4鍵洗掉，但是沒有該鍵，報錯
# dct.pop('key4') # error


# 指定默認值，預防報錯
res = dct.pop('key4', '沒有該鍵')
print(dct)  # {'key1': None, 'key2': None}
print(res)  # 沒有該鍵

popitem

洗掉最后一個鍵值對，

dct = {'one': 1, 'two': 2, 'three': 3}
dct.popitem()
print(dct)  # {'one': 1, 'two': 2}

clear

清空字典

dct = {'one': 1, 'two': 2, 'three': 3}
dct.clear()
print(dct)  # {}

update

用來批量的更新字典的鍵，如果這鍵存在就更新對應的值，如果這個鍵不存在，就創建一個新的鍵值對，

# 方式一：定義一組新的字典，然后將新字典跟新至舊的字典當中（推薦使用）
dct = {'one': 1, 'two': 2, 'three': 3}
new_dct = {'one': 11, 'two': 22, 'six': 666}

dct.update(new_dct)
print(dct)  # {'one': 11, 'two': 22, 'three': 3, 'six': 666}


# 方式二：在函式中直接跟著更新鍵值對（不推薦使用）
'''
在函式當中的直接使用關鍵字引數進行字典鍵值對的更新，關鍵字表示鍵，對應的值就是值；
缺點是關鍵字的命名和變數的命名是一樣的，比如不能使用數字開頭，那么如果字典鍵是整型那么就不能修改它對應的值了，
'''
dct = {1:1, 2:2, 'one':1, 'two':2}

# 關鍵字的命名不能使用數字開頭，那么就無法修改鍵是整型的鍵值對
# 所以這也是推薦是按照變數名的標準去命名鍵名的原因之一
# dct.update(1=1)   # error

dct.update(one=11)
print(dct)  # {1: 1, 2: 2, 'one': 11, 'two': 2}

# 可以一次性修改多個值
dct.update(one=111, two=22, three=33)
print(dct)  # {1: 1, 2: 2, 'one': 111, 'two': 22, 'three': 33}

get

查找資料，指定一個鍵獲取對應的值

dct = {'one': 1, 'two': 2, 'three': 3}


# 指定鍵獲取資料
res = dct.get('one')
print(res)  # 1

# 如果沒有這個鍵，就回傳None
res = dct.get('six')
print(res)  # None

# 可以設定默認值，如果查不到資料就回傳設定的默認值
res = dct.get('six', '沒有找到這個鍵')
print(res)  # 沒有找到這個鍵

# 也可以直接指定鍵來查看對應的資料，但是如果沒有這個鍵就會直接報錯
# res = dct['six']  # error 找不到該資料

keys

將字典的鍵組成一個叫做dict_keys的可迭代物件，這是一個特殊的資料型別，可以強轉成為其它的資料型別，

dct = {'one': 1, 'two': 2, 'three': 3}

res = dct.keys()

print(res)          # dict_keys(['one', 'two', 'three'])
print(type(res))    # <class 'dict_key

values

將字典中的值組成一個叫做dict_values的可迭代物件當中，也是可以強轉成其它的容器資料型別，

dct = {'one': 1, 'two': 2, 'three': 3}

res = dct.values()

print(res)          # dict_values([1, 2, 3])
print(type(res))    # <class 'dict_values'>

items

將字典中的鍵值對湊成一個個的元組，組成叫做dict_items的可迭代物件中，

dct = {'one': 1, 'two': 2, 'three': 3}

res = dct.items()

print(res)          # dict_items([('one', 1), ('two', 2), ('three', 3)])
print(type(res))    # <class 'dict_items'>

集合的相關函式

集合的增刪改查

集合是無序資料，因此不能進行查找和修改操作；

add

往集合中單個的添加資料

setvar = {1, 2, 3, 'hello', 'msr', 'msr20666'}
setvar.add('motherland')
print(setvar)   # {1, 2, 3, 'motherland', 'hello', 'msr20666', 'msr'}

update

迭代的添加資料

setvar = {1, 2, 3, 'hello', 'msr', 'msr20666'}
lst = ('china', 'america', 'russia')
setvar.update(lst)
print(setvar)   # {1, 2, 3, 'msr', 'america', 'russia', 'china', 'hello', 'msr20666'}

pop

隨機的洗掉其中的一個資料

setvar = {1, 2, 3, 'hello', 'msr', 'msr20666'}
setvar.pop()
print(setvar)   # {2, 3, 'msr', 'msr20666', 'hello'}

remove

洗掉集合中指定的一個值，如果這個值不存在，就會報錯

setvar = {1, 2, 3, 'hello', 'msr', 'msr20666'}
setvar.remove('hello')
print(setvar)   # {1, 2, 3, 'msr', 'msr20666'}

setvar.remove(4)    # error，這個值不存在

discard

洗掉集合中指定的一個值，如果這個值不存在也不會報錯

setvar = {1, 2, 3, 'hello', 'msr', 'msr20666'}
setvar.discard('hello')
print(setvar)   # {1, 2, 3, 'msr20666', 'msr'}

res = setvar.discard(4)
print(res)      # None

clear

清空集合

setvar = {1, 2, 3, 'hello', 'msr', 'msr20666'}
setvar.clear()
print(setvar)   # set()

集合的交叉并補

intersection

交集，就是兩個集合中相同的資料，兩個集合的交集是相同的，簡寫 &

set0 = {1, 2, 3, 4, 5, 6}
set1 = {1, 2, 3, 7, 8, 9, 0}

res = set0.intersection(set1)
print(res)  # {1, 2, 3}

res = set1 & set0
print(res)  # {1, 2, 3}

difference

差集，差集就是兩個集合當中不相同的資料，注意兩個集合中的差集是不同的，簡寫 -

set0 = {1, 2, 3, 4, 5, 6}
set1 = {1, 2, 3, 7, 8, 9, 0}

res = set0.difference(set1)
print(res)  # {4, 5, 6}

res = set1 - set0
print(res)  # {0, 8, 9, 7}

union

并集，是兩個集合的所有資料，但是交集部分只會存在一個，兩個集合的并集是相同的，簡寫使用 |

set0 = {1, 2, 3, 4, 5, 6}
set1 = {1, 2, 3, 7, 8, 9, 0}

res = set0.union(set1)
print(res)  # {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}

res = set1 | set0
print(res)  # {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}

symmetric_difference

對稱差集，是兩個集合中除去并集的資料，就是兩者的差集，兩者的對稱差集是相同的，簡寫使用 ^

set0 = {1, 2, 3, 4, 5, 6}
set1 = {1, 2, 3, 7, 8, 9, 0}

res = set0.symmetric_difference(set1)
print(res)  # {0, 4, 5, 6, 7, 8, 9}

res = set1 ^ set0
print(res)  # {0, 4, 5, 6, 7, 8, 9}

補集，如果兩個集合，其中的一個集合包含另一個集合的所有資料，那么這個集合就是另一個集合的父集，反之就是子集，父集當中子集不存在的資料就是子集的補集

set0 = {1, 2, 3, 4, 5, 6, 7, 8}
set1 = {1, 2, 3, 4}

res = set0.symmetric_difference(set1)
print(res)  # {8, 5, 6, 7}

res = set1.symmetric_difference(set0)
print(res)  # {5, 6, 7, 8}

issuperset

判斷是否是指定集合的父集，回傳布林值，簡寫使用 > 或者 =+

set0 = {1, 2, 3, 4, 5, 6, 7, 8}
set1 = {1, 2, 3, 4}

res = set0.issuperset(set1)
print(res)  # True

res = set1 > set0
print(res)  # False

res = set1 >= set0
print(res)  # False

issubset

判斷是否是指定集合的子集，回傳布林值，簡寫使用 < 或者 <=

set0 = {1, 2, 3, 4, 5, 6, 7, 8}
set1 = {1, 2, 3, 4}

res = set0.issubset(set1)
print(res)  # False

res = set1 < set0
print(res)  # True

res = set1 <= set0
print(res)  # True

isdisjoint

檢測兩個集合是否不相交

set0 = {1, 2, 3, 4, 5, 6, 7, 8}
set1 = {1, 2, 3, 4}
res = set0.isdisjoint(set1)
print(res)  # False


set0 = {1, 2, 3}
set1 = {4, 5, 6}
res = set0.isdisjoint(set1)
print(res)  # True

冰凍集合

冰凍集合可以理解為將集合冰凍封印，這樣集合不能進行添加洗掉元素等操作，只能進行交叉并補的操作，

setvar = {1, 2, 3, 4}
lstvar = [1, 2, 3, 4, 5]

fzs0 = frozenset(setvar)
print(fzs0)         # # frozenset({1, 2, 3, 4})
print(type(fzs0))   # <class 'frozenset'>

fzs1 = frozenset(lstvar)
print(fzs1)         # frozenset({1, 2, 3, 4, 5})
print(type(fzs1))   # <class 'frozenset'>

冰凍集合不能進行增刪改查的操作

fzs0.clear()        # error

可以進行關于交叉并補的操作

res = fzs0.issuperset(fzs1)
print(res)              # False

冰凍集合沒有解凍的方法，但是可以轉換成為其它的資料型別，比如使用set函式將冰凍集合變成普通的集合，

lst = set(fzs1)
print(setvar)

集合交叉并補的簡寫為什么是運算子

簡單的來說，交叉并補和位運算的本質都是一樣的，

標籤：其他

上一篇：使用FreeMarker配置動態模板

下一篇：Java基礎——ArrayList