python怎么打印字典_Python中的字典

作者|Ankit Gupta

编译|VK

来源|Towards Datas Science

在这篇文章中，我将讨论字典。这是“Python中的数据结构”系列的第二篇文章。本系列的第一部分是关于列表的。

字典是Python中使用键进行索引的重要数据结构。它们是无序的项序列(键值对)，这意味着顺序不被保留。键是不可变的。

与列表一样，字典的值可以保存异构数据，即整数、浮点、字符串、NaN、布尔值、列表、数组，甚至嵌套字典。

本文将为你提供一个清晰的理解，并使你能够熟练地使用Python字典。

本文包括以下主题：创建字典并添加元素

访问字典元素

删除字典元素

添加/插入新元素

合并/连接字典

修改字典

字典排序

字典生成式

创建字典的其他方法

复制字典

重命名现有键

嵌套字典

检查字典中是否存在键

1 创建字典并添加元素

像列表是用方括号([])初始化的，字典是用花括号({})初始化的。当然，空字典的长度是零。dic_a = {} # 空字典

type(dic_a)

>>> dict

len(dic_a)

>>> 0

字典有两个特征：键和值。每个键都有相应的值。键和值都可以是string、float、integer、NaN等类型。向字典中添加元素意味着添加键值对。字典由一个或多个键值对组成。

让我们在空字典里增加一些元素。下面是一种方法。这里，“A”是键，“Apple”是它的值。你可以添加任意多个元素。# 添加第一个元素

dic_a['A'] = 'Apple'

print (dic_a)

>>> {'A': 'Apple'}

# 添加第二个元素

dic_a['B'] = 'Ball'

print (dic_a)

>>> {'A': 'Apple', 'B': 'Ball'}

注意：Python区分大小写，“A”和“a”充当两个不同的键。dic_a['a'] = 'apple'

print (dic_a)

>>> {'A': 'Apple', 'B': 'Ball', 'a': 'apple'}

一次初始化字典

如果你发现上面一个接一个添加元素的方法很烦人，那么你也可以通过指定所有键值对立即初始化字典。dic_a = {'A': 'Apple', 'B': 'Ball', 'C': 'Cat'}

异构字典

到目前为止，你的字典中有字符串作为键和值。字典也可以存储混合类型的数据。下面是一个有效的Python字典。dic_b = {1: 'Ace', 'B': 123, np.nan: 99.9, 'D': np.nan, 'E': np.inf}

但是你应该为键使用有意义的名称，因为它们表示字典的索引。尤其要避免使用float和np.nan作为键。

2 访问字典元素

创建了字典之后，让我们看看如何访问它们的元素。

访问键和值

你可以使用函数dict.keys()和dict.values()分别访问键和值。还可以使用items()函数访问元组形式的键和值。dic_a = {'A': 'Apple', 'B': 'Ball', 'C': 'Cat'}

dic_a.keys()

>>> dict_keys(['A', 'B', 'C'])

dic_a.values()

>>> dict_values(['Apple', 'Ball', 'Cat'])

dic_a.items()

>>> dict_items([('A', 'Apple'), ('B', 'Ball'), ('C', 'Cat')])

或者，也可以使用“for”循环一次访问/打印一个。# 打印键

for key in dic_a.keys():

print (key, end=' ')

>>> A B C

#############################

# 打印值

for key in dic_a.values():

print (key, end=' ')

>>> Apple Ball Cat

你可以避免两个“for”循环，并使用items()访问键和值。“for”循环将遍历items()返回的键值对。这里，键和值是任意变量名。dic_a = {'A': 'Apple', 'B': 'Ball', 'C': 'Cat'}

for key, value in dic_a.items():

print (key, value)

>>> A Apple

B Ball

C Cat

访问单个元素

无法使用数字索引访问字典项。dic_a = {'A': 'Apple', 'B': 'Ball', 'C': 'Cat'}

dic_a[0]

>>> ----> 1 dic_a[0]

