Python 字典

最后修改于 2024 年 3 月 24 日

在本文中，我们使用 Python 字典。

Python 字典 是键值对的容器。它是可变的，可以包含混合类型。字典是无序的集合。在其他语言中，Python 字典被称为关联数组或哈希表。字典中的键必须是不可变对象，例如字符串或数字。它们在字典中也必须是唯一的。

Python 字典创建

首先，我们展示如何创建 Python 字典。

#!/usr/bin/python

# create_dict.py

weekend = { "Sun": "Sunday", "Mon": "Monday" }
vals = dict(one=1, two=2)

capitals = {}
capitals["svk"] = "Bratislava"
capitals["deu"] = "Berlin"
capitals["dnk"] = "Copenhagen"

d = { i: object() for i in range(4) }

print(weekend)
print(vals)
print(capitals)
print(d)

在本例中，我们通过四种不同的方式创建了四个字典。之后，我们将这些字典的内容打印到控制台。

weekend = { "Sun": "Sunday", "Mon": "Monday" }

我们使用字典字面量表示法创建一个 weekend 字典。键值对用花括号括起来。对之间用逗号分隔。一对的第一个值是键，后面跟着一个冒号和一个值。"Sun" 字符串是一个键，"Sunday" 字符串是一个值。

vals = dict(one=1, two=2)

可以使用 dict 函数创建字典。

capitals = {}
capitals["svk"] = "Bratislava"
capitals["deu"] = "Berlin"
capitals["dnk"] = "Copenhagen"

第三种方式是创建一个空的 capitals 字典。向字典添加了三个键值对。键在方括号内，值位于赋值的右侧。

d = { i: object() for i in range(4) }

使用字典推导式创建字典。推导式有两个部分。第一部分是 i: object 表达式，它在循环的每个周期执行。第二部分是 for i in range(4) 循环。字典推导式创建一个包含四个键值对的字典，其中键是数字 0、1、2 和 3，值是简单的对象。

$ ./create_dict.py
{'Sun': 'Sunday', 'Mon': 'Monday'}
{'two': 2, 'one': 1}
{'svk': 'Bratislava', 'dnk': 'Copenhagen', 'deu': 'Berlin'}
{0: <object object at 0xb76cb4a8>, 1: <object object at 0xb76cb4b0>,
2: <object object at 0xb76cb4b8>, 3: <object object at 0xb76cb4c0>}

Python 字典推导式

字典推导式 是一种语法结构，它基于现有字典创建字典。

D = { expression for variable in sequence [if condition] }

字典推导式放在两个花括号之间；它有三个部分：for 循环、条件和表达式。

在 for 循环中，我们遍历字典。可选的 if 条件指定必须满足的条件。最后，对表达式进行求值。表达式从满足条件的输入序列的成员生成输出字典的元素。

#!/usr/bin/python

# comprehension.py

capitals = { "Bratislava": 424207, "Vilnius": 556723, "Lisbon": 564657,
             "Riga": 713016, "Jerusalem": 780200, "Warsaw": 1711324,
             "Budapest": 1729040, "Prague": 1241664, "Helsinki": 596661,
             "Yokyo": 13189000, "Madrid": 3233527 }


capitals2 = { key:val for key, val in capitals.items() if val < 1000000 }

print(capitals2)

在本例中，我们从现有字典创建一个新字典。

capitals = { "Bratislava": 424207, "Vilnius": 556723, "Lisbon": 564657,
             "Riga": 713016, "Jerusalem": 780200, "Warsaw": 1711324,
             "Budapest": 1729040, "Prague": 1241664, "Helsinki": 596661,
             "Yokyo": 13189000, "Madrid": 3233527 }

我们有一个首都字典。键是首都，值是人口。

capitals = { key:val for key, val in capitals.items() if val < 1000000 }

使用字典推导式创建了一个新字典。它包含人口少于一百万的首都。

$ ./comprehension.py
{'Bratislava': 424207, 'Vilnius': 556723, 'Jerusalem': 780200, 'Riga': 713016,
    'Lisbon': 564657, 'Helsinki': 596661}

这些首都的人口少于一百万。

Python 字典的基本操作

以下示例展示了 Python 字典的一些基本操作。

#!/usr/bin/python

# basics.py

basket = { 'oranges': 12, 'pears': 5, 'apples': 4 }

basket['bananas'] = 5

print(basket)
print("There are {0} various items in the basket".format(len(basket)))

print(basket['apples'])
basket['apples'] = 8
print(basket['apples'])

print(basket.get('oranges', 'undefined'))
print(basket.get('cherries', 'undefined'))

我们有一个包含不同水果的购物车。我们在购物车字典上执行一些操作。

basket = { 'oranges': 12, 'pears': 5, 'apples': 4 }

创建了 basket 字典。它最初有三个键值对。

basket['bananas'] = 5

创建了一个新键值对。'bananas' 字符串是键，5 是整数值。

print("There are {0} various items in the basket".format(len(basket)))

len 函数给出字典中键值对的数量。

print(basket['apples'])

将 'apples' 键的值打印到终端。

basket['apples'] = 8

