字典是“鍵-值”對的無序可變序列，字典中的每個元素可以分爲兩部分，“鍵”和“值”。定義字典時，每個元素的“鍵”和“值”用冒號分隔，相鄰元素之間用逗號分隔，所有元素放在一對大括號”{“和”}“中。字典中的“鍵”可以是Python中任意不可變數據，例如整數，實數，複數，字符串，元組等等，但不能使用列表、集合、字典作爲字典的“鍵”，因爲這些對象是可變的。另外，字典中的“鍵”不允許重複，而值是可以重複的。by《董付國Python程序設計基礎》
注意：Python中字典的鍵必須是一個具體的數，或者是一個不可變序列。List是一個可變序列，提供了插入刪除修改操作，而tuple屬於不可變序列，沒有append()、extend()和insert()這些可以對序列進行修改的函數。
具體內容可參考目錄。不保證無差錯，以具體代碼結果爲準。
目錄
1 字典的創建
1.1手動創建
使用等號直接手動創建字典。
a_dict={'DXY':"19950819" , 'HJL':"19960424"}
print(a_dict) #{'HJL': '19960424', 'DXY': '19950819'}
print(type(a_dict)) #<class 'dict'> 爲字典類型
1.2 使用內置函數dict()創建
dictionary=dict( [["a",1],["b",2],["c",3]] )
print(dictionary) #{'b': 2, 'a': 1, 'c': 3}
print( type(dictionary )) #<class 'dict'>
將 “'鍵'='值'”作爲dict()的參數來創建字典。
a_dict=dict(name='DYX' , age=24) #鍵=值對
print(a_dict) #{'age': 24, 'name': 'DYX'}
#這是19年的筆記，當時dyx確實24。
還可以利用dict.fromkeys()方法，給定“鍵”序列，創建“值”爲空的字典。
a_dict=dict.fromkeys( ['name','age','sex'] )
print(a_dict) #{'sex': None, 'name': None, 'age': None}
#“鍵”是給出的序列中的元素，“值”爲空。
2 字典元素的讀取
2.1 下標方式讀取Value
與列表類似，可以使用下標的方式來訪問字典中的元素，但不同的是字典的下標是字典的“鍵”，而列表和元組訪問時下標必須爲整數值。使用下標的方式訪問字典“值”時，若指定的鍵不存在則拋出異常。
a_dict = {'name':'DYX', 'sex':'male', 'age':24}
print(a_dict['name']) #DYX
#print(a_dict['tel']) KeyError: 'tel' 不存在拋出異常
2.2 get()讀取Value
使用字典對象的get()方法可以獲取指定”鍵“對應的”值”，並且可以在指定“鍵“不存在的時候返回指定值，如果不指定，則默認返回None。相對於上文的方法，該方法更安全。
即:下標方法，在指定鍵不存在的情況下會拋出異常，而get()方法會返回指定值，或者是None。
a_dict = {'name':'DYX', 'sex':'male', 'age':24}
print(a_dict.get('ranking')) #None 指定的鍵ranking不存在返回None
print(a_dict.get('ranking','No entry')) #No entry 指定的鍵不存在，返回指定的內容No entry
2.3 keys()方法返回“鍵”
a_dict = {'name':'DYX', 'sex':'male', 'age':24}
print(a_dict.keys()) #輸出字典的鍵 dict_keys(['name', 'age', 'sex'])
print(type(a_dict.keys())) #查看一下類型 <class 'dict_keys'>
print(list(a_dict.keys())) #['age', 'name', 'sex']
#可以用循環的方式輸出
for key in a_dict.keys():
print(key, end = " ") #name sex age
在舊版本Python2中字典對象存在一個iterkeys()方法，可以來具體看下區別：iterkeys()需要迭代後才能顯示具體。
a_dict = {'name':'DYX', 'sex':'male', 'age':24}
print(a_dict.iterkeys()) #<dictionary-itemiterator object at 0x0000000004C9FC28>
print(type(a_dict.iterkeys())) #<type 'dictionary-keyiterator'>
for key in a_dict.iterkeys():
print key
#age
#name
#sex
2.4 values()方法返回“值”
a_dict = {'name':'DYX', 'sex':'male', 'age':24}
print(a_dict.values()) #輸出字典的值 dict_values(['male', 'DYX', 24])
print(type(a_dict.values())) #查看一下類型 <class 'dict_values'>
print(list(a_dict.values())) #['male', 'DYX', 24]
#這裏也可以體現字典的無序性。
for key in a_dict.values():
print(key, end = " ") #male DYX 24
2.5 items()方法返回“鍵-值”對
a_dict = {'name':'DYX', 'sex':'male', 'age':24}
print(a_dict.items()) #dict_items([('age', 24), ('name', 'DYX'), ('sex', 'male')])
print(type(a_dict.items())) #<class 'dict_items'>
#通常用遍歷來做
for item in a_dict.items():
print(item, end = " ") #('sex', 'male') ('name', 'DYX') ('age', 24)
#查看一下item的類型
print("\n",type(item)) # <class 'tuple'> 元組類型
也可以這樣迭代輸出
a_dict = {'name':'DYX', 'sex':'male', 'age':24}
for key,values in a_dict.items():
print(key,values) #單純遍歷輸出兩個值，所以不是元組形式
#age 24
#sex male
#name DYX
如果直接對字典進行遍歷，只能遍歷出“鍵”。
a_dict = {'name':'DYX', 'sex':'male', 'age':24}
for item in a_dict: #默認是遍歷“鍵”
print(item, end = " ") #name age sex
3 字典元素的添加與修改
3.1 下標方式添加和修改
將“鍵”作爲下標時，如果存在這個鍵，那麼修改該鍵對應的值，如果該鍵不存在，則添加一個新的“鍵-值”對。
a_dict = {'name':'DYX', 'sex':'male', 'age':24}
a_dict['name']="DDD"
print(a_dict) #{'age': 24, 'sex': 'male', 'name': 'DDD'}
#進行了修改
a_dict['ranking']=15 #不存在該鍵，所以添加新的鍵值對。
print(a_dict) #{'ranking': 15, 'age': 24, 'name': 'DDD', 'sex': 'male'}
3.2 update()方法添加鍵值對
字典對象的update()方法，可以將另一個字典全部添加到當前字典中，如果兩個字典中存在相同的“鍵”，則以另一個字典中的“值”爲準，對當前字典進行更新。
a_dict = { 'ranking': [98, 97] , 'age': 24 , 'name': 'DYX' , 'sex': 'male' }
#字典中的“值”可以是列表、數字、字符串元組等等,是很寬泛的
#字典中的“鍵”要注意不能使用列表、集合、字典作爲字典的“鍵”
print(a_dict.items())
#dict_items([('sex', 'male'), ('age', 24), ('name', 'DYX'), ('ranking', [98, 97])])
a_dict.update( {'a':'a','b':'b'} )
print(a_dict) #查看添加後的字典
#{'sex': 'male', 'age': 24, 'ranking': [98, 97], 'name': 'DYX', 'a': 'a', 'b': 'b'}
3.3 刪除
3.3.1 del命令
del命令刪除字典中指定“鍵”對應的元素。或者刪除字典本身。
a_dict = {'name':'DYX', 'sex':'male', 'age':24}
del a_dict["name"]
print(a_dict) #{'age': 24, 'sex': 'male'}
del a_dict
print(a_dict) #NameError: name 'a_dict' is not defined 報錯
3.3.2 clear()方法
字典的clear()方法來刪除字典中所有元素。
a_dict = {'name':'DYX', 'sex':'male', 'age':24}
a_dict.clear()
print(a_dict) #{}
#注意和del 的不同，del是刪除整個字典，clear()方法是刪除字典裏面的元素。
3.3.3 pop()方法
pop()方法刪除並返回指定“鍵”的元素。
a_dict = {'name':'DYX', 'sex':'male', 'age':24}
temp = a_dict.pop("name")
print(temp) #DYX
print(a_dict) #{'age': 24, 'sex': 'male'}
4 判斷鍵是否在字典中
4.1 Python3中的方式
a_dict = {'name':'DYX', 'sex':'male', 'age':24}
print("name" in a_dict) #True
print("ranking" in a_dict) #False
4.2 Python2中的方法
Python2中，字典對象has_key()方法測試字典是否包含指定的鍵。python3不再支持這個方法，需要使用in。
a_dict = {'name':'DYX', 'sex':'male', 'age':24}
print (a_dict.has_key("name")) #True
print(a_dict.has_key("ranking")) #False
5 有序字典
Python內置字典是無序的，如果需要一個可以記住元素插入順序的字典可以使用collections.OrderedDict。
例如下面代碼：
x=dict() #創建一個無序字典
x['a']=3 #有就修改元素的“值”，無就在字典中更新這個“鍵-值對”
x['b']=5
x['c']=8
print(x) #輸出無序{'b': 5, 'c': 8, 'a': 3}
print(x.items()) #dict_items( [ ('c', 8), ('a', 3), ('b', 5) ] )
print(dict(x.items())) # {'b': 5, 'a': 3, 'c': 8}
import collections
x=collections.OrderedDict() #創建一個有序字典
x['a']=3 #有就修改元素的“值”，無就在字典中更新這個“鍵-值對”
x['b']=5
x['c']=8
print(x) #OrderedDict( [ ('a', 3), ('b', 5), ('c', 8) ] )
print( dict(x) ) #又變爲無序字典{'b': 5, 'a': 3, 'c': 8}
6 字典的複製與淺複製
利用copy()方法實現字典的“淺複製”，對淺複製生成的字典進行修改，不影響原字典。
淺複製
a_dict = {'name':'DYX', 'sex':'male', 'age':24}
b_dict = a_dict.copy()
print(b_dict) #{'age': 24, 'name': 'DYX', 'sex': 'male'}
b_dict["name"] = "DDD"
print(b_dict) #{'sex': 'male', 'name': 'DDD', 'age': 24}
print(a_dict) #{'sex': 'male', 'name': 'DYX', 'age': 24}
#修改b_dict不影響a_dict
複製
a_dict = {'name':'DYX', 'sex':'male', 'age':24}
c_dict = a_dict
c_dict["name"] = "DDD"
print(c_dict) #{'sex': 'male', 'name': 'DDD', 'age': 24}
print(a_dict) #{'sex': 'male', 'name': 'DDD', 'age': 24}
#修改c_dict等同修改a_dict
7 字典的排序
7.1 根據“鍵Key”進行排序
test_dict = {"DDD":15, "CMJ":43, "HLZ":66, "HXH":39}
#依據五選排名（不懂的忽略我這句註釋）
sorted_key = sorted(test_dict)
print(sorted_key ) #['CMJ', 'DDD', 'HLZ', 'HXH']
#print(type(sorted_key)) #<class 'list'>
for k in sorted_key:
print(k, test_dict[k],end = " ") #CMJ 43 DDD 15 HLZ 66 HXH 39
7.2 根據“值Value”進行排序
test_dict = {"DDD":15, "CMJ":43, "HLZ":66, "HXH":39}
sorted_value = sorted(test_dict, key=test_dict.__getitem__)
print(sorted_value) #['DDD', 'HXH', 'CMJ', 'HLZ']
for k in sorted_value:
print(k, test_dict[k],end = " ") #DDD 15 HXH 39 CMJ 43 HLZ 66
7.3 根據items()進行排序
根據鍵
test_dict = {"DDD":15, "CMJ":43, "HLZ":66, "HXH":39}
res = sorted(test_dict.items())
print(res) #[('CMJ', 43), ('DDD', 15), ('HLZ', 66), ('HXH', 39)]
#等同於
res = sorted(test_dict.items(),key=lambda d:d[0])
print(res) #[('CMJ', 43), ('DDD', 15), ('HLZ', 66), ('HXH', 39)]
根據值
res = sorted(test_dict.items(),key=lambda d:d[1])
print(res) #[('DDD', 15), ('HXH', 39), ('CMJ', 43), ('HLZ', 66)]
以上都是從小到大排序，如果要從大到小。sorted()裏面加上 reverse=True
res = sorted(test_dict.items(),key=lambda d:d[1],reverse = True)
print(res) #[('HLZ', 66), ('CMJ', 43), ('HXH', 39), ('DDD', 15)]
7.4 藉助operator.itemgeter()
import operator
test_dict = {"DDD":15, "CMJ":43, "HLZ":66, "HXH":39}
##按照item中的第一個字符進行排序，即按照key排序
sort_by_key = sorted(test_dict.items(),key = operator.itemgetter(0))
print(sort_by_key) #[('CMJ', 43), ('DDD', 15), ('HLZ', 66), ('HXH', 39)]
##按照item中的第一個字符進行排序，即按照value排序
sort_by_value = sorted(test_dict.items(),key = operator.itemgetter(1))
print(sort_by_value) #[('DDD', 15), ('HXH', 39), ('CMJ', 43), ('HLZ', 66)]
#同樣可以逆序
sort_by_value = sorted(test_dict.items(),key = operator.itemgetter(1),reverse = True)
print(sort_by_value) #[('HLZ', 66), ('CMJ', 43), ('HXH', 39), ('DDD', 15)]
行筆匆忙，如果錯誤，還望指正。
參考文獻：
董付國《Python程序設計基礎》
Python 字典(Dictionary)操作詳解 https://www.cnblogs.com/scios/p/8108243.html
python2與 python3的區別 http://www.cnblogs.com/meng-wei-zhi/articles/8194849.html
python 根據字典的鍵值進行排序 https://www.cnblogs.com/kilometerwine/p/9712329.html
python 對字典"排序" https://www.cnblogs.com/koliverpool/p/6791614.html