文章目录
一. 介绍
字典是另一种可变容器模型，且可存储任意类型对象。
字典的每个键值 key=>value 对用冒号 : 分割，每个对之间用逗号(,)分割，整个字典包括在花括号 {} 中 ,格式如下所示：
d = {
key1 : value1, key2 : value2, key3 : value3 }
注意：dict 作为 Python 的关键字和内置函数，变量名不建议命名为 dict。
键必须是唯一的，但值则不必，值可以取任何数据类型，但键必须是不可变的，如字符串，数字。
字典中的“键”可以是Python中任意不可变数据，例如整数，实数，复数，字符串，元组等等，但不能使用列表、集合、字典作为字典的“键”，因为这些对象是可变的。另外，字典中的“键”不允许重复，而值是可以重复的。
注意：Python中字典的键必须是一个具体的数，或者是一个不可变序列。List是一个可变序列，提供了插入删除修改操作，而tuple属于不可变序列，没有append()、extend()和insert()这些可以对序列进行修改的函数。
二. 字典的创建
1. 手动创建
使用等号直接手动创建字典：
a_dict={
'DXY':"19950819" , 'HJL':"19960424"}
print(a_dict) #{'HJL': '19960424', 'DXY': '19950819'}
print(type(a_dict)) #<class 'dict'> 为字典类型
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'}
3. 使用dict.fromkeys()方法创建
利用dict.fromkeys()方法，给定“键”序列，创建“值”为空的字典：
a_dict=dict.fromkeys( ['name','age','sex'] )
print(a_dict) #{'sex': None, 'name': None, 'age': None}
#“键”是给出的序列中的元素，“值”为空。
三. 字典元素的读取
1. 下标方式读取Value
与列表类似，可以使用下标的方式来访问字典中的元素，但不同的是字典的下标是字典的“键”，而列表和元组访问时下标必须为整数值。使用下标的方式访问字典“值”时，若指定的键不存在则抛出异常。
a_dict = {
'name':'DYX', 'sex':'male', 'age':24}
print(a_dict['name']) #DYX
#print(a_dict['tel']) KeyError: 'tel' 不存在抛出异常
2. dict.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
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
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
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
四. 字典元素的添加与修改
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'}
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.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.2 clear()方法
字典的clear()方法来删除字典中所有元素，但字典还是存在，只是是一个空字典:
a_dict = {
'name':'DYX', 'sex':'male', 'age':24}
a_dict.clear()
print(a_dict) #{}
#注意和del 的不同，del是删除整个字典，clear()方法是删除字典里面的元素。
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'}
3.4 popitem()方法
返回并删除字典中的最后一对键和值。删除并返回最后插入键值对(key, value 形式)，按照 LIFO（Last In First Out 后进先出法） 顺序规则，即最末尾的键值对。如果字典已经为空，调用了此方法，就报出 KeyError 异常。
示例：
#!/usr/bin/python3
site= {
'name': '菜鸟教程', 'alexa': 10000, 'url': 'www.runoob.com'}
# ('url': 'www.runoob.com') 最后插入会被删除
result = site.popitem()
print('返回值 = ', result)
print('site = ', site)
# 插入新元素
site['nickname'] = 'Runoob'
print('site = ', site)
# 现在 ('nickname', 'Runoob') 是最后插入的元素
result = site.popitem()
print('返回值 = ', result)
print('site = ', site)
返回值 = ('url', 'www.runoob.com')
site = {
'name': '菜鸟教程', 'alexa': 10000}
site = {
'name': '菜鸟教程', 'alexa': 10000, 'nickname': 'Runoob'}
返回值 = ('nickname', 'Runoob')
site = {
'name': '菜鸟教程', 'alexa': 10000}
五. 判断键是否在字典中
in 进行判断键是否在字典中：
a_dict = {
'name':'DYX', 'sex':'male', 'age':24}
print("name" in a_dict) #True
print("ranking" in a_dict) #False
六. 有序字典
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}
注意：python 3.8后支持原始dict字典为有序的字典
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}
七. 字典的复制与浅复制
利用copy()方法实现字典的“浅复制”，对浅复制生成的字典进行修改，不影响原字典。
1. 浅复制
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
2. 复制
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
八. 字典的排序
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
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
3. 根据items()进行排序
3.1 根据键排序
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)]
3.2 根据值排序
res = sorted(test_dict.items(),key=lambda d:d[1])
print(res) #[('DDD', 15), ('HXH', 39), ('CMJ', 43), ('HLZ', 66)]
3.3 从大到小排序：reverse=True
以上都是从小到大排序，如果要从大到小，往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)]
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)]
九. 字典内置函数&方法