修改了 'apples' 键的值。将其设置为数字 8。

print(basket.get('oranges', 'undefined'))

get 方法检索指定键的值。如果没有这样的键，则返回方法的第二个参数。

print(basket.get('cherries', 'undefined'))

这一行返回 'undefined'。购物车中没有樱桃。

$ ./basics.py
{'bananas': 5, 'pears': 5, 'oranges': 12, 'apples': 4}
There are 4 various items in the basket
4
8
12
undefined

Python 字典 - fromkeys 和 setdefault

下一个示例介绍了两个字典方法：fromkeys 和 setdefault。

#!/usr/bin/python

# fruits.py

basket = ('oranges', 'pears', 'apples', 'bananas')

fruits = {}.fromkeys(basket, 0)
print(fruits)

fruits['oranges'] = 12
fruits['pears'] = 8
fruits['apples'] = 4

print(fruits.setdefault('oranges', 11))
print(fruits.setdefault('kiwis', 11))

print(fruits)

fromkeys 方法从列表创建新字典。setdefault 方法在键存在时返回其值。否则，它会插入一个具有指定默认值的键并返回该值。

basket = ('oranges', 'pears', 'apples', 'bananas')

我们有一个字符串列表。将从该列表构建一个新字典。

fruits = {}.fromkeys(basket, 0)

fromkeys 方法创建一个新字典，其中列表项将是键。每个键都初始化为 0。请注意，fromkeys 方法是类方法，需要类名（在本例中为 {}）才能调用。

fruits['oranges'] = 12
fruits['pears'] = 8
fruits['apples'] = 4

此处我们将一些值添加到 fruits 字典。

print(fruits.setdefault('oranges', 11))
print(fruits.setdefault('kiwis', 11))

第一行将 12 打印到终端。'oranges' 键存在于字典中。在这种情况下，该方法返回其值。在第二种情况下，键尚不存在。将一个新键值对 'kiwis': 11 插入到字典中。并将值 11 打印到控制台。

$ ./fruits.py
{'bananas': 0, 'pears': 0, 'oranges': 0, 'apples': 0}
12
11
{'kiwis': 11, 'bananas': 0, 'pears': 8, 'oranges': 12, 'apples': 4}

运行 fruits.py 脚本时，我们会收到此输出。

Python 字典 update 方法

下一个代码示例演示了如何使用 update 方法添加两个 Python 字典。

#!/usr/bin/python

# domains.py

domains = { "de": "Germany", "sk": "Slovakia", "hu": "Hungary"}
domains2 = { "us": "United States", "no": "Norway" }

domains.update(domains2)

print(domains)

使用 update 方法将两个字典连接起来。

domains.update(domains2)

使用 update 方法将 domains2 字典添加到 domains 字典中。

$ ./domains.py
{'sk': 'Slovakia', 'de': 'Germany', 'no': 'Norway',
'us': 'United States', 'hu': 'Hungary'}

结果显示所有值。

Python 从字典中删除项

现在我们展示如何从字典中删除键值对。

#!/usr/bin/python

# removing.py

items = { "coins": 7, "pens": 3, "cups": 2,
    "bags": 1, "bottles": 4, "books": 5 }

print(items)

item = items.pop("coins")
print("Item having value {0} was removed".format(item))

print(items)

del items["bottles"]
print(items)

items.clear()
print(items)

items 字典有六个键值对。我们将从该字典中删除键值对。

item = items.pop("coins")
print("Item having value {0} was removed".format(item))

pop 方法删除具有指定键的键值对；它返回已删除键的值。

del items["bottles"]

del 关键字从 items 字典中删除 "bottles": 4 键值对。

items.clear()

clear 方法清除字典中的所有项。

$ ./removing.py
{'bags': 1, 'pens': 3, 'coins': 7, 'books': 5, 'bottles': 4, 'cups': 2}
Item having value 7 was removed
{'bags': 1, 'pens': 3, 'books': 5, 'bottles': 4, 'cups': 2}
{'bags': 1, 'pens': 3, 'books': 5, 'cups': 2}
{}

Python 字典的键和值

Python 字典由键值对组成。keys 方法返回字典中的键列表。values 方法创建值列表。items 方法返回键值对元组的列表。

#!/usr/bin/python

# keys_values.py

domains = { "de": "Germany", "sk": "Slovakia", "hu": "Hungary",
    "us": "United States", "no": "Norway"  }

print(domains.keys())
print(domains.values())
print(domains.items())

print("de" in domains)
print("cz" in domains)

我们演示了上述方法。我们还使用 in 关键字检查键是否存在。

print(domains.keys())

我们使用 keys 方法打印 domains 字典的键列表。

print(domains.values())

我们使用 values 方法打印 domains 字典的值列表。

print(domains.items())

最后，我们使用 items 方法打印 domains 字典的键值对元组列表。

print("de" in domains)
print("cz" in domains)

使用 in 关键字，我们检查 "de"、"cz" 键是否存在于 domains 字典中。返回值是 True 或 False。

