关于python字典中、正确的是_Python字典中你必须知道的用法

末蓝、 2022-11-19 09:59 266阅读 0赞

本文Python版本为3.7.X，阅读本文之前需了解python字典的基本用法。

![Image 1][]

介绍

字典(dict)是Python中内置的一个数据结构，由多个键值对组成，键(key)和值(value)用冒号分隔，每个键值对之间用逗号(，)分隔，整个字典包括在大括号中(\{\})，键必须是唯一的，值可以取任何类型，但是键必须是不可变类型，如字符串，数字或元组。

推荐：《python教程》

底层使用了hash表来关联key和value,dict是无序的。特点包括：

● 查找和插入的速度极快，不会随着key的增加而变慢；

● 需要占用的内存较多

所以，dict是一种以空间换取时间的数据结构，应用于需要快速查找的场景。

操作：常用方法

get()

返回指定键的值，如果key不存在，则返回默认值(默认为None)，而不会报错，语法为dict.get(key)。dict\_1\['age'\] = 24

In \[7\]: print(dict\_1.get('age'))

24

In \[11\]: print(dict\_1.get('nama'))

None

In \[12\]: print(dict\_1\['nama'\])

\---------------------------------------------------------------------------

KeyError Traceback (most recent call last)

in

\----> 1 print(dict\_1\['nama'\])

KeyError: 'nama'

key in dict

使用in操作符来判断键是否存在于字典中，存在则返回True，否则返回False，语法为：key in dict。In \[15\]: dict\_1

Out\[15\]: \{'name': None, 'age': 24, 'sex': None\}

In \[16\]: print('name' in dict\_1)

True

In \[17\]: print('nama' in dict\_1)

False

在python 2中该功能使用has\_key()方法实现。

items()

以列表形式返回可遍历的(键， 值)元组数组，语法为dict.items()。In \[18\]: dict\_1

Out\[18\]: \{'name': None, 'age': 24, 'sex': None\}

In \[19\]: print(dict\_1.items())

dict\_items(\[('name', None), ('age', 24), ('sex', None)\])

In \[20\]: for key, value in dict\_1.items():

...: print(key, value)

...:

name None

age 24

sex None

keys()

以列表返回一个字典的所有键：dict.keys()In \[21\]: dict\_1

Out\[21\]: \{'name': None, 'age': 24, 'sex': None\}

In \[22\]: print(dict\_1.keys())

dict\_keys(\['name', 'age', 'sex'\])

values()

以列表形式返回字典中的所有值：dict.values()In \[27\]: dict\_1

Out\[27\]: \{'name': None, 'age': 24, 'sex': None, 'sub\_name': 'Tony'\}

In \[28\]: print(dict\_1.values())

dict\_values(\[None, 24, None, 'Tony'\])

setdefault()

和get()类似，用户获得与给顶尖相关联的值，不同的是，该方法如果键不存在时会添加键并将值设为默认值，语法为：dict.setdefault(key, default=None)。

In \[23\]: dict\_1

Out\[23\]: \{'name': None, 'age': 24, 'sex': None\}

In \[24\]: print(dict\_1.setdefault('name'))

None

In \[25\]: print(dict\_1.setdefault('name', 'Tony'))

None

In \[26\]: print(dict\_1.setdefault('sub\_name', 'Tony'))

Tony

In \[27\]: dict\_1

Out\[27\]: \{'name': None, 'age': 24, 'sex': None, 'sub\_name': 'Tony'\}

update()

语法为：dict\_1.update(dict\_2)，用于把dict\_2的键值对更新到dict\_1中，如果有相同的键会被覆盖。In \[31\]: dict\_1

Out\[31\]: \{'name': None, 'age': 24, 'sex': None, 'sub\_name': 'Tony'\}

In \[32\]: dict\_2

Out\[32\]: \{'name': 'Mary', 'age': 18, 'sex': None, 'sub\_name': ''\}

In \[33\]: dict\_1.update(dict\_2)

In \[34\]: dict\_1

Out\[34\]: \{'name': 'Mary', 'age': 18, 'sex': None, 'sub\_name': ''\}

clear()

删除字典中的所有项，dict.clear()，举个例子：In \[1\]: dict\_1 = dict(name="Tony", age=24)

In \[2\]: dict\_2 = dict\_1

In \[3\]: print(dict\_2)

\{'name': 'Tony', 'age': 24\}

In \[4\]: dict\_2.clear()

In \[5\]: dict\_2

Out\[5\]: \{\}

In \[6\]: dict\_1

Out\[6\]: \{\}

copy()

浅拷贝原始字典，返回一个具有相同键值对的新字典，dict.copy()，举个例子：In \[1\]: dict\_1 = dict(name='Tony', info=\['boy', 24\])

