# Python 字典

> 原文： [http://zetcode.com/lang/python/dictionaries/](http://zetcode.com/lang/python/dictionaries/)

在 Python 编程教程的这一部分中，我们将更详细地介绍 Python 字典。

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

## Python 字典创建

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

`create_dict.py`

```py
#!/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)

```

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

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

```

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

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

```

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

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

```

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

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

```

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

```py
$ ./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 字典推导式

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

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

```

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

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

`comprehension.py`

```py
#!/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)

```

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

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

```

我们有一个大写的字典。 键是大写的，而人口就是值。

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

```

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

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

```

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

## Python 字典的基本操作

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

`basics.py`

```py
#!/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'))

```

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

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

```

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

```py
basket['bananas'] = 5

```

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

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

```

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

```py
print(basket['apples'])

```

`"apples"`键的值会打印到终端上。

```py
basket['apples'] = 8

```

`"apples"`键的值被修改。 设置为数字 8。

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

```

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

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

```

该行返回`'undefined'`。 篮子里没有樱桃。

```py
$ ./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`

```py
#!/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()`方法将返回一个值。 否则，它将插入具有指定默认值的键并返回该值。

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

```

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

```py
fruits = {}.fromkeys(basket, 0)

```

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

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

```

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

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

```

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

```py
$ ./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`

```py
#!/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()`方法结合在一起。

```py
domains.update(domains2)

```

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

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

```

结果显示所有值。

## Python 从字典中删除项目

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

`removing.py`

```py
#!/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)

```

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

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

```

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

```py
del items["bottles"]

```

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

```py
items.clear()

```

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

```py
$ ./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`

```py
#!/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`关键字是否存在键。

```py
print(domains.keys())

```

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

```py
print(domains.values())

```

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

```py
print(domains.items())

```

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

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

```

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

```py
$ ./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`

```py
#!/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`字典以打印键，值以及字典的键和值。

```py
for key in domains:
    print(key)

```

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

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

```

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

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

```

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

```py
$ ./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`

```py
#!/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`

```py
#!/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]))))

```

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

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

```

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

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

```

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

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

```

项目字典按其键排序。

内置的`sorted()`函数可以完成更有效的分类。

`sorting.py`

```py
#!/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()`函数按其键升序和降序打印排序的数据。

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

```

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

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

```

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

```py
$ ./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`

```py
#!/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))

```

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

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

```

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

```py
$ ./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 字典的文章。