Python dict字典全部操作方法_python dict操作

一. 介绍

字典是另一种可变容器模型，且可存储任意类型对象。
字典的每个键值 key=>value 对用冒号 : 分割，每个对之间用逗号(,)分割，整个字典包括在花括号 {} 中 ,格式如下所示：

d = {key1 : value1, key2 : value2, key3 : value3 }
1

注意：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'>  为字典类型
1
2
3

2. 使用内置函数dict()创建

dictionary=dict( [["a",1],["b",2],["c",3]] )
print(dictionary)   #{'b': 2, 'a': 1, 'c': 3}
print( type(dictionary ))  #<class 'dict'>
1
2
3

将 “‘键’=‘值’”作为dict()的参数来创建字典：

a_dict=dict(name='DYX' ,  age=24)  #键=值对
print(a_dict)  #{'age': 24, 'name': 'DYX'}
1
2

3. 使用dict.fromkeys()方法创建

利用dict.fromkeys()方法，给定“键”序列，创建“值”为空的字典：

a_dict=dict.fromkeys( ['name','age','sex'] )
print(a_dict)  #{'sex': None, 'name': None, 'age': None}
#“键”是给出的序列中的元素，“值”为空。
1
2
3

三. 字典元素的读取

1. 下标方式读取Value

与列表类似，可以使用下标的方式来访问字典中的元素，但不同的是字典的下标是字典的“键”，而列表和元组访问时下标必须为整数值。使用下标的方式访问字典“值”时，若指定的键不存在则抛出异常。

a_dict = {'name':'DYX', 'sex':'male', 'age':24}
print(a_dict['name'])  #DYX
#print(a_dict['tel'])  KeyError: 'tel' 不存在抛出异常
1
2
3

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
1
2
3

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
1
2
3
4
5
6
7
8

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 
1
2
3
4
5
6
7
8

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'> 元组类型
1
2
3
4
5
6
7
8
9

也可以这样迭代输出：

a_dict = {'name':'DYX', 'sex':'male', 'age':24}
for key,values in a_dict.items():
    print(key,values) #单纯遍历输出两个值，所以不是元组形式
#age 24
#sex male
#name DYX
1
2
3
4
5
6

如果直接对字典进行遍历，只能遍历出“键”：

a_dict = {'name':'DYX', 'sex':'male', 'age':24}
for item in a_dict:    #默认是遍历“键”
    print(item, end = " ")  #name age sex
1
2
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'}
1
2
3
4
5
6
7

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'}
1
2
3
4
5
6
7
8

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  报错
1
2
3
4
5

3.2 clear()方法

字典的clear()方法来删除字典中所有元素，但字典还是存在，只是是一个空字典:

a_dict = {'name':'DYX', 'sex':'male', 'age':24}
a_dict.clear()
print(a_dict)  #{}
#注意和del 的不同，del是删除整个字典，clear()方法是删除字典里面的元素。
1
2
3
4

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'}
1
2
3
4

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)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

返回值 =  ('url', 'www.runoob.com')
site =  {'name': '菜鸟教程', 'alexa': 10000}
site =  {'name': '菜鸟教程', 'alexa': 10000, 'nickname': 'Runoob'}
返回值 =  ('nickname', 'Runoob')
site =  {'name': '菜鸟教程', 'alexa': 10000}
1
2
3
4
5

五. 判断键是否在字典中

in 进行判断键是否在字典中：

a_dict = {'name':'DYX', 'sex':'male', 'age':24}
print("name" in a_dict) #True
print("ranking" in a_dict) #False
1
2
3

六. 有序字典

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}
1
2
3
4
5
6
7

注意：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}
1
2
3
4
5
6
7

七. 字典的复制与浅复制

利用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
1
2
3
4
5
6
7

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
2
3
4
5
6

八. 字典的排序

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
1
2
3
4
5
6
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
1
2
3
4
5

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)]
1
2
3
4
5
6

3.2 根据值排序

res = sorted(test_dict.items(),key=lambda d:d[1])
print(res)  #[('DDD', 15), ('HXH', 39), ('CMJ', 43), ('HLZ', 66)]
1
2

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)]
1
2

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)]
1
2
3
4
5
6
7
8
9
10
11
12
13

九. 字典内置函数&方法

十. 参考链接

1. Python字典(Dictionary)操作全解【创建、读取、修改、添加、删除、有序字典、浅复制、排序】
2. Python3 字典：https://www.runoob.com/python3/python3-dictionary.html