Python-字典总结（操作符、方法、内置函数）

电玩女神 2022-12-10 08:39 206阅读 0赞

**目录**

上篇文章思考题

简介

创建与赋值

删除

操作符

访问、添加、更新（\[\]）

标准操作符(>,<,<=,>=,==,!=)

判断键是否存在（成员关系操作in,not in）

方法

键值对视图

键视图

值视图

返回键对应的值

设置默认值

浅拷贝

删除键值对

创建并返回字典

合并

清空

相关内置函数

长度

字符串

排序

字典推导式

思考题

--------------------

# 上篇文章思考题 #

[Python-元组总结（操作符、方法、内置函数、相关模块）][Python-]

> >>> t = (\[1,2\],4,6,'lady')  
> >>> id(t)  
> 2105860316360  
> >>> t\[0\].append(4)  
> >>> id(t)  
> 2105860316360  
> >>> t  
> (\[1, 2, 4\], 4, 6, 'lady')

没有问题，元组不可修改，但是列表可修改。

# 简介 #

字典由键值对构成，是唯一的映射的类型，作为可变哈希表来实现的。键不可重复，必须可哈希。

# 创建与赋值 #

使用\{\}创建,内包含key:value的键值对，逗号分隔。

> d = \{1:3,4:5,6:"lady",'killer':9,7:True\}

# 删除 #

使用del，不建议手动删除整个字典

> >>> d1 = \{2:3,3:4\}  
> >>> del d1\[2\]  
> >>> d1  
> \{3: 4\}  
> >>> del d1  
> >>> d1  
> Traceback (most recent call last):  
>   File "<stdin>", line 1, in <module>  
> NameError: name 'd1' is not defined

# 操作符 #

## 访问、添加、更新（\[\]） ##

> >>> d\[1\]  
> 3  
> >>> d\[2\]=10  
> >>> d  
> \{1: 3, 4: 5, 6: 'lady', 'killer': 9, 7: True, 2: 10\}  
> >>> d\[6\]=6  
> >>> d  
> \{1: 3, 4: 5, 6: 6, 'killer': 9, 7: True, 2: 10\}

## 标准操作符(>,<,<=,>=,==,!=) ##

>,<,<=,>=不支持dict与dict进行比较，==,!=可以判断是否每个key对应的每个value都相等。对于比较可以查看后面的cmp。

> >>> d  
> \{1: 3, 4: 5, 6: 6, 'killer': 9, 7: True, 2: 10\}  
> >>> d1 = \{1:3,4:5,6:6,'killer':10,7:True,2:10\}  
> >>> d<d1  
> Traceback (most recent call last):  
>   File "<stdin>", line 1, in <module>  
> TypeError: '<' not supported between instances of 'dict' and 'dict'  
> >>>
> 
> >>> d==d1  
> False  
> >>> d>=d1  
> Traceback (most recent call last):  
>   File "<stdin>", line 1, in <module>  
> TypeError: '>=' not supported between instances of 'dict' and 'dict'  
> >>> d!=d1  
> True  
> >>> d1\['killer'\]=9  
> >>> d==d1  
> True

## 判断键是否存在（成员关系操作in,not in） ##

字典没有has\_key函数了

> >>> 2 in d  
> True  
> >>> 3 not in d  
> True

# 方法 #

## 键值对视图 ##

items()

> >>> d.items()  
> dict\_items(\[(1, 3), (4, 5), (6, 6), ('killer', 9), (7, True), (2, 10)\])

## 键视图 ##

keys()

> >>> d.keys()  
> dict\_keys(\[1, 4, 6, 'killer', 7, 2\])
> 
> >>> list(d)  
> \[1, 4, 6, 'killer', 7, 2\]

## 值视图 ##

values()

> >>> d.values()  
> dict\_values(\[3, 5, 6, 9, True, 10\])

前面三个返回的都是视图对象。该对象提供字典条目的一个动态视图，这意味着当字典改变时，视图也会相应改变。 大多数情况下我们希望得到的是列表，可以使用list()进行转换，对于keys()来说，list(d)与list(d.keys())是一样的。

## 返回键对应的值 ##

get(*key*\[,default\])

如果 *key* 存在于字典中则返回 *key* 的值，否则返回 *default*。 如果 *default* 未给出则默认为 `None`。

> >>> d.get('killer')  
> 9  
> >>> d.get('lady')  
> >>>

## 设置默认值 ##

setdefault(key,default)

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

就是不更新，只添加，或者说安全的添加防止覆盖，其实自己使用in来实现的话也很简单，python还是贴心的帮你写了。

>  >>> d.setdefault('killer','frank')  
> 9  
> >>> d.setdefault('lady','yu')  
> 'yu'  
> >>> d.get('lady')  
> 'yu'

## 浅拷贝 ##

copy()

返回原字典的浅拷贝。

> >>> d1=d.copy()  
> >>> d1  
> \{1: 3, 4: 5, 6: 6, 'killer': 9, 7: True, 2: 10, 'lady': 'yu'\}

## 删除键值对 ##

pop(key)

