[19/09/19-星期四] Python中的字典和集合

1、字典

# 字典
# 使用 {} 來建立字典
d = {} # 建立了一個空字典

# 建立一個保護有數據的字典
# 語法：
#   {key:value,key:value,key:value}
#   字典的值能夠是任意對象
#   字典的鍵能夠是任意的不可變對象（int、str、bool、tuple ...），可是通常咱們都會使用str
#       字典的鍵是不能重複的，若是出現重複的後邊的會替換到前邊的
# d = {'name':'孫悟空' , 'age':18 , 'gender':'男' , 'name':'sunwukong'}
d = {
'name':'孫悟空' , 
'age':18 , 
'gender':'男' , 
'name':'sunwukong'
}

# print(d , type(d))

# 須要根據鍵來獲取值
# print(d['name'],d['age'],d['gender'])

# 若是使用了字典中不存在的鍵，會報錯
# print(d['hello']) KeyError: 'hello'

2、字典的使用

# - 字典屬於一種新的數據結構，稱爲映射（mapping）
# - 字典的做用和列表相似，都是用來存儲對象的容器
# - 列表存儲數據的性能很好，可是查詢數據的性能的不好
# - 在字典中每個元素都有一個惟一的名字，經過這個惟一的名字能夠快速的查找到指定的元素
# - 在字典中能夠保存多個對象，每一個對象都會有一個惟一的名字
#     這個惟一的名字，咱們稱其爲鍵（key），經過key能夠快速的查詢value
#     這個對象，咱們稱其爲值（value）
#     因此字典，咱們也稱爲叫作鍵值對（key-value）結構
#     每一個字典中均可以有多個鍵值對，而每個鍵值對咱們稱其爲一項（item）



# 建立字典
# 使用{}
# 語法：{k1:v1,k2:v2,k3:v3}

# 使用 dict()函數來建立字典
# 每個參數都是一個鍵值對，參數名就是鍵，參數名就是值（這種方式建立的字典，key都是字符串）
d = dict(name='孫悟空',age=18,gender='男') 

# 也能夠將一個包含有雙值子序列的序列轉換爲字典
# 雙值序列，序列中只有兩個值，[1,2] ('a',3) 'ab'
# 子序列，若是序列中的元素也是序列，那麼咱們就稱這個元素爲子序列
# [(1,2),(3,5)]
d = dict([('name','孫悟飯'),('age',18)])
# print(d , type(d))
d = dict(name='孫悟空',age=18,gender='男') 

# len() 獲取字典中鍵值對的個數
# print(len(d))

# in 檢查字典中是否包含指定的鍵
# not in 檢查字典中是否不包含指定的鍵
# print('hello' in d)

# 獲取字典中的值，根據鍵來獲取值
# 語法：d[key]
# print(d['age'])

# n = 'name'
# print(d[n])

# 經過[]來獲取值時，若是鍵不存在，會拋出異常 KeyError
# get(key[, default]) 該方法用來根據鍵來獲取字典中的值
#   若是獲取的鍵在字典中不存在，會返回None
#   也能夠指定一個默認值，來做爲第二個參數，這樣獲取不到值時將會返回默認值
# print(d.get('name'))
# print(d.get('hello','默認值'))

# 修改字典
# d[key] = value 若是key存在則覆蓋，不存在則添加
d['name'] = 'sunwukong' # 修改字典的key-value
d['address'] = '花果山' # 向字典中添加key-value

# print(d) 
# 增 setdefault(key[, default]) 能夠用來向字典中添加key-value
#   若是key已經存在於字典中，則返回key的值，不會對字典作任何操做
#   若是key不存在，則向字典中添加這個key，並設置value
result = d.setdefault('name','豬八戒') #不會把name改爲豬八戒 由於name已經存在。
result = d.setdefault('hello','豬八戒')

# print('result =',result)
# print(d)

# 改 update([other])
# 將其餘的字典中的key-value添加到當前字典中
# 若是有重複的key，則後邊的會替換到當前的
d = {'a':1,'b':2,'c':3}
d2 = {'d':4,'e':5,'f':6, 'a':7}
d.update(d2)

# print(d)
# 刪  刪除，可使用 del 來刪除字典中的 key-value
del d['a']
del d['b']

# popitem()
# 隨機刪除字典中的一個鍵值對，通常都會刪除最後一個鍵值對
#   刪除以後，它會將刪除的key-value做爲返回值返回
#   返回的是一個元組，元組中有兩個元素，第一個元素是刪除的key，第二個是刪除的value
# 當使用popitem()刪除一個空字典時，會拋出異常 KeyError: 'popitem(): dictionary is empty'
# d.popitem()
# result = d.popitem()

# pop(key[, default])
# 根據key刪除字典中的key-value
# 會將被刪除的value返回！
# 若是刪除不存在的key，會拋出異常
#   若是指定了默認值，再刪除不存在的key時，不會報錯，而是直接返回默認值
result = d.pop('d')
result = d.pop('z','這是默認值')