In \[2\]: dict\_3 = dict\_1.copy()

In \[3\]: dict\_3\['name'\] = "Ring"

In \[4\]: dict\_3\['info'\].remove('boy')

In \[5\]: dict\_3

Out\[5\]: \{'name': 'Ring', 'info': \[24\]\}

In \[6\]: dict\_1

Out\[6\]: \{'name': 'Tony', 'info': \[24\]\}

fromkeys()

创建一个新字典，dict.fromkeys(seq\[, value\])，以序列seq中的元素做字典的键，value为字典所有键对应的初始值，其中value为可选参数， 默认为None。适用于数据初始化，举个例子：In \[1\]: info = \['name', 'age', 'sex'\]

In \[2\]: dict\_1 = dict.fromkeys(info)

In \[3\]: dict\_1

Out\[3\]: \{'name': None, 'age': None, 'sex': None\}

常见操作

合并字典

有四种方式：

常规处理In \[15\]: dict\_1

Out\[15\]: \{'Tony': 24\}

In \[16\]: dict\_2

Out\[16\]: \{'ben': 18\}

In \[17\]: dict3 = dict()

In \[18\]: for key, value in dict\_1.items():

...: dict\_3\[key\] = value

...:

In \[19\]: for key, value in dict\_2.items():

...: dict\_3\[key\] = value

...:

In \[20\]: dict\_3

Out\[20\]: \{'Tony': 24, 'ben': 18\}

update()In \[9\]: dict\_1

Out\[9\]: \{'Tony': 24\}

In \[10\]: dict\_2

Out\[10\]: \{'ben': 18\}

In \[12\]: dict\_3 = dict\_1.copy()

In \[13\]: dict\_3.update(dict\_2)

In \[14\]: dict\_3

Out\[14\]: \{'Tony': 24, 'ben': 18\}

借助字典的dict(d1, \*\*d2)方法In \[33\]: dict\_1

Out\[33\]: \{'Tony': 24\}

In \[34\]: dict\_2

Out\[34\]: \{'ben': 18\}

In \[35\]: dict\_3 = dict(dict\_1, \*\*dict\_2)

In \[36\]: dict\_3

Out\[36\]: \{'Tony': 24, 'ben': 18\}

进阶

字典推导式

和列表推导式类似，优点是底层用C实现，会快很多，推荐使用。

对换字典的键值

使用字典推导式可以轻松对换一个字典的键值：In \[42\]: dict\_4

Out\[42\]: \{24: 'Tony', 18: 'ben'\}

In \[43\]: dict\_3

Out\[43\]: \{'Tony': 24, 'ben': 18\}

In \[44\]: dict\_4 = \{k:v for v, k in dict\_3.items()\}

In \[45\]: dict\_4

Out\[45\]: \{24: 'Tony', 18: 'ben'\}

从字典中提取子集

想创建一个字典，其本身是另一个字典的子集。

举个例子：In \[88\]: a = \{'Ben': 18, 'Jack': 12, 'Ring': 23, 'Tony': 24\}

In \[89\]: b = \{k:v for k, v in a.items() if v > 18\}

In \[90\]: b

Out\[90\]: \{'Ring': 23, 'Tony': 24\}

生成有序字典

在Python3.6之前的字典是无序的，但是有时候我们需要保持字典的有序性，orderDict可以在dict的基础上实现字典的有序性，这里的有序指的是按照字典key插入的顺序来排列，这样就实现了一个先进先出的dict，当容量超出限制时，先删除最早添加的key。

举例：In \[49\]: from collections import OrderedDict

In \[50\]: ordered\_dict = OrderedDict(\[('a', 2), ('b', 4), ('c', 5)\])

In \[51\]: for key, value in ordered\_dict.items():

...: print(key, value)

...:

a 2

b 4

c 5

可以看到OrderedDict是按照字典创建时的插入顺序来排序。

原理：OrderedDict内部维护了一个双向链表，它会根据元素加入的顺序来排列键的位置，这也就导致OrderedDict的大小是普通字典的2倍多。

合并列表中key相同的字典

也就是生成所谓的一键多值字典，需要将对应的多个值保存在其它容器比如列表或集合，取决于多值是否需要保证唯一性。

举个例子：In \[64\]: from collections import defaultdict

In \[65\]: a = \[\{'a': 1\}, \{'b': 3\}, \{'c': 4\}, \{'a':5\}, \{'b':2\}, \{'b': 4\}\]

In \[66\]: b = defaultdict(list)

In \[67\]: \[b\[k\].append(v) for item in a for k, v in item.items()\]

Out\[67\]: \[None, None, None, None, None, None\]

In \[68\]: b

