阅读《Python编程从入门到实践》Day05

第六章

1、一个简单的字典

alien_0 = {'color': 'green', 'points': '5'}
print(alien_0['color'])
print(alien_0['points'])
# 输出：
green
5

2、使用字典

在Python中，字典是一系列键-值对。每个键都与一个值相关联，你可以使用键来访问与之相关联的值。与键相关联的值可以是数字、字符串、列表乃至字典，实际上，任何Python对象都可以用作字典中的值。
在Python中，字典用放在花括号{}中的一系列键-值对来表示。键-值对是两个相关联的值。指定键时，Python将返回与之相关联的值。键和值之间用冒号分隔，而键-值对之间用逗号分隔，字典可以存储任意数量的键-值对。

（1）访问字典中的值

要获取与键相关联的值，可依次指定字典名和放在方括号内的键。如文章开头的例子中就是如此。

（2）添加键-值对

字典是一种动态结构，可随时在其中添加键-值对。要添加键-值对，可依次指定字典名、用方括号括起来的键和相关联的值。如：

alien_0 = {'color': 'green', 'points': '5'}
print(alien_0)
alien_0['x_position'] = 0
alien_0['y_position'] = 25
print(alien_0)
# 输出：
{'color': 'green', 'points': '5'}
{'color': 'green', 'points': '5', 'x_position': 0, 'y_position': 25}

值得注意的是，键-值对的排列顺序与添加顺序不同。Python不关心键-值对的添加顺序，而只关心键和值之间的关联关系。

（3）先创建一个空字典

可用一对空的花括号来创建一个空字典，然后再分行添加各个键-值对。

alien_0 = {}
print(alien_0)
alien_0['color'] = 'green'
alien_0['points'] = 5
print(alien_0)
# 输出：
{}
{'color': 'green', 'points': 5}

在使用字典来存储用户提供的数据或在编写能自动生成大量键-值对的代码时，通常都需要先定义一个空字典。

（4）修改字典中的值

要修改字典中的值，可依次指定字典名、用方括号括起的键以及与该键相关联的新值。如将颜色由绿色改成黄色：

alien_0 = {'color': 'green'}
print(alien_0)
alien_0['color'] = 'yellow'
print(alien_0)
# 输出：
{'color': 'green'}
{'color': 'yellow'}

（5）删除键-值对

对于字典中不再需要的信息，可使用del语句将相应的键-值对彻底删除。使用del语句时，必须指定字典名和要删除的键。已经删除的键-值对将永远消失。

alien_0 = {'color': 'green', 'points': 5}
print(alien_0)
del alien_0['points']
print(alien_0)
# 输出：
{'color': 'green', 'points': 5}
{'color': 'green'}

（6）由类似对象组成的字典

上述的各个例子中，字典存储的是一个对象的多种信息，但字典也可以用来存储众多对象的同一种信息。如：

favorite_languages = {
    'jen': 'Python',
    'sarah': 'C',
    'edward': 'Ruby',
    'phil': 'Python',
    }

在使用多行来定义字典后，在右花括号前添加与键-值对同样的缩进。另外一种不错的做法是在最后一个键-值对后面也加上逗号，为以后在下一行添加键-值做好准备。

3、遍历字典

Python支持对字典遍历。因为字典可用于以各种方式存储信息，所以有多种遍历字典的方式：可遍历字典的所有键-值对、键或值。

（1）遍历所有的键-值对

user_0 = {
    'username': 'efermi',
    'first': 'enrico',
    'last': 'fermi',
    }
for key, value in user_0.items():
    print('key: ' + key)
    print('value: ' + value)
# 输出：
key: username
value: efermi
key: first
value: enrico
key: last
value: fermi

编写用于遍历字典的for循环，可声明两个变量，用于存储键-值对中的键和值。变量的名称可以是任意的，但最好具有一定的描述性。for语句的第二部分包含字典名和方法items()，它返回一个键-值对列表。即使在遍历字典时，键-值对的返回顺序也与存储顺序不同。

（2）遍历字典中的所有键

