Python字典操作大全

发表于 更新于 分类于

记录了python字典对象支持的所有操作方法，比如字典值操作、字典键操作、键值对操作、字典对象操作及字典视图对象操作

相关链接

官方文档

字典值操作

返回字典值

如果键不存在将引发 KeyError 异常

1
2
3
4
dict_ = {'key': 'value'}
print(dict_['key'])

# value

修改字典值

如果键存在的话,否则增加一个键值对

1
2
3
4
5
dict_ = {'key': 'value'}
dict_['key'] = '雨园博客'
print(dict_)

# {'key': '雨园博客'}

字典键操作

返回由字典键组成的列表

1
2
3
4
dict_ = {'key': 'value', 'key_1': 'value_1'}
print(list(dict_))

# ['key', 'key_1']

移除字典键并返回其值

返回一个逆序获取字典键的迭代器

这是 reversed(d.keys()) 的快捷方式

1
2
3
4
5
6
7
8
9
10
11
12
13

dict = {
    '小明': '20',
    '小红': '22',
    '小军': '21',
    '小刚': '23'
}

print(reversed(dict))
# <dict_reversekeyiterator object at 0x00000262914F3090>

print(list(reversed(dict)))  # 转换成列表
# ['小刚', '小军', '小红', '小明']

返回由字典键组成的迭代器

键值对操作

返回键值对数量

1
2
3
4
dict_ = {'key': 'value', 'key_1': 'value_1'}
print(len(dict_))

# 2

增加一个键值对

如果键不存在的话,否则修改值

1
2
3
4
5
dict_ = {'key': 'value'}
dict_['key_1'] = 'value_1'
print(dict_)

# {'key': 'value', 'key_1': 'value_1'}

移除一个键值对

1
2
3
4
5
dict_ = {'key': 'value'}
del dict_['key']
print(dict_)

# {}

移除所有键值对

1
2
3
4
5
dict_ = {'key': 'value', 'key_1': 'value_1'}
dict_.clear()
print(dict_)

# {}

移除并返回键值对

键值对会按 LIFO （后进先出）的顺序被返回

如果字典为空，调用 popitem() 将引发 KeyError 异常

1
2
3
4
5
6
7
8
9
dict = {
    '小明': '20',
    '小红': '22',
    '小军': '21',
    '小刚': '23'
}

print(dict.popitem())   # ('小刚', '23')
print(dict)             # {'小明': '20', '小红': '22', '小军': '21'}

设置默认值

setdefault(key[, default])

如果字典存在键 key ，返回它的值。如果不存在，插入值为 default 的键 key ，并返回 default

default 默认为 None

无 default

1
2
3
4
5
6
dict = {
    '小明': '20',
    '小红': '22',
}
print(dict.setdefault('小军'))  # None
print(dict.setdefault('小明'))  # 20

有 default

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
dict = {
    '小明': '20',
    '小红': '22',
}

print(dict.setdefault('小军', '30'))
print(dict)
print(dict.setdefault('小明', '30'))
print(dict)


'''输出
30
{'小明': '20', '小红': '22', '小军': '30'}
20
{'小明': '20', '小红': '22', '小军': '30'}
'''

字典对象操作

返回字典的浅拷贝

拷贝父对象，不会拷贝父对象内部的子对象

父对象

无论是改变原字典父对象还是改变浅拷贝父对象，都互不影响

1
2
3
4
5
6
7
8
9
10
11
dict_ = {'key': 'value', 'key_1': 'value_1'}
dict_1 = dict_.copy()   # 浅拷贝
print(dict_1)

dict_['key'] = '雨园'   # 改变原字典
print(dict_1)
print(dict_)

dict_1['key'] = '博客'  # 改变浅拷贝
print(dict_1)
print(dict_)

输出

1
2
3
4
5
{'key': 'value', 'key_1': 'value_1'}
{'key': 'value', 'key_1': 'value_1'}       
{'key': '雨园', 'key_1': 'value_1'}        
{'key': '博客', 'key_1': 'value_1'}        
{'key': '雨园', 'key_1': 'value_1'}

子对象

无论是改变原字典子对象还是改变浅拷贝子对象，都互相改变