如果 *key* 存在于字典中则将其移除并返回对应value，否则返回 *default*。 如果 *default* 未给出且 *key* 不存在于字典中，则会引发`KeyError`。

> >>> d1.pop('killer')  
> 9  
> >>> d1.pop('killer')  
> Traceback (most recent call last):  
>   File "<stdin>", line 1, in <module>  
> KeyError: 'killer'

popitem()

从字典中移除并返回一个 `(键, 值)` 对。 键值对会按 LIFO(Last in,First out 后进先出)的顺序被返回。如果字典为空，则会引发`KeyError`。

> >>> d1.popitem()  
> ('lady', 'yu')  
> >>> d1.popitem()  
> (2, 10)  
> >>> d1.popitem()  
> (7, True)  
> >>> d1.popitem()  
> (6, 6)  
> >>> d1.popitem()  
> (4, 5)  
> >>> d1.popitem()  
> (1, 3)  
> >>> d1.popitem()  
> Traceback (most recent call last):  
>   File "<stdin>", line 1, in <module>  
> KeyError: 'popitem(): dictionary is empty'

无论数据库，各种编程语言或其他应用也好，无非就是CRUD，在CUD之前通过R来判断是比较好的习惯。

## 创建并返回字典 ##

fromkeys(iterable,\[None/value\])

使用来自 *iterable* 的键创建一个新字典，并将键值设为 *value。第二个参数不填，默认为None。*

> >>> d1 = d.fromkeys(d.keys(),9)  
> >>> d1  
> \{1: 9, 4: 9, 6: 9, 'killer': 9, 7: 9, 2: 9, 'lady': 9\}
> 
> >>> d2 = d.fromkeys(\[1,2,3,4,5\])  
> >>> d2  
> \{1: None, 2: None, 3: None, 4: None, 5: None\}

## 合并 ##

update(other)

使用来自 *other* 的键/值对更新字典，覆盖原有的键。python3不像c++有multimap（同一个键对应多个value），所以调用update方法的字典就会被覆盖，如果键值相同保留的话可以将value作为列表，若有相同的key，value扩充即可。

> >>> d2.update(d1)  
> >>> d2  
> \{1: 9, 2: 9, 3: None, 4: 9, 5: None, 6: 9, 'killer': 9, 7: 9, 'lady': 9\}

## 清空 ##

clear()

移除字典中的所有元素。

> >>> d2.clear()  
> >>> d2  
> \{\}

# 相关内置函数 #

## 长度 ##

len()

> >>> len(d)  
> 7

## 字符串 ##

str()

用于打印比较方便

> >>> str(d)  
> "\{1: 3, 4: 5, 6: 6, 'killer': 9, 7: True, 2: 10, 'lady': 'yu'\}"

## 排序 ##

sorted(iterable,key,reverse)

对键排序

> >>> del d\['lady'\]  
> >>> del d\['killer'\]  
> >>> d  
> \{1: 3, 4: 5, 6: 6, 7: True, 2: 10\}
> 
> >>> sorted(d)  
> \[1, 2, 4, 6, 7\]  
> >>> sorted(d,reverse=True)  
> \[7, 6, 4, 2, 1\]

对值排序

> >>> sorted(d.values())  
> \[True, 3, 5, 6, 10\]  
> >>> sorted(d.values(),reverse=True)  
> \[10, 6, 5, 3, True\]

对键值对排序

> >>> sorted(d.items(),key=lambda d:d\[0\])  
> \[(1, 3), (2, 10), (4, 5), (6, 6), (7, True)\]  
> >>> sorted(d.items(),key=lambda d:d\[0\],reverse=True)  
> \[(7, True), (6, 6), (4, 5), (2, 10), (1, 3)\]  
> >>> sorted(d.items(),key=lambda d:d\[1\])  
> \[(7, True), (1, 3), (4, 5), (6, 6), (2, 10)\]  
> >>> sorted(d.items(),key=lambda d:d\[1\],reverse=True)  
> \[(2, 10), (6, 6), (4, 5), (1, 3), (7, True)\]

# 字典推导式 #

\{key: value for (key, value) in iterable\}

> d = \{key: value for (key, value) in zip('0123456789',range(10))\}
> 
> d = dict(zip('0123456789',range(10)))

上一个为推导式，后面的使用构造函数，结果一样

# 思考题 #

元组是不可变类型，那么元组可以作为字典的key吗？

尝试将下面两个元组作为key放到字典中

> (1,)
> 
> (1,\[1,2\])

答案见：[Python-函数基础总结与内置函数][Python- 1]

更多python相关内容：[【python总结】python学习框架梳理][python_python]

本人b站账号:[lady\_killer9][lady_killer9]

有问题请下方评论，转载请注明出处，并附有原文链接，谢谢！如有侵权，请及时联系。如果您感觉有所收获，自愿打赏，可选择支付宝18833895206（小于），您的支持是我不断更新的动力。

[Python-]: https://blog.csdn.net/lady_killer9/article/details/108741304
[Python- 1]: https://blog.csdn.net/lady_killer9/article/details/108939273
[python_python]: https://blog.csdn.net/lady_killer9/article/details/108763489
[lady_killer9]: https://space.bilibili.com/374432302