在不需要使用字典中的值时，可用方法keys()来遍历字典中的所有键。

favorite_languages = {
    'jen': 'Python',
    'sarah': 'C',
    'edward': 'Ruby',
    'phil': 'Python',
    }
for name in favorite_languages.keys():
    print(name.title())
# 输出：
Jen
Sarah
Edward
Phil

遍历字典时，会默认遍历所有的键，因此，如果将上述代码中的for name in favorite_languages.keys():替换成for name in favorite_languages:，输出不会改变。
方法keys()并非只能用于遍历，它实际上返回的是一个列表，一个包含字典中多有键的列表。

（3）按顺序遍历字典中的所有键

字典总是明确地记录键和值之间的关联关系，但获取字典的元素时，获取顺序时不可预测的。如果要以特定的顺序返回元素，一种办法就是在for循环中对返回的键进行排序。

favorite_languages = {
    'jen': 'Python',
    'sarah': 'C',
    'edward': 'Ruby',
    'phil': 'Python',
    }
for name in sorted(favorite_languages.keys()):
    print(name.title())
# 输出：
Edward
Jen
Phil
Sarah

（4）遍历字典中的所有值

可使用方法values()遍历字典中的所有值，它返回一个列表，而不包含任何键。

favorite_languages = {
    'jen': 'Python',
    'sarah': 'C',
    'edward': 'Ruby',
    'phil': 'Python',
    }
for language in set(favorite_languages.values()):
    print(language)
# 输出：
Python
Ruby
C

当提取出来的字典中的值时，会发现有一些重复的值，所以为了剔除重复项，在这里使用了方法set()，可让Python找出列表中独一无二的元素，并使用这些元素来创建一个集合。

4、嵌套

有时候，需要将一系列的字典存储在列表中，或将列表作为值存储在字典中，甚至将字典作为值存储在字典中，这称为嵌套。

（1）字典列表

将字典作为元素存储在列表中。

alien_0 = {'color': 'green', 'points': 5}
alien_1 = {'color': 'yellow', 'points': 10}
alien_2 = {'color': 'red', 'points': 15}
aliens = [alien_0, alien_1, alien_2]
for alien in aliens:
    print(alien)
# 输出：
{'color': 'green', 'points': 5}
{'color': 'yellow', 'points': 10}
{'color': 'red', 'points': 15}

在这里首先创建了三个键一样的字典，并将它们存储在一个列表当中，通过for循环将其遍历输出。

（2）在字典中存储列表

pizza = {
    'crust': 'thick',
    'toppings': ['mushrooms', 'extra cheese'],
    }
print("You ordered a " + pizza['crust'] + "-crust pizza " +
      "with the following toppings:")
for topping in pizza['toppings']:
    print('\t' + topping)
# 输出：
You ordered a thick-crust pizza with the following toppings:
    mushrooms
    extra cheese

这里的披萨配料是一个列表，作为键‘toppings’相关联的值存储在字典中。
注意列表和字典的嵌套层级不应太多，如果嵌套的层级太多，很可能会有更简单的解决问题的方案。

（3）在字典中存储字典

users = {
    'aeinstein': {
        'first': 'albert',
        'last': 'einstein',
        'location': 'princeton',
        },
    'mcurie': {
        'first': 'marie',
        'last': 'curie',
        'location': 'paris',
        },
    }
for username, user_info in users.items():
    print("\nUsername: " + username)
    full_name = user_info['first'] + ' ' + user_info['last']
    location = user_info['location']
    print('\tFull name: ' + full_name.title())
    print('\tLocation: ' + location.title())
# 输出：
Username: aeinstein
    Full name: Albert Einstein
    Location: Princeton

Username: mcurie
    Full name: Marie Curie
    Location: Paris

这里定义了一个名为users的字典，其中包含两个键：用户名‘aeinstein’和‘mcurie’；与每个键相关联的值都是一个字典，其中包含用户的名、姓和居住地。
另外，字典的结构尽量相同，虽然Python并没有这样的要求，但这样可以使得嵌套的字典处理起来更容易。