跳转至

Python 字典

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

Python 字典创建

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

create_dict.py 
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
#!/usr/bin/env 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)

在示例中，我们以四种不同方式创建四个字典。 稍后，我们将这些词典的内容打印到控制台。

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

我们使用字典文字表示法创建周末字典。 键值对用大括号括起来。 两对之间用逗号分隔。 一对的第一个值是键，后跟一个冒号和一个值。 "Sun"字符串是键，"Sunday"字符串是值。

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

可以使用dict()功能创建字典。

1
2
3
4
capitals = {}
capitals["svk"] = "Bratislava"
capitals["deu"] = "Berlin"
capitals["dnk"] = "Copenhagen"

第三种方法是创建一个空的大写字典。 三对将添加到词典中。 键位于方括号内，值位于分配的右侧。

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

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

1
2
3
4
5
6
$ ./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 字典推导式

词典理解是一种基于现有词典创建词典的语法结构。

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

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

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

comprehension.py 
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
#!/usr/bin/env 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)

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

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

我们有一个大写的字典。 关键在于资本，而人口就是价值。

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

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

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

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

Python 字典的基本操作

以下示例显示了使用 Python 词典的一些基本操作。

basics.py 
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
#!/usr/bin/env 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'))

我们有一个装着不同水果的篮子。 我们对购物篮字典执行一些操作。

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

将创建篮子字典。 它最初具有三个键值对。

1
basket['bananas'] = 5

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

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

len()函数给出字典中的对数。

1
print(basket['apples'])

“苹果”键的值会打印到终端上。

1
basket['apples'] = 8

“苹果”键的值被修改。 设置为数字 8。

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

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

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

该行返回“未定义”。 篮子里没有樱桃。

1
2
3
4
5
6
7
$ ./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()。

fruits.py 
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
#!/usr/bin/env 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()方法将返回一个值。 否则，它将插入具有指定默认值的键并返回该值。

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

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

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

fromkeys()方法创建一个新的词典，列表项将作为关键字。 每个键都将初始化为 0。请注意fromkeys()方法是一个类方法，需要调用该类名，在本例中为{}。

1
2
3
fruits['oranges'] = 12
fruits['pears'] = 8
fruits['apples'] = 4

在这里，我们向fruits字典添加一些值。

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

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

1
2
3
4
5
$ ./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()方法添加两个 Python 字典。

domains.py 
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
#!/usr/bin/env python

# domains.py

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

domains.update(domains2)

print(domains)

两个字典通过update()方法结合在一起。

1
domains.update(domains2)

使用update()方法将domains2字典添加到域字典中。

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

结果显示所有值。

Python 从字典中删除项目

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

removing.py 
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
#!/usr/bin/env 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)

项目字典有六个键值对，我们将从该词典中删除配对。

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

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

1
del items["bottles"]

del关键字从项目字典中删除"bottles": 4对。

1
items.clear()

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

1
2
3
4
5
6
$ ./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()方法返回键值元组的列表。

keys_values.py 
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
#!/usr/bin/env 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关键字是否存在键。

1
print(domains.keys())

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

1
print(domains.values())

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

1
print(domains.items())

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

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

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

1
2
3
4
5
6
7
$ ./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 关键字完成。

looping.py 
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
#!/usr/bin/env 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字典以打印键，值以及字典的键和值。

1
2
for key in domains:
    print(key)

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

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

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

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

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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
$ ./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运算符，我们可以检查字典中是否存在键。

membership.py 
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
#!/usr/bin/env 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 字典是无序的，这也意味着它们不能像 Python 列表那样排序，程序员可以创建 Python 字典的排序表示形式。 在本节中，我们展示了几种创建排序输出的方法。

程序员可能希望以正常或相反的顺序对数据进行排序。 他们可以按键或按值对数据进行排序。

simple_sort.py 
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
#!/usr/bin/env 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]))))

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

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

从字典中获得键列表。 该列表使用sort()方法排序。

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

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

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

项目字典按其键排序。

内置的sorted()功能可以完成更有效的分类。

sorting.py 
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
#!/usr/bin/env 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()功能按其键升序和降序打印排序的数据。

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

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

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

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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
$ ./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

sorting.py脚本的输出。

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

sorting2.py 
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
#!/usr/bin/env 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))

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

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

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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
$ ./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

从输出中我们可以看到，这次按它们的值排序。