Out\[68\]: defaultdict(list, \{'a': \[1, 5\], 'b': \[3, 2, 4\], 'c': \[4\]\})

In \[69\]: b\['a'\]

Out\[69\]: \[1, 5\]

寻找两个字典的异同

场景：寻找两个字典中的异同，包括相同的键或者相同的值。

分析：字典是一系列键值之间的映射集合，有以下特点：

keys()会返回字典中的所有键，并且字典的键是支持集合操作的，所以利用集合的交叉并补即可对字典的键进行处理；

items()返回(key, value)组成的对象，支持集合操作；

values()并不支持集合操作，因为并不能保证所有的值是唯一的，但是如果必须要判断操作，可以先将值转化为集合来实现。

举例：In \[78\]: a = \{'a':1, 'b':2, 'c':3\}

In \[79\]: b = \{'b':3, 'c':3, 'd':4\}

In \[80\]: a.keys() & b.keys()

Out\[80\]: \{'b', 'c'\}

In \[81\]: a.keys() - b.keys()

Out\[81\]: \{'a'\}

In \[82\]: a.items() & b.items()

Out\[82\]: \{('c', 3)\}

再举一个例子，在创建一个字典时，期望可以去除某些键：In \[85\]: a

Out\[85\]: \{'a': 1, 'b': 2, 'c': 3\}

In \[86\]: c = \{k: a\[key\] for k in a.keys() - \{'b'\}\}

In \[87\]: c

Out\[87\]: \{'a': 3, 'c': 3\}

本文来自 python教程 栏目，欢迎学习！

[Image 1]:

发表评论取消回复

表情：

评论列表（有 0 条评论，266人围观）

还没有评论，来说两句吧...

相关阅读

相关在Python中，为什么字典的键必须是唯一的？

在Python中，字典的键（key）确实必须是唯一的。这是由于以下几个原因： 1. **索引性**：字典通过键来存储和检索值。如果多个不同的键对应同一个值，那么在查找特定值时

梦里梦外;/ 2025年01月17日 00:09/ 0 赞/ 92 阅读

相关 Python 中的字典

描述本文旨在帮助读者熟悉 python 中字典的概念以及与之相关的方法。定义字典： A dictionary that maps players of a

清疚/ 2024年03月22日 16:10/ 0 赞/ 172 阅读

相关 Python 字典方法——Python 中的字典

在 Python 中，字典是核心数据结构之一。它是由逗号分隔并用花括号括起来的键值对序列。核心价值如果您熟悉 JavaScript，Python 字典就像 JavaSc

心已赠人/ 2023年09月26日 22:54/ 0 赞/ 143 阅读

相关 python中的字典

python中的字典创建字典 `key必须是不可变类型，因此列表不能作为dict的key` 使用`{}`创建 lang = { 'python':

刺骨的言语ヽ痛彻心扉/ 2023年02月14日 13:29/ 0 赞/ 108 阅读

相关 Python-字典中的所有方法及用法

1. setdefault使用有则不变，无则增加 dic1 = { 'name': 'lucy', 'age': 18} dic1.setde

快来打我*/ 2023年02月09日 11:56/ 0 赞/ 21 阅读

相关下列关于python的说法中、正确的是-以下关于 Python版本的说法中,哪个是正确的?...

【单选题】以下赋值语句中合法的是【单选题】字符串:s= abcde',n=len(s)。索引字符串s字符'c',哪个语句是正确的? 【单选题】以下哪个方法能够根据','分

蔚落/ 2022年11月21日 14:16/ 0 赞/ 269 阅读

相关关于python字典中、正确的是_Python字典中你必须知道的用法

本文Python版本为3.7.X，阅读本文之前需了解python字典的基本用法。 ![Image 1][] 介绍字典(dict)是Python中内置的一个数据结构，由多

末蓝、/ 2022年11月19日 09:59/ 0 赞/ 267 阅读

相关 Python 6 个字典操作你必须知道

key是否存在使用in关键字判断key是否存在字典中 ![1240][] 不要使用key in d.keys()，这是一种画蛇添足的操作，因为d.ke

ゝ一纸荒年。/ 2022年10月01日 14:57/ 0 赞/ 372 阅读

相关 python中的字典

1.字典的定义字典是一个无序的数据集合通常输出的顺序和定义的顺序不一致 1.列表类型转换 users = ['user1','user2']

红太狼/ 2021年12月14日 11:35/ 0 赞/ 444 阅读

相关 Python中的字典

目录一、字典中对属性的基本使用获取属性值新增属性修改属性删除属性二、遍历字典：遍历所有属性、key、value 三、字典嵌套 --------

朴灿烈づ我的快乐病毒、/ 2021年07月26日 01:57/ 0 赞/ 522 阅读