Python 字典
在 Python 编程教程的这一部分中，我们将更详细地介绍 Python 字典。
Python 字典是键-值对的容器。 它是可变的，可以包含混合类型。 字典是无序集合。 Python 字典在其他语言中称为关联数组或哈希表。 字典中的键必须是不可变的对象，例如字符串或数字。 它们在字典中也必须是唯一的。
Python 字典创建
首先，我们展示如何创建 Python 字典。
create_dict.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)
在示例中，我们以四种不同方式创建四个字典。 稍后，我们将这些字典的内容打印到控制台。
weekend = { "Sun": "Sunday", "Mon": "Monday" }
我们使用字典字面值表示法创建周末字典。 键值对用大括号括起来。 两对之间用逗号分隔。 一对的第一个值是键，后跟一个冒号和一个值。 "Sun"字符串是键，"Sunday"字符串是值。
vals = dict(one=1, two=2)
可以使用dict()函数创建字典。
capitals = {}
capitals["svk"] = "Bratislava"
capitals["deu"] = "Berlin"
capitals["dnk"] = "Copenhagen"
第三种方法是创建一个空的大写字典。 三对将添加到字典中。 键位于方括号内，值位于分配的右侧。
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条件指定必须满足的条件。 最后，对表达式进行求值。 该表达式从满足条件的输入序列成员中产生输出字典的元素。
comprehension.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)
在示例中，我们从现有字典创建一个新字典。
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 字典的一些基本操作。
basics.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'))
我们有一个装着不同水果的篮子。 我们对购物篮字典执行一些操作。
basket = { 'oranges': 12, 'pears': 5, 'apples': 4 }
将创建篮子字典。 它最初具有三个键值对。
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()。
fruits.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()方法将返回一个值。 否则，它将插入具有指定默认值的键并返回该值。
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()方法添加两个 Python 字典。
domains.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()方法结合在一起。
domains.update(domains2)
使用update()方法将domains2字典添加到域字典中。
$ ./domains.py
{'sk': 'Slovakia', 'de': 'Germany', 'no': 'Norway',
'us': 'United States', 'hu': 'Hungary'}
结果显示所有值。
Python 从字典中删除项目
现在我们展示如何从字典中删除一对。
removing.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)
项目字典有六个键值对。 我们将从该字典中删除配对。
item = items.pop("coins")
print("Item having value {0} was removed".format(item))
pop()方法删除具有指定键的一对； 它返回已删除键的值。
del items["bottles"]
del关键字从项目字典中删除"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()方法返回键值元组的列表。
keys_values.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关键字是否存在键。
print(domains.keys())
我们使用keys()方法打印domains字典的键列表。
print(domains.values())
我们使用values()方法打印domains字典的值列表。
print(domains.items())
最后，我们使用items()方法打印域字典的键值元组列表。
print("de" in domains)
print("cz" in domains)
使用in关键字，我们检查domains字典中是否存在"de"和"cz"键。 返回值为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关键字完成。
looping.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字典以打印键，值以及字典的键和值。
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运算符，我们可以检查字典中是否存在键。
membership.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
#!/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]))))
第一个示例提供了最简单的解决方案，以按键对数据进行排序。
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
项目字典按其键排序。
内置的sorted()函数可以完成更有效的分类。
sorting.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()函数按其键升序和降序打印排序的数据。
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
sorting.py脚本的输出。
在下一个示例中，我们将按项目的值对项目进行排序。
sorting2.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))
该示例按值的升序和降序打印数据。
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 字典的文章。
