Python——字典dict()詳解

1、字典

字典是Python提供的一種數據類型，用於存放有映射關係的數據，字典至關於兩組數據，其中一組是key，是關鍵數據（程序對字典的操做都是基於key），另外一組數據是value，能夠經過key來進行訪問。如圖：

 

一、建立字典

經過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}

二、字典用法

- 經過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

三、字典的經常使用方法

咱們能夠在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}

 

四、注意事項

列表不容許對不存在的索引賦值，但字典容許對不存在的鍵賦值。
例：

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}