$ ./keys_values.py
['sk', 'de', 'no', 'us', 'hu']
['Slovakia', 'Germany', 'Norway', 'United States', 'Hungary']
[('sk', 'Slovakia'), ('de', 'Germany'), ('no', 'Norway'),
('us', 'United States'), ('hu', 'Hungary')]
True
False

Python 字典遍历

遍历字典是常见的编程任务。这可以使用 for 关键字完成。

#!/usr/bin/python

# looping.py

domains = { "de": "Germany", "sk": "Slovakia", "hu": "Hungary",
    "us": "United States", "no": "Norway" }

for key in domains:
    print(key)

for val in domains.values():
    print(val)

for k, v in domains.items():
    print(": ".join((k, v)))

在本例中，我们遍历 domains 字典以打印字典的键、值以及键和值。

for key in domains:
    print(key)

此循环打印字典的所有键。

for val in domains.values():
    print(val)

第二个循环打印字典的所有值。

for k, v in domains.items():
    print(": ".join((k, v)))

在第三个循环中，打印所有键和值。

$ ./looping.py
sk
de
no
us
hu
Slovakia
Germany
Norway
United States
Hungary
sk: Slovakia
de: Germany
no: Norway
us: United States
hu: Hungary

Python 字典成员资格测试

使用 in 和 not in 运算符，我们可以检查键是否存在于字典中。

#!/usr/bin/python

# membership.py

domains = { "de": "Germany", "sk": "Slovakia", "hu": "Hungary",
    "us": "United States", "no": "Norway"  }

key = "sk"

if key in domains:
    print("{0} is in the dictionary".format(domains[key]))

在本例中，我们使用 in 运算符检查国家/地区是否在字典中。

Python 字典排序

从 Python 3.7 开始，CPython（Python 最常见的实现）中的字典会维护插入顺序。这意味着在迭代或访问元素时，您添加到字典的键值对的顺序将得以保留。

我们可能希望按正常顺序或反向顺序对数据进行排序。我们可以按键或按值对数据进行排序。

#!/usr/bin/python

# simple_sort.py

items = { "coins": 7, "pens": 3, "cups": 2,
    "bags": 1, "bottles": 4, "books": 5 }

kitems = list(items.keys())
kitems.sort()

for k in kitems:
    print(": ".join((k, str(items[k]))))

第一个示例提供了按键对数据进行排序的最简单解决方案。

kitems = items.keys()
kitems.sort()

从字典中获取键列表。使用 sort 方法对列表进行排序。

for k in kitems:
    print(": ".join((k, str(items[k]))))

在循环中，我们从字典中打印排序后的键及其值。

$ ./simple_sort.py
bags: 1
books: 5
bottles: 4
coins: 7
cups: 2
pens: 3

items 字典按键排序。

使用内置的 sorted 函数可以进行更有效的排序。

#!/usr/bin/python

# sorting.py

items = { "coins": 7, "pens": 3, "cups": 2,
    "bags": 1, "bottles": 4, "books": 5 }

for key in sorted(items.keys()):
    print("%{0}: {1}".format(key, items[key]))

print("###############")

for key in sorted(items.keys(), reverse=True):
    print("{0}: {1}".format(key, items[key]))

在本例中，我们使用 sorted 函数以升序和降序打印按键排序的数据。

for key in sorted(items.keys()):
    print("%{0}: {1}".format(key, items[key]))

在此 for 循环中，我们按升序打印键值对。iteritems 函数返回字典的（键，值）对的迭代器。

for key in sorted(items.keys(), reverse=True):
    print("{0}: {1}".format(key, items[key]))

在第二个 for 循环中，数据按降序排序。排序类型由 reverse 参数控制。

$ ./sorting.py
bags: 1
books: 5
bottles: 4
coins: 7
cups: 2
pens: 3
###############
pens: 3
cups: 2
coins: 7
bottles: 4
books: 5
bags: 1

在下一个示例中，我们将按值对项进行排序。

#!/usr/bin/python

# sorting2.py

items = { "coins": 7, "pens": 3, "cups": 2,
    "bags": 1, "bottles": 4, "books": 5 }

for key, value in sorted(items.items(), key=lambda pair: pair[1]):

    print("{0}: {1}".format(key, value))

print("###############")

for key, value in sorted(items.items(), key=lambda pair: pair[1], reverse=True):

    print("{0}: {1}".format(key, value))

该示例按值以升序和降序打印数据。

for key, value in sorted(items.iteritems(),
    key=lambda (k,v): (v,k)):

字典键值对按其值排序并打印到控制台。key 参数接受一个函数，该函数指示数据如何排序。

$ ./sorting2.py
bags: 1
cups: 2
pens: 3
bottles: 4
books: 5
coins: 7
###############
coins: 7
books: 5
bottles: 4
pens: 3
cups: 2
bags: 1

从输出中我们可以看到，这次键值对是按其值排序的。

来源

Python 数据结构 - 语言参考

在本文中，我们介绍了 Python 字典。

作者

我叫 Jan Bodnar，是一位热情的程序员，拥有丰富的编程经验。自 2007 年以来，我一直在撰写编程文章。迄今为止，我已撰写了 1400 多篇文章和 8 本电子书。我在编程教学方面拥有十多年的经验。

列出所有 Python 教程。