1
2
3
4
5
6
7
8
9
10
11
12
# 子对象 {'key_2': 'value_2'}
dict_ = {'key': 'value', 'key_1': {'key_2': 'value_2'}}
dict_1 = dict_.copy()               # 浅拷贝
print(dict_1)

dict_['key_1']['key_2'] = '雨园'    # 改变原字典
print(dict_1)
print(dict_)

dict_1['key_1']['key_2'] = '博客'   # 改变浅拷贝
print(dict_1)
print(dict_)

输出

1
2
3
4
5
{'key': 'value', 'key_1': {'key_2': 'value_2'}}
{'key': 'value', 'key_1': {'key_2': '雨园'}}
{'key': 'value', 'key_1': {'key_2': '雨园'}}
{'key': 'value', 'key_1': {'key_2': '博客'}}
{'key': 'value', 'key_1': {'key_2': '博客'}}

创建一个新字典

classmethod fromkeys(iterable[, value])

使用来自 iterable（可迭代对象） 的键创建一个新字典，并将键值设为 value；value 默认为 None

所有值都只引用一个单独的实例，因此让 value 成为一个可变对象例如空列表通常是没有意义的

修改新字典不改变原字典

可迭代对象有 str、list、tuple、dict、set

无 Value

1
2
3
4
5
6
7
8
9
10
11
12
dict = {
    '小明': '20',
    '小红': '22',
}

print(dict.fromkeys('雨园'))
print(dict)

'''输出
{'雨': None, '园': None}
{'小明': '20', '小红': '22'}
'''

有 Value

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
dict = {
    '小明': '20',
    '小红': '22',
}

print(dict.fromkeys('雨园', '20'))
print(dict)

print(dict.fromkeys('雨园', ['a', 'b']))
print(dict)


'''输出
{'雨': '20', '园': '20'}
{'小明': '20', '小红': '22'}
{'雨': ['a', 'b'], '园': ['a', 'b']}
{'小明': '20', '小红': '22'}
'''

更新字典

update([other])

使用来自 other 的键/值对更新字典，覆盖原有的键。 返回 None

如果键在原字典不存在，则将键值对插入原字典末尾
如果键在原字典存在，则将插入的字典值更新

other是一个字典

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
dict = {
    '小明': '20',
    '小红': '22'
}

print(dict.update({'小刘': '22'}))
print(dict)
print(dict.update({'小刘': '26'}))
print(dict)


'''输出
None
{'小明': '20', '小红': '22', '小刘': '22'}
None
{'小明': '20', '小红': '22', '小刘': '26'}
'''

other是一个键值对

以长度为二的元组或其他可迭代对象表示的可迭代对象

1
2
3
4
5
6
7
8
9
10
11
12
13
dict = {
    '小明': '20',
    '小红': '22',
}

print(dict.update(('ab', 'cd')))
print(dict)


'''输出
None
{'小明': '20', '小红': '22', 'a': 'b', 'c': 'd'}
'''

other是关键字参数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
dict = {
    '小明': '20',
    '小红': '22'
}

print(dict.update(小刘=20, 小芳=18))
print(dict)
print(dict.update(小刘=22, 小芳=20))
print(dict)


'''输出
None
{'小明': '20', '小红': '22', '小刘': 20, '小芳': 18}
None
{'小明': '20', '小红': '22', '小刘': 22, '小芳': 20}
'''

字典视图对象

当字典改变时，视图也会相应改变。字典视图可以被迭代，并支持成员检测

更多信息见 字典视图对象

返回由字典值组成的新视图

dict.values()

更多信息见 values()

1
2
3
4
5
6
7
8
9
10
11
12
dict = {
    '小明': '20',
    '小红': '22',
    '小军': '21',
    '小刚': '23'
}

print(dict.values())
# dict_values(['20', '22', '21', '23'])

print(list(dict.values()))  # 转换成列表
# ['20', '22', '21', '23']

返回由字典键组成的新视图

dict.keys()

1
2
3
4
5
6
7
8
9
10
11
12
dict = {
    '小明': '20',
    '小红': '22',
    '小军': '21',
    '小刚': '23'
}

print(dict.keys())
# dict_keys(['小明', '小红', '小军', '小刚'])

print(list(dict.keys()))  # 转换成列表
# ['小明', '小红', '小军', '小刚']

返回由键值对组成的新视图