Python编程：从入门到实践（学习笔记-Charpter 6)

Python编程：从入门到实践（学习笔记-Charpter 6)

十月 17, 2019

Chapter 6 : 字典

6.1初识字典

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

​ 与键相关联的值可以是数字、字符串、列表乃至字典。

  • 创建字典

    • 1
      2
      3
      4
      5
      6
      7
      alien_0 = {'color': 'green', 'points': 5}
      print(alien_0['color'])
      print(alien_o['points'])

      #---------学完改进---------
      for k, v in alien.items():  #通过for循环来遍历整个字典的键和值
          print(k + ' : ' + v)

键—值对：是两个相关联的值。指定键时，Python将返回与之前相关联的值。键和值用：隔开，而键—值之间用逗号隔开。

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

new_points = alien_0['point']
print("You just enrned " + str(new_points) + "points!")
  • 添加键—值对
1
2
3
4
5
6
7
alien_0 = {'color': 'green', 'point' : 5}
print(alien_0)

#直接在[ ]中添加键 ，在 = 右边添加 值。
alien_0['x_position'] = 0
alien_0['y_position'] = 25
print(alien_0)

注：Python不太关心键—值对的添加顺序，只关心键—值之间的关联关系。

  • 创建一个空字典

    • 1
      2
      3
      4
      5
      6
      alien_0 = {}

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

      print(alien_0)

  • 修改字典中的值

    • 1
      2
      3
      4
      5
      6
      7
      #修改字典中的值，可依次指定自定名、用方括号起的 键名 及与该键相关联的 新值
      alien_0 = {'color': 'green'}
      print("The alien is " + alien_0['color'] + '.')

      #将颜色改为黄色
      alien_0['color'] = 'yelow' #color 对应的值改为 yellow
      print('The alien is now' + alien_0['color'] + '.')

  • 例子:对外星人的位置进行跟踪

    • 1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      alien_0 = {'x_position': 0, 'y_position': 25, 'speed': 'medium'}
      print("Original x_position: " + str(alien_0['x_position']))

      #向右移动外星人
      #据外星人当前速度决定将其移动多远
      if alien_0['speed'] == 'slow':
          x_increment = 1
      elif alien_0['speed'] == 'medium':
          x_increment = 2
      else:
          #这个外星人的速度很快
          x_increment = 3
          
      #新位置等于老位置加上增量
      alien_0['x_position'] = alien_0['x_position'] + x_increment

      print("New x-position: " + str(alien_0['x_position']))

  • 删除键—值对

    • 使用del 将键—值对彻底删除

    • 1
      2
      3
      4
      alien_0 = {'color': 'green', 'points' : 5}

      del alien_0['points']
      print(alien_0)

    • 多行创建字典

      • 确定需要使用多行来定义字典时，在输入左花括号后按回车键再在下一行缩进四个空格，指定第一个键 — 值对,并在它后面加上一个逗号。此后你再次按回车键时,文本编辑器将自动缩进后续键 — 值对，且缩进量与第一个键 — 值对相同，

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

        print("sarah favorite language is " + favorite_languages['sarah'].title() + ".")

6.2遍历字典

  • 遍历字典中所有的键—值对 items() for循环

    • 1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      favorite_languages = {
          'jen': 'python',
          'sarah': 'c',
          'edward': 'ruby',
          'phil': 'python',
      }
      for name, language in favorite_languages.items():   #❶items S不能忘记
          print(name.title() + "'s favorite language is " + language.title() + ".")
          #❷                                                     ❸  
          
      #要编写用于遍历字典的 for 循环,可声明两个变量,用于存储键 — 值对中的键和值。对于这两个变量,可使用任何名称。下面的代码使用了简单的变量名,for 语句的第二部分包含字典名和方法 items() (见❶),它返回一个键 — 值对列表。接下来, for 循环依次将每个键 — 值对存储到指定的两个变量中。在前面的示例中,我们使用这两个变量来打印每个键(见❷)及其相关联的值(见❸)

  • 遍历字典中所有的键 keys() 

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

      for name in favorite_languages.keys():         #.keys()
          print(name.title())
    • 1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      favorite_languages = {
          'jen': 'python',
          'sarah': 'c',
          'edward': 'ruby',
          'phil': 'python',
      }

      friends = ['phil', 'sarah']
      for name in favorite_languages.keys():
          print(name.title())
          if name in friends:
              print('hi' + name.title() + ', I see you favorite language is ' + favorite_language[name].title() + '!')

  • 按顺序遍历字典中的所有键 sorted( ) 用法不同

    • 1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      #在for循环中对返回的键排序
      favorite_languages = {
          'jen': 'python',
          'sarah': 'c',
          'edward': 'ruby',
          'phil': 'python',
      }

      for name in sorted(favorite_languages.keys()):    # sorted
          print(name.title() + 'thank you for taking the poll.')

  • 遍历字典中所有的值 valus()

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

      print("The following languages have been mentioned:")
      for language in favorite_languages.values():   #.values()
          print(language.title())

    • 剔除重复项 set()

    • 1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      favorite_languages = {
          'jen': 'python',
          'sarah': 'c',
          'edward': 'ruby',
          'phil': 'python',
      }

      print("The following languages have been mentioned:")
      for language in set(favorite_languages.values()):   #set()
          print(language.title())
          
      #通过对包含重复元素的列表调用 set() ,可让 Python 找出列表中独一无二的元素,并使用这些元素来创建一个集合。

6.3嵌套

定义：需要将一系列字典存储在列表中,或将列表作为值存储在字典中,这称为嵌套 。你可以在列表中嵌套字典、在字典中嵌套列表甚至在字典中嵌套字典。

  • 字典列表

    • 1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      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)
          
      #我们首先创建了三个字典,其中每个字典都表示一个外星人。在❶处,我们将这些字典都放到一个名为 aliens 的列表中。最后,我们遍历这个列表,并将每个外星人都打印出来:

      #----
      {'color': 'green', 'points': 5}
      {'color': 'yellow', 'points': 10}
      {'color': 'red', 'points': 15}
      #----
    • 1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      #创建一个用于存储外星人的空列表
      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("Total number of aliens: " + str(aliens ))
    • 1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      #修改外星人列表
      #创建一个用于存储外星人的空列表
      aliens = []

      #创建30个绿色的外星人
      for alien_number in range(0,30):
          new_alien = {'color': 'green', 'points': 5, 'speed': 'slow'}
          aliens.append(new_alien)
          
      for alien in aliens[0:3]:
          if  alien['color'] == 'green':
              alien['color'] = 'yellow'
              alien['speed'] = 'medium'
              alien['point'] = 10

      #显示前5个外星人
      for alien in aliens[0:5]:
          print(alien)
      print("...")
    • 1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      #将黄色外星人的移动速度改为快速，且值15个点的红色外星人
      for alien in aliens[0:30]:
          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
      10
      #存储所点披萨的信息
      pizza = {
          'crust': 'thick',
          'toppings': ['mushroom', 'extra cheese'],
      }

      #概述所点的披萨
      print("You ordered a " + pizza['crust'] + "-crust pizza " + "with the following toppings:")
      for topping in pizza['toppings']:
          print("\t" + topping)
    • 1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      favorite_languages = {
          
          'jen': ['python', 'ruby'],
          'sarah': ['c'],
          'edward': ['ruby','go'],
          'phil': ['python', 'haskell'],
          
      }

      for name, languages in favorite_languages.items():
          if len(languages) == 1 :  #判断是否只含有一个
              print('\n' + name.title() + "'s favorite language is :" )
              for language in languages:
                  print("\t" + language.title())
          else:
              print("\n" + name.title() + "'s favorite languages are:")
              for language in languages:
                  print("\t" + language.title())

  • 在字典中存储字典

    • 1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      20
      21
      22
      23
      24
      25
      26
      #每位用户的字典结构都相同
      users = {
          
          'aeinstein': {
              'first': 'albert',
              'last': 'einstein',
              'loaction': '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())

      • 我们首先定义了一个名为 users 的字典,其中包含两个键:用户名 ‘aeinstein’ 和 ‘mcurie’ ;与每个键相关联的值都是一个字典,其中包含用户的名、姓和居住地。在❶处,我们遍历字典 users ,让 Python 依次将每个键存储在变量 username 中,并依次将与当前键相关联的字典存储在变量 user_info 中。在主循环内部的❷处,我们将用户名打印出来。在❸处,我们开始访问内部的字典。变量 user_info 包含用户信息字典,而该字典包含三个键: ‘first’ 、 ‘last’ 和 ‘location’ ;对于每位用户,我们都使用这些键来生成整洁的姓名和居住地,然后打印有关用户的简要信息(见❹)

##