【python基础】字典详解：如何定义、修改、遍历字典、字典中嵌套字典、列表等

本章讲学到：

• 如何定义字典，以及如何使用存储在字典中的信息；
• 如何访问和修改字典中的元素，以及如何遍历字典中的所有信息；
• 如何遍历字典中所有的键值对、所有的键和所有的值；
• 如何在列表中嵌套字典、在字典中嵌套列表以及在字典中嵌套字典。

一. 一个简单的字典

存储了有关特定外星人的信息：

alien_0 = {'color': 'green', 'points': 5}

# 使用键访问值
print(alien_0['color'])
print(alien_0['points'])
1
2
3
4
5
6

 

二. 字典基本语法

在Python中，字典是一系列键值对。每个键都与一个值相关联，你可使用键来访问相关联的值。

可将任何Python对象用作字典中的值：可以是数、字符串、列表乃至字典。

 

1. 定义字典：

在Python中，字典用放在花括号{}中的一系列键值对表示，键和值之间用冒号分隔，而键值对之间用逗号分隔。

alien_0 = {'color': 'green', 'points': 5}
1

 

2. 访问字典中的值

使用键来访问相关联的值

alien_0 = {'color': 'green'}
print(alien_0['color'])
1
2

 

3. 添加键值对

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

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}
1
2
3
4
5
6
7
8
9
10

在Python 3.7中，字典中元素的排列顺序与定义时相同。

 

4. 创建一个空字典

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

alien_0 = {}

alien_0['color'] = 'green'
alien_0['points'] = 5

print(alien_0)
1
2
3
4
5
6

 

5. 修改字典中的值

例如，假设随着游戏的进行，需要将一个外星人从绿色改为黄色：

alien_0 = {'color': 'green'}
print(f"The alien is {alien_0['color']}.")

alien_0['color'] = 'yellow'
print(f"The alien is now {alien_0['color']}.")
1
2
3
4
5

 

6. 删除键值对

使用del语句将相应的键值对彻底删除。

  alien_0 = {'color': 'green', 'points': 5}
  print(alien_0)

# 指定字典名[key_name]
  del alien_0['points']
  print(alien_0)
1
2
3
4
5
6

 

7. 由类似对象组成的字典

例如，假设你要调查很多人，询问他们最喜欢的编程语言，可使用一个字典来存储这种简单调查的结果

favorite_languages = {
    'jen': 'python',
    'sarah': 'c',
    'edward': 'ruby',
    'phil': 'python',
    }
1
2
3
4
5
6

 

8. 使用get()来访问值

使用方法get()在指定的键不存在时返回一个默认值

alien_0 = {'color': 'green', 'speed': 'slow'}

point_value = alien_0.get('points', 'No point value assigned.')
print(point_value)
1
2
3
4

 

二. 遍历字典

1. 遍历所有键值对

user_0 = {
      'username': 'efermi',
      'first': 'enrico',
      'last': 'fermi',
      }

for key, value in user_0.items():
     print(f"\nKey: {key}")
     print(f"Value: {value}")
1
2
3
4
5
6
7
8
9

要编写遍历字典的for循环，可声明两个变量，用于存储键值对中的键和值。这两个变量可以使用任意名称。

for k, v in user_0.items()

1
2

方法items()返回一个键值对列表，for循环依次将每个键值对赋给指定的两个变量。
 

2. 遍历字典中的所有键

在不需要使用字典中的值时，方法keys()很有用。

  favorite_languages = {
      'jen': 'python',
      'sarah': 'c',
      'edward': 'ruby',
      'phil': 'python',
      }

for name in favorite_languages.keys():
      print(name.title())
1
2
3
4
5
6
7
8
9

但注意：遍历字典时，会默认遍历所有的键。因此，如果将上述代码中的：

for name in favorite_languages.keys():
# 替换为：
for name in favorite_languages:
1
2
3

显式地使用方法keys()可让代码更容易理解，你可以选择这样做，但是也可以省略它。

 
遍历键并根据键输出值

  favorite_languages = {
      --snip--
      }

  friends = ['phil', 'sarah']
  for name in favorite_languages.keys():
      print(f"Hi {name.title()}.")

     if name in friends:
          language = favorite_languages[name].title()
          print(f"\t{name.title()}, I see you love {language}!")

# 每个人的名字都会被打印，但只对朋友打特殊消息：
Hi Jen.
Hi Sarah.
    Sarah, I see you love C!
Hi Edward.
Hi Phil.
    Phil, I see you love Python!
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

判断某个key是否在字典中：

  favorite_languages = {
      'jen': 'python',
      'sarah': 'c',
      'edward': 'ruby',
      'phil': 'python',
      }

# 直接能判断整个名字列表
 if 'erin' not in favorite_languages.keys():
      print("Erin, please take our poll!")
 
# 因为她并不包含在这个列表中，所以打印一条消息，邀请她参加调查：
Erin, please take our poll!
1
2
3
4
5
6
7
8
9
10
11
12
13

 

3. 排序后遍历

从Python 3.7起，遍历字典时将按插入的顺序返回其中的元素。
可使用函数sorted()来获得按特定顺序排列的键列表的副本：

favorite_languages = {
    'jen': 'python',
    'sarah': 'c',
    'edward': 'ruby',
    'phil': 'python',
    }

for name in sorted(favorite_languages.keys()): # 在遍历前对这个列表进行排序。
    print(f"{name.title()}, thank you for taking the poll.")
1
2
3
4
5
6
7
8
9

 

4. 遍历值

favorite_languages = {
    'jen': 'python',
    'sarah': 'c',
    'edward': 'ruby',
    'phil': 'python',
    }

print("The following languages have been mentioned:")
for language in favorite_languages.values():
    print(language.title())
1
2
3
4
5
6
7
8
9
10

 
为剔除重复项，可使用集合（set）。

  favorite_languages = {
      --snip--
      }

  print("The following languages have been mentioned:")
 for language in set(favorite_languages.values()): 
# 让Python找出列表中独一无二的元素，并使用这些元素来创建一个集合。
      print(language.title())
1
2
3
4
5
6
7
8

 

5. 定义集合

>>> languages = {'python', 'ruby', 'python', 'c'}
>>> languages
{'ruby', 'python', 'c'}
1
2
3

当花括号内没有键值对时，定义的很可能是集合。不同于列表和字典，集合不会以特定的顺序存储元素。

 

三. 嵌套

将一系列字典存储在列表中，或将列表作为值存储在字典中，这称为嵌套。

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}
1
2
3
4
5
6
7
8
9
10
11

生成30个外星人

  # 创建一个用于存储外星人的空列表。
  aliens = []

  # 创建30个绿色的外星人。
❶ for alien_number in range(30):
❷     new_alien = {'color': 'green', 'points': 5, 'speed': 'slow'}
❸     aliens.append(new_alien)

  # 显示前5个外星人。
❹ for alien in aliens[:5]:
      print(alien)
  print("...")

  # 显示创建了多少个外星人。
❺ print(f"Total number of aliens: {len(aliens)}")
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

 

修改数组

for alien in aliens[0:3]:
    if alien['color'] == 'green':
        alien['color'] = 'yellow'
        alien['speed'] = 'medium'
        alien['points'] = 10
    elif alien['color'] == 'yellow':
        alien['color'] = 'red'
        alien['speed'] = 'fast'
        alien['points'] = 15
1
2
3
4
5
6
7
8
9

 

2. 在字典中存储列表

  # 存储所点比萨的信息。
❶ pizza = {
      'crust': 'thick',
      'toppings': ['mushrooms', 'extra cheese'],
      }

  # 概述所点的比萨。
❷ print(f"You ordered a {pizza['crust']}-crust pizza "
      "with the following toppings:")

❸ for topping in pizza['toppings']:
      print("\"f+topping)
1
2
3
4
5
6
7
8
9
10
11
12

 
遍历字典与列表：

favorite_languages = {
    'jen': ['python', 'ruby'],
    'sarah': ['c'],
    'edward': ['ruby', 'go'],
    'phil': ['python', 'haskell'],
}

for name, subjects in favorite_languages.items():
    print(f"\n{name.title()}'s favorite languages are:")
    for language in subjects:
        print(f"\t{language.title()}")
        print(f'Hi, {name}')  # Press ⌘F8 to toggle the breakpoint.
1
2
3
4
5
6
7
8
9
10
11
12
13

注: 列表和字典的嵌套层级不应太多。如果嵌套层级比前面的示例多得多，很可能有更简单的解决方案。

 

3. 在字典中存储字典

def print_dic():

    users = {
        'aeinstein': {
            'first': 'albert',
            'last': 'einstein',
            'location': 'princeton',
        },
        'mcurie': {
            'first': 'marie',
            'last': 'curie',
            'location': 'paris',
        },
    }
    # 自定义key，value名取值
    for username, user_info in users.items():
        print(f"\nUsername: {username}")
        full_name = f"{user_info['first']} {user_info['last']}"
        location = user_info['location']
        print(f"\tFull name: {full_name.title()}")
        print(f"\tLocation: {location.title()}")
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

 

《python编程：入门到实践（第二版）》