# del d['z'] z不存在，報錯
# result = d.popitem()
# result = d.popitem()
# result = d.popitem()
# result = d.popitem()

# clear()用來清空字典
d.clear()

# print('result =',result)
# print(d)

# copy()
# 該方法用於對字典進行淺複製
# 複製之後的對象，和原對象是獨立，修改一個不會影響另外一個
# 注意，淺複製會簡單複製對象內部的值，若是值也是一個可變對象，這個可變對象不會被複制，直接把地址給引用過來
d = {'a':1,'b':2,'c':3}
d2 = d.copy()
# d['a'] = 100

d = {'a':{'name':'孫悟空','age':18},'b':2,'c':3}
d2 = d.copy()
d2['a']['name'] = '豬八戒'


print('d = ',d , id(d))#輸出結果d ={'a': {'name': '豬八戒', 'age': 18}, 'b': 2, 'c': 3} 35065144
print('d2 = ',d2 , id(d2))#d2 ={'a': {'name': '豬八戒', 'age': 18}, 'b': 2, 'c': 3} 41238248

3、遍歷字典

# 遍歷字典
# keys() 該方法會返回字典的全部的key
#   該方法會返回一個序列，序列中保存有字典的全部的鍵
d = {'name':'孫悟空','age':18,'gender':'男'}

# 經過遍歷keys()來獲取全部的鍵
# for k in d.keys() :
#     print(k , d[k])

# values()
# 該方法會返回一個序列，序列中保存有字典的左右的值
# for v in d.values():
#     print(v)

# items()
# 該方法會返回字典中全部的項
# 它會返回一個序列，序列中包含有雙值子序列
# 雙值分別是，字典中的key和value
# print(d.items())
for k,v in d.items() :
    print(k , '=' , v)

4、集合

# ## 集合（set）
#     - 集合和列表很是類似
#     - 不一樣點：
#         1.集合中只能存儲不可變對象
#         2.集合中存儲的對象是無序（實際上不是按照元素的插入順序保存），列表中是有序的
#         3.集合中不能出現重複的元素

# 集合
# 使用 {} 來建立集合
s = {10,3,5,1,2,1,2,3,1,1,1,1} # <class 'set'>
# s = {[1,2,3],[4,6,7]} TypeError: unhashable type: 'list'
# 使用 set() 函數來建立集合
s = set() # 空集合
# 能夠經過set()來將序列和字典轉換爲集合
s = set([1,2,3,4,5,1,1,2,3,4,5])
s = set('hello')
s = set({'a':1,'b':2,'c':3}) # 使用set()將字典轉換爲集合時，只會包含字典中的鍵

# 建立集合
s = {'a' , 'b' , 1 , 2 , 3 , 1}

# 使用in和not in來檢查集合中的元素
# print('c' in s)

# 使用len()來獲取集合中元素的數量
# print(len(s))

# add() 向集合中添加元素
s.add(10)
s.add(30)

# update() 將一個集合中的元素添加到當前集合中
#   update()能夠傳遞序列或字典做爲參數，字典只會使用鍵
s2 = set('hello')
s.update(s2)
s.update((10,20,30,40,50))
s.update({10:'ab',20:'bc',100:'cd',1000:'ef'})

# {1, 2, 3, 100, 40, 'o', 10, 1000, 'a', 'h', 'b', 'l', 20, 50, 'e', 30}
# pop()隨機刪除並返回一個集合中的元素
# result = s.pop()

# remove()刪除集合中的指定元素
s.remove(100)
s.remove(1000)

# clear()清空集合
s.clear()

# copy()對集合進行淺複製

# print(result)
print(s , type(s))

5、集合的運算

# 在對集合作運算時，不會影響原來的集合，而是返回一個運算結果
# 建立兩個集合
s = {1,2,3,4,5}
s2 = {3,4,5,6,7}

# & 交集運算
result = s & s2 # {3, 4, 5}

# | 並集運算
result = s | s2 # {1,2,3,4,5,6,7}

# - 差集
result = s - s2 # {1, 2}

# ^ 異或集 獲取只在一個集合中出現的元素
result = s ^ s2 # {1, 2, 6, 7}

# <= 檢查一個集合是不是另外一個集合的子集
# 若是a集合中的元素所有都在b集合中出現，那麼a集合就是b集合的子集，b集合是a集合超集
a = {1,2,3}
b = {1,2,3,4,5}

result = a <= b # True
result = {1,2,3} <= {1,2,3} # True
result = {1,2,3,4,5} <= {1,2,3} # False

# < 檢查一個集合是不是另外一個集合的真子集 把=那種狀況去掉
# 若是超集b中含有子集a中全部元素，而且b中還有a中沒有的元素，則b就是a的真超集，a是b的真子集
result = {1,2,3} < {1,2,3} # False
result = {1,2,3} < {1,2,3,4,5} # True

# >= 檢查一個集合是不是另外一個的超集
# > 檢查一個集合是不是另外一個的真超集
print('result =',result)