KeyError: 0

你需要使用键从字典中访问相应的值。# 获取"Apple"的值

dic_a['A']

>>> 'Apple'

# 获取"Cat"的值

dic_a['C']

>>> 'Cat'

如果字典中不存在键，则会出现错误。dic_a['Z']

>>> KeyError Traceback (most recent call last)

----> 1 dic_a['Z']

KeyError: 'Z'

如果希望在不存在键的情况下避免此类键错误，可以使用get()函数。如果键不存在，则返回None。也可以使用自定义消息返回。print (dic_a.get('Z'))

>>> None

# 自定义返回消息

print (dic_a.get('Z', 'Key does not exist'))

>>> Key does not exist

访问列表中的字典元素dic_a = {'A': 'Apple', 'B': 'Ball', 'C': 'Cat'}

list(dic_a.keys())[0]

>>> 'A'

list(dic_a.keys())[-1]

>>> 'C'

list(dic_a.values())[0]

>>> 'Apple'

list(dic_a.values())[-1]

>>> 'Cat'

3 删除字典元素

从字典中删除元素意味着一起删除一个键值对。

使用del

可以使用del关键字和要删除其值的键删除字典元素。删除是in-place，这意味着删除后不需要重新分配字典的值。dic_a = {'A': 'Apple', 'B': 'Ball', 'C': 'Cat'}

# 删除“A”：“Apple”的键值对

del dic_a['A']

print (dic_a)

>>> {'B': 'Ball', 'C': 'Cat'}

# 删除“C”：“Cat”的键值对

del dic_a['C']

print (dic_a)

>>> {'B': 'Ball'}

使用pop()

你还可以使用“pop()”函数删除元素。它返回弹出(删除)的值，并修改字典。dic_a = {'A': 'Apple', 'B': 'Ball', 'C': 'Cat'}

dic_a.pop('A')

>>> 'Apple'

print (dic_a)

# {'B': 'Ball', 'C': 'Cat'}

在上述两种方法中，如果要删除的键不存在于字典中，则会出现KeyError。在“pop()”的情况下，如果键不存在，可以指定要显示的错误消息。key_to_delete = 'E'

dic_a = {'A': 'Apple', 'B': 'Ball', 'C': 'Cat'}

dic_a.pop(key_to_delete, f'Key {key_to_delete} does not exist.')

>>> 'Key E does not exist.'

删除多个元素

没有直接的方法，但是你可以使用一个“for”循环，如下所示。to_delete = ['A', 'C']

dic_a = {'A': 'Apple', 'B': 'Ball', 'C': 'Cat'}

for key in to_delete:

del dic_a[key]

print (dic_a)

>>> {'B': 'Ball'}

4 添加/插入新元素

你可以向字典中添加一个元素，如下所示。dic_a = {'A': 'Apple', 'B': 'Ball', 'C': 'Cat'}

dic_a['D'] = 'Dog'

print (dic_a)

>>> {'A': 'Apple', 'B': 'Ball', 'C': 'Cat', 'D': 'Dog'}

dic_a['E'] = 'Egg'

print (dic_a)

>>> {'A': 'Apple', 'B': 'Ball', 'C': 'Cat', 'D': 'Dog', 'E': 'Egg'}

如果你正在添加的键已经存在，则将覆盖现有值。dic_a = {'A': 'Apple', 'B': 'Ball', 'C': 'Cat'}

dic_a['A'] = 'Adam' # 键“A”已经存在，值为“Apple”

print (dic_a)

>>> {'A': 'Adam', 'B': 'Ball', 'C': 'Cat'}

使用update()

还可以使用update()函数通过将该对作为参数传递来添加新的键值对。dic_a = {'A': 'Apple', 'B': 'Ball', 'C': 'Cat'}

dic_a.update({'D': 'Dog'})

print (dic_a)

>>> {'A': 'Apple', 'B': 'Ball', 'C': 'Cat', 'D': 'Dog'}

函数还允许你同时向现有字典添加多个键值对。dic_a = {'A': 'Apple', 'B': 'Ball', 'C': 'Cat'}

dic_b = {'D':'Dog', 'E':'Egg'}

dic_a.update(dic_b)

print(dic_a)

>>> {'A': 'Apple', 'B': 'Ball', 'C': 'Cat', 'D': 'Dog', 'E': 'Egg'}

5 合并/连接字典

可以使用从Python 3.5开始的解包操作符(**)合并两个或多个字典。dic_a = {'A': 'Apple', 'B': 'Ball'}

dic_b = {'C': 'Cat', 'D': 'Dog'}

dic_merged = {**dic_a, **dic_b}

print (dic_merged)

>>> {'A': 'Apple', 'B': 'Ball', 'C': 'Cat', 'D': 'Dog'}

如果不想创建新字典，但只想将dic_b添加到现有dic_a中，你可以简单地更新前面所示的第一个字典。dic_a = {'A': 'Apple', 'B': 'Ball'}

dic_b = {'C': 'Cat', 'D': 'Dog'}

dic_a.update(dic_b)

print (dic_a)

>>> {'A': 'Apple', 'B': 'Ball', 'C': 'Cat', 'D': 'Dog'}

在连接时如何处理重复键？

Python字典的一个特点是它们不能有重复的键，即键不能出现两次。那么，如果连接两个或多个字典，其中包含一个或多个公共键，会发生什么情况。

答案是，最后一个合并字典中的键值对(按合并顺序)将继续存在。在下面的示例中，所有三个字典中都存在键“A”，因此，最终字典从最后一个合并字典(dic_c)中获取值。dic_a = {'A': 'Apple', 'B': 'Ball'}

dic_b = {'C': 'Cat', 'A': 'Apricot'}

dic_c = {'A': 'Adam', 'E': 'Egg'}

dic_merged = {**dic_a, **dic_b, **dic_c}

print (dic_merged)

>>> {'A': 'Adam', 'B': 'Ball', 'C': 'Cat', 'E': 'Egg'}

谨慎的话

我刚说字典不能有重复的键。严格地说，你可以定义一个具有重复键的字典，但是，打印时，只能打印最后一个。如下所示的dic_a，只返回唯一的键，对于重复的键('A)，只返回最后一个值。dic_a = {'A': 'Apple', 'B': 'Ball', 'A': 'Apricot', 'A': 'Assault'}

print (dic_a)

>>> {'A': 'Assault', 'B': 'Ball'}

Python 3.9中的更简单方法+

从Python 3.9开始，你可以使用|操作符连接两个或多个字典。dic_a = {'A': 'Apple', 'B': 'Ball'}

dic_b = {'C': 'Cat', 'D': 'Dog'}

dic_c = dic_a | dic_b

>>> {'A': 'Apple', 'B': 'Ball', 'C': 'Cat', 'D': 'Dog'}

# 连接两个以上的字典

dic_d = dic_a | dic_b | dic_c

6 修改字典

如果要将“A”的值从“Apple”更改为“Apricot”，可以使用一个简单的赋值。dic_a = {'A': 'Apple', 'B': 'Ball', 'C': 'Cat'}

dic_a['A'] = 'Apricot'

print (dic_a)

>>> {'A': 'Apricot', 'B': 'Ball', 'C': 'Cat', 'D': 'Dog'}

7 字典排序

字典中不维护顺序。字典中不维护顺序。你可以使用键或使用sorted()函数的值对字典进行排序。

按键排序

如果键是字符串，它们将按字母顺序排序。在字典中，我们有两个主要元素：键和值。因此，在对键进行排序时，我们使用第一个元素，即键，因此，lambda函数中使用的索引是“[0]”。关于lambda函数的更多信息，可以阅读这篇文章。dic_a = {'B': 100, 'C': 10, 'D': 90, 'A': 40}

sorted(dic_a.items(), key=lambda x: x[0])

>>> [('A', 40), ('B', 100), ('C', 10), ('D', 90)]

排序不是in-place。如下所示，如果现在打印字典，它将保持无序，与最初初始化时一样。你必须在分类后重新赋值。# 如果你把这个字典打印出来，它还是没有顺序

print (dic_a)

>>> {'B': 100, 'C': 10, 'D': 90, 'A': 40}

如果要按逆序排序，请指定关键字reverse=True。sorted(dic_a.items(), key=lambda x: x[0], reverse=True)

>>> [('D', 90), ('C', 10), ('B', 100), ('A', 40)]

按值排序

要根据字典的值对字典进行排序，需要在lambda函数中使用索引“[1]”。dic_a = {'B': 100, 'C': 10, 'D': 90, 'A': 40}

sorted(dic_a.items(), key=lambda x: x[1])

>>> [('C', 10), ('A', 40), ('D', 90), ('B', 100)]

8 字典生成式

它是动态创建字典的一种非常有用的方法，也是动态创建字典的一种非常有用的方法。假设你要创建一个字典，其中键是一个整数，值是它的平方。字典生成式如下所示。dic_c = {i: i**2 for i in range(5)}

print (dic_c)

>>> {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}

如果你希望你的键是字符串，可以使用'f-strings'。dic_c = {f'{i}': i**2 for i in range(5)}

print (dic_c)

>>> {'0': 0, '1': 1, '2': 4, '3': 9, '4': 16}

9 创建字典的其他方法

从列表创建字典

假设你有两个列表，你想用它们创建一个字典。最简单的方法是使用dict()构造函数。names = ['Sam', 'Adam', 'Tom', 'Harry']

marks = [90, 85, 55, 70]

dic_grades = dict(zip(names, marks))

print (dic_grades)

>>> {'Sam': 90, 'Adam': 85, 'Tom': 55, 'Harry': 70}

你还可以将这两个列表压缩在一起，并使用前面所示的字典生成式创建字典。dic_grades = {k:v for k, v in zip(names, marks)}

print (dic_grades)

>>> {'Sam': 90, 'Adam': 85, 'Tom': 55, 'Harry': 70}

传递键值对

你还可以将用逗号分隔的键值对列表传递给dict()构造，它将返回一个字典。dic_a = dict([('A', 'Apple'), ('B', 'Ball'), ('C', 'Cat')])

print (dic_a)

>>> {'A': 'Apple', 'B': 'Ball', 'C': 'Cat'}

如果你的键是字符串，你甚至可以使用更简单的初始化，只使用变量作为键。dic_a = dict(A='Apple', B='Ball', C='Cat')

print (dic_a)

>>> {'A': 'Apple', 'B': 'Ball', 'C': 'Cat'}

10 复制字典

我将用一个简单的例子来解释这一点。字典的复制机制涉及到更多的微妙之处，我建议读者参考这篇Stack Overflow的问题以获得详细的解释：https://stackoverflow.com/q/3...

参考赋值

当你只需将现有字典(父字典)重新指派给新字典时，两者都指向同一个对象(“引用赋值”)。

考虑下面的例子，你将dic_a重新分配给dic_b。dic_a = {'A': 'Apple', 'B': 'Ball', 'C': 'Cat'}

dic_b = dic_a # 简单重新分配

现在，如果你修改dic_b(例如添加一个新元素)，你会注意到该更改也会反映在dic_a中。dic_b['D'] = 'Dog'

print (dic_b)

>>> {'A': 'Apple', 'B': 'Ball', 'C': 'Cat', 'D': 'Dog'}

print (dic_a)

>>> {'A': 'Apple', 'B': 'Ball', 'C': 'Cat', 'D': 'Dog'}

浅拷贝

使用copy()函数创建一个浅拷贝。在浅拷贝中，这两个字典充当两个独立的对象，它们的内容仍然共享相同的引用。如果在新字典(浅表副本)中添加新的键值对，它将不会显示在父字典中。dic_a = {'A': 'Apple', 'B': 'Ball', 'C': 'Cat'}

dic_b = dic_a.copy()

dic_b['D'] = 'Dog'

# New，浅拷贝，有新的键值对

print (dic_b)

>>> {'A': 'Apple', 'B': 'Ball', 'C': 'Cat', 'D': 'Dog'}

# 父字典没有新的键值对

print (dic_a)

>>> {'A': 'Apple', 'B': 'Ball', 'C': 'Cat'}

现在，父字典(“dic_a”)中的内容是否会更改取决于值的类型。例如，在下面，内容是不可变的简单字符串。因此，更改给定键(在本例中为a)的“dic_b”中的值不会更改“dic_a”中键“a”的值。dic_a = {'A': 'Apple', 'B': 'Ball', 'C': 'Cat'}

dic_b = dic_a.copy()

# 在浅拷贝中将现有键替换为新值

dic_b['A'] = 'Adam'

print (dic_b)

>>> {'A': 'Adam', 'B': 'Ball', 'C': 'Cat'}

# 字符串是不可变的，所以'Apple'在dic_a中不会变成'Adam'

print (dic_a)

>>> {'A': 'Apple', 'B': 'Ball', 'C': 'Cat'}

但是，如果“dic_A”中键“A”的值是一个列表，那么在“dic_b”中更改其值将反映“dic_A”(父字典)中的更改，因为列表是可变的。dic_a = {'A': ['Apple'], 'B': 'Ball', 'C': 'Cat'}

# 浅拷贝

dic_b = dic_a.copy()

dic_b['A'][0] = 'Adam'

print (dic_b)

>>> {'A': ['Adam'], 'B': 'Ball', 'C': 'Coal'}

# 列表是可变的，因此更改也会反映在dic_a中

print (dic_a)

>>> {'A': ['Adam'], 'B': 'Ball', 'C': 'Cat'}

11 重命名现有键

假设你想将键“Adam”替换为“Alex”。你可以使用pop函数，因为它删除传递的键(这里是Adam)并返回删除的值(这里是85)。所以你一枪打死两只鸟。

使用返回的(已删除)值将该值分配给新键(这里是Alex)。可能还有更复杂的情况，其中的键是元组。这种情况不在本文的讨论范围之内。dic_a = {'Sam': 90, 'Adam': 85, 'Tom': 55, 'Harry': 70}

dic_a['Alex'] = dic_a.pop('Adam')

print (dic_a)

>>> {'Sam': 90, 'Tom': 55, 'Harry': 70, 'Alex': 85}

12 嵌套字典

嵌套字典在一个字典中有一个或多个字典。下面是具有两层嵌套的嵌套字典的最简单示例。这里，外部字典(第1层)只有一个键值对。但是，现在值本身就是一个字典。dic_a = {'A': {'B': 'Ball'}}

dic_a['A']

>>> {'B': 'Ball'}

type(dic_a['A'])

>>> dict

如果你想进一步访问内部字典(第2层)的键值对，现在需要使用dic_a['a']作为字典。dic_a['A']['B']

>>> 'Ball'

三层字典

让我们添加一个嵌套字典的附加层。现在，dic_a['a']本身是一个嵌套字典，与上面最简单的嵌套字典不同。dic_a = {'A': {'B': {'C': 'Cat'}}}

# 第1层

dic_a['A']

>>> {'B': {'C': 'Cat'}}

# 第2层

dic_a['A']['B']

>>> {'C': 'Cat'}

# 第3层

dic_a['A']['B']['C']

>>> 'Cat'

13 检查字典中是否存在键

你可以使用in运算符查找字典中是否存在特定键。dic_a = {'A': 'Apple', 'B': 'Ball', 'C': 'Cat', 'D': 'Dog'}

'A' in dic_a

# True

'E' in dic_a

# False

在上面的代码中，你不需要使用“in dic_a.keys( )”，因为“in dic_a”已经在键中查找了。