一、字典
字典是Python提供的一種數據類型，用於存放有映射關系的數據，字典相當於兩組數據，其中一組是key，是關鍵數據（程序對字典的操作都是基於key），另一組數據是value，可以通過key來進行訪問。如圖：
1、創建字典
通過Python內置函數help()查看幫助：
>>> help(dict)
Help on class dict in module builtins:
class dict(object)
| dict() -> new empty dictionary
| dict(mapping) -> new dictionary initialized from a mapping object's
| (key, value) pairs
| dict(iterable) -> new dictionary initialized as if via:
| d = {}
| for k, v in iterable:
| d[k] = v
| dict(**kwargs) -> new dictionary initialized with the name=value pairs
| in the keyword argument list. For example: dict(one=1, two=2)
|
| Methods defined here:
|
| __contains__(self, key, /)
| True if the dictionary has the specified key, else False.
|
| __delitem__(self, key, /)
| Delete self[key].
|
| __eq__(self, value, /)
| Return self==value.
|
| __ge__(self, value, /)
| Return self>=value.
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __getitem__(...)
| x.__getitem__(y) <==> x[y]
|
| __gt__(self, value, /)
| Return self>value.
|
| __init__(self, /, *args, **kwargs)
| Initialize self. See help(type(self)) for accurate signature.
|
| __iter__(self, /)
| Implement iter(self).
|
| __le__(self, value, /)
| Return self<=value.
|
| __len__(self, /)
| Return len(self).
|
| __lt__(self, value, /)
| Return self<value.
|
| __ne__(self, value, /)
| Return self!=value.
|
| __repr__(self, /)
| Return repr(self).
|
| __setitem__(self, key, value, /)
| Set self[key] to value.
|
| __sizeof__(...)
| D.__sizeof__() -> size of D in memory, in bytes
|
| clear(...)
| D.clear() -> None. Remove all items from D.
|
| copy(...)
| D.copy() -> a shallow copy of D
|
| get(self, key, default=None, /)
| Return the value for key if key is in the dictionary, else default.
|
| items(...)
| D.items() -> a set-like object providing a view on D's items
|
| keys(...)
| D.keys() -> a set-like object providing a view on D's keys
|
| pop(...)
| D.pop(k[,d]) -> v, remove specified key and return the corresponding value.
| If key is not found, d is returned if given, otherwise KeyError is raised
|
| popitem(...)
| D.popitem() -> (k, v), remove and return some (key, value) pair as a
| 2-tuple; but raise KeyError if D is empty.
|
| setdefault(self, key, default=None, /)
| Insert key with a value of default if key is not in the dictionary.
|
| Return the value for key if key is in the dictionary, else default.
|
| update(...)
| D.update([E, ]**F) -> None. Update D from dict/iterable E and F.
| If E is present and has a .keys() method, then does: for k in E: D[k] = E[k]
| If E is present and lacks a .keys() method, then does: for k, v in E: D[k] = v
| In either case, this is followed by: for k in F: D[k] = F[k]
|
| values(...)
| D.values() -> an object providing a view on D's values
|
| ----------------------------------------------------------------------
| Class methods defined here:
|
| fromkeys(iterable, value=None, /) from builtins.type
| Create a new dictionary with keys from iterable and values set to value.
|
| ----------------------------------------------------------------------
| Static methods defined here:
|
| __new__(*args, **kwargs) from builtins.type
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __hash__ = None
通過幫助文檔，可以看到，程序可以使用花括號或者dict()函數創建字典，
花括號創建字典，例：
# 使用花括號創建字典
a = {'小紅':'學霸','小黑':'學渣','老王':'班主任'}
print (a)
# 打印 {'小紅': '學霸', '小黑': '學渣', '老王': '班主任'}
# 使用花括號創建空字典
b = {}
print (b)
# 打印 {}
# 字典嵌套
c = {'學生':{'小紅':'學霸','小黑':'學渣'},'老師':{'老王':'班主任'}}
print (c)
# 打印 {'學生': {'小紅': '學霸', '小黑': '學渣'}, '老師': {'老王': '班主任'}}
print (c['學生'])
# 打印 {'小紅': '學霸', '小黑': '學渣'}
# 元組作為字典的key
d = {('級長','班主任'):'老王',('學生','委員'):'小紅'}
print (d)
# 打印 {('級長', '班主任'): '老王', ('學生', '委員'): '小紅'}
print (d[('學生', '委員')])
# 打印 '小紅'
使用dict函數創建字典，例：
# 創建空字典
e = dict()
print (e)
# 打印 {}
# 使用dict指定關鍵字參數創建字典，key不允許使用表達式
f = dict(k1 = 1,k2 = 'v2')
print (f)
# 打印 {'k1': 1, 'k2': 'v2'}
# 使用dict指定關鍵字參數創建字典，key使用表達式
y = dict(1=1,2=2)
# 報錯：SyntaxError: keyword can't be an expression
# 創建兩個鍵值對字典
h1 = [('k1',1),('k2',2)]
h = dict(h1)
print (h1)
# 打印 {'k1': 1, 'k2': 2}
# 創建三個鍵值對字典
i1 = [['j1',1],['j2',2],['j3',3]]
i = dict(i1)
print (i)
# 打印 {'j1': 1, 'j2': 2, 'j3': 3}
2、字典用法
- 通過key訪問value
a = {'小紅':'學霸','小黑':'學渣','老王':'班主任'}
# 通過key訪問value
print (a['小紅'])
# 打印 學霸
c = {'學生':{'小紅':'學霸','小黑':'學渣'},'老師':{'老王':'班主任'}}
# 訪問字典嵌套字典的value
c1 = c['學生']
print (c1)
# 打印 {'小紅': '學霸', '小黑': '學渣'}
print (c1['小紅'])
# 打印 學霸
- 通過key添加鍵值對
# 創建字典
n = dict(k1 = 1,k2 = 2,k3 = 3)
# 通過key添加key-value對(需要為不存在的key賦值，如果已存在，會被覆蓋)
n['k4'] = 4
print (n)
# 打印 {'k1': 1, 'k2': 2, 'k3': 3, 'k4': 4}
- 通過key修改鍵值對
m = {'k1': 1, 'k2': 2, 'k3': 3}
# 如果key已存在，則新的value會覆蓋原來的value
m['k1'] = '覆蓋'
print (m)
# 打印 {'k1': '覆蓋', 'k2': 2, 'k3': 3}
- 通過in或not in運算符判斷字典是否包含指定的key
p = {'k1': 1, 'k2': 2, 'k3': 3, 'k4': 4}
# 判斷p是否包含名為'k1'的key
print ('k1' in p)
# 打印 True
print ('k1' not in p)
# 打印 False
#判斷p是否包含名為'k5'的key
print ('k5' in p)
# 打印 False
print ('k5' not in p)
# 打印 True
3、字典的常用方法
我們可以在Python交互模式中，輸入dir(dict)查看dict類包含哪些方法，
例：
>>> dir(dict) ['__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'clear', 'copy', 'fromkeys', 'get', 'items', 'keys', 'pop', 'popitem', 'setdefault', 'update', 'values']
1）、clear()
用於清除一個字典的鍵值對，當一個字典執行clean()之后，這個字典將會變為空字典。
>>> help(dict.clear) Help on method_descriptor: clear(...) D.clear() -> None. Remove all items from D.
例：
c = dict(k1 = 1,k2 = 2)
c.clear()
print(c)
# 打印 {}
2）、copy()
可復制一個字典的鍵值對。
>>> help(dict.copy) Help on method_descriptor: copy(...) D.copy() -> a shallow copy of D
例：
c = dict(k1 = 1,k2 = 2)
d = c.copy()
print(d)
# 打印 {'k1': 1, 'k2': 2}
3）、fromkeys()
使用給定的多個key創建字典，這些key對應的value默認為None，該方法一般會使用dict類直接調用（字典對象調用沒有什么意義）。
>>> help(dict.fromkeys) Help on built-in function fromkeys: fromkeys(iterable, value=None, /) method of builtins.type instance Create a new dictionary with keys from iterable and values set to value.
例：
a = (['k1','k2','k3'])
b = dict.fromkeys(a)
print(b)
# 打印 {'k1': None, 'k2': None, 'k3': None}
# 傳入'test'作為默認的value
d = (['k1','k2','k3'])
e = dict.fromkeys(d,'test')
print(e)
# 打印 {'k1': 'test', 'k2': 'test', 'k3': 'test'}
4）、get()
如果key在字典中，則返回key對應的value值，否則返回default默認參數None。
>>> help(dict.get) Help on method_descriptor: get(self, key, default=None, /) Return the value for key if key is in the dictionary, else default.
例：
a = dict(k1 = 1, k2 =2)
print(a.get('k1'))
# 打印 1
print(a.get('k10'))
# 打印 None
# 傳入“Not_found”作為默認的default
print(a.get('k10','Not_found'))
# 打印 Not_found
5）、items()
用於獲取字典中的所有鍵值對,返回dict_items對象。
>>> help(dict.items) Help on method_descriptor: items(...) D.items() -> a set-like object providing a view on D's items
例：
a = dict(k1 =1,k2 = 2)
print(a.items())
# 打印 dict_items([('k1', 1), ('k2', 2)])
# 將dict_items轉換成list
print(list(a.items()))
# 打印 [('k1', 1), ('k2', 2)]
6）、keys()
用於返回字典中的所有key，返回dict_keys對象。
>>> help(dict.keys) Help on method_descriptor: keys(...) D.keys() -> a set-like object providing a view on D's keys
例：
a = dict(k1 =1,k2 = 2) print(a.keys()) # 打印 dict_keys(['k1', 'k2']) # 將dict_keys轉換成list print(list(a.keys())) # 打印 ['k1', 'k2']
7）、values()
用於返回字典中的所有value，返回dict_values對象。
>>> help(dict.values) Help on method_descriptor: values(...) D.values() -> an object providing a view on D's values
例：
a = dict(k1 =1,k2 = 2) print(a.values()) # 打印 dict_values([1, 2]) # 將dict_values轉換為list print(list(a.values())) # 打印 [1, 2]
8）、popitem()
用於隨機刪除字典中的一個鍵值對，實際上字典的popitem()方法總是彈出底層存儲的最后一個鍵值對。
>>> help(dict.popitem) Help on method_descriptor: popitem(...) D.popitem() -> (k, v), remove and return some (key, value) pair as a 2-tuple; but raise KeyError if D is empty.
例：
a = dict(k1 =1,k2 = 2,k3 = 3,k4 = 4,k5 = 5)
print(a.popitem())
# 打印 ('k5', 5)
print(a)
# 打印 {'k1': 1, 'k2': 2, 'k3': 3, 'k4': 4}
9）、setdefault()
用於根據key獲取對應的value，如果key在字典中不存在時，會先給這個key設置一個默認的value，再返回這個key對應的value。
>>> help(dict.setdefault) Help on method_descriptor: setdefault(self, key, default=None, /) Insert key with a value of default if key is not in the dictionary. Return the value for key if key is in the dictionary, else default.
例：
a = dict(k1 =1,k2 = 2)
print(a.setdefault('k1'))
# 打印 1
print(a.setdefault('k10'))
# 打印 None
# 傳入‘test’作為默認的default
print(a.setdefault('k11','test'))
#打印 test
print(a)
# 打印 {'k1': 1, 'k2': 2, 'k10': None, 'k11': 'test'}
10）、update()
在一個字典中，可根據key對已存在的鍵值對進行覆蓋，如果key不存在，則該鍵值對會被添加進字典。
>>> help(dict.update) Help on method_descriptor: update(...) D.update([E, ]**F) -> None. Update D from dict/iterable E and F. If E is present and has a .keys() method, then does: for k in E: D[k] = E[k] If E is present and lacks a .keys() method, then does: for k, v in E: D[k] = v In either case, this is followed by: for k in F: D[k] = F[k]
例：
a = dict(k1 =1,k2 = 2)
# 根據key對已存在的key-value，覆蓋value
a.update(k1 = 3)
print(a)
# 打印 {'k1': 3, 'k2': 2}
# key不存在，該鍵值對會被添加進字典
a.update(k3 = 10)
print(a)
# 打印 {'k1': 3, 'k2': 2, 'k3': 10}
11）、pop()
用於根據key獲取對應的value，並且刪除該鍵值對。
>>> help(dict.pop) Help on method_descriptor: pop(...) D.pop(k[,d]) -> v, remove specified key and return the corresponding value. If key is not found, d is returned if given, otherwise KeyError is raised
例：
a = dict(k1 =1,k2 = 2,k3 = 3,k4 = 4,k5 = 5)
print(a.pop('k1'))
# 打印 1
print(a)
# 打印 {'k2': 2, 'k3': 3, 'k4': 4, 'k5': 5}
4、注意事項
列表不允許對不存在的索引賦值，但字典允許對不存在的鍵賦值。
例：
p = [1,2,3,4,5]
# 對不存在的索引賦值
p[5] = 666
# 報錯 IndexError: list assignment index out of range
q = dict(a=1,b=2)
# 對不存在的key賦值
q['c'] = 3
print (q)
# 打印 {'a': 1, 'b': 2, 'c': 3}