5、字典

• 字典定义

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

• 字典初始化
  我们可以定义空的字典，以便后面向其中批量的添加键值对。
  当我们定义的字典中初始话的键值对太多时，可以将较大的字典放在多行，每行以冒号结尾，推荐最后一个键值对后面也加上逗号，为以后在下一行添加键值对做好准备。最后最好为后大括号添加缩进，使得其与键值对对齐。

alien_0 = {}  #定义空的字典
print(alien_0)

favorite_languages = {
   'jen': 'Python',
   'sarah': 'c',
   'edward': 'ruby',
   'phil': 'Python',
   }    #添加了缩进使得与键值对对齐

print(favorite_languages)

输出：
{}
{'jen': 'Python', 'sarah': 'c', 'edward': 'ruby', 'phil': 'Python'}

• 访问字典

要获取与键相关的值，可依次指定字典名和放在括号内的值。

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

alien_0['color'] = 'red'
print(alien_0)

输出：
{'color': 'green', 'points': 5}
{'color': 'red', 'points': 5}

• 向字典中添加键值对
  要添加键值对，可依次指定字典名、用方括号括起来的键和相关联的值。
  在Python3.7中，字典中的元素排列顺序与定义时相同，即字典中元素排列的顺序与添加的顺序保持一致。

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

alien_0['x_position'] = 0
alien_0['y_position'] = 1
print(alien_0)

输出：
{'color': 'green', 'points': 5}
{'color': 'green', 'points': 5, 'x_position': 0, 'y_position': 1}

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

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

del alien_0['color']
print(alien_0)

输出：
{'color': 'green', 'points': 5}
{'points': 5}

• 使用get()来访问值
  当我们访问的键值可能不存在时，应该考虑使用get()，而不要使用方括号。
  get( key, default message)，key是必须的，default message可选，但是建议在不知道键是否存在时要加上提示信息。

favorite_languages = {
    'jen': 'Python',
    'sarah': 'c',
    'edward': 'ruby',
    'phil': 'Python',
    }
    
#寻找存在的键值对
sarah = favorite_languages.get('sarah',"No such a student!")  
print(sarah)

#寻找不存在的键值对
Malong = favorite_languages.get('Malong',"No such a student!")  
print(Malong)

输出：
c
No such a student!

• 遍历字典
  字典中可能包含数百万个键值对，Python支持对字典进行遍历，有多种遍历方式，可以遍历字典的所有键值对，也可仅遍历键或值。
  具体语法见下：

语法：
dictionary = {}
#遍历键值对
for k,v in dictionary.items()
#遍历键
for k in dictionary.keys()
for k in dictionary   #直接遍历字典的时候，默认遍历key
#遍历值
for v in dictionary.values()
for v in set(dictionary.values)

其中，items()返回一个可迭代的键值对列表对象，keys()返回一个可迭代的键列表对象，values()返回一个可迭代的值列表对象。值得一提的是：

• 当我们不适用任何函数，直接使用字典名时，默认是使用keys()函数；
• values()取出的列表是可能重复的，可以使用set来去重;
• 集合是很容易和字典弄混的数据结构，因为二者都是用一对花括号定义的，当花括号中没有键值对的时候，定义的很可能是集合。不同于列表和字典，集合不会以特定的顺序存储元素。集合不会包含重复的元素，也同样可以用for循环遍历。

#集合
union = {'first','second','third','first'}
print(union)

for item in union:
    print(item)

输出：
{'second', 'third', 'first'}
second
third
first

下面展示如何从迭代器中取出元素并生成列表：

dictionary = {
    'jen': 'Python',
    'sarah': 'c',
    'edward': 'ruby',
    'phil': 'Python',
    }

#得到一个可迭代列表对象，每个元素都是一个元组
items_1 = dictionary.items()
print(items_1)
#从中获取元素列表的唯一方法，用for循环迭代取出
items = [item for item in dictionary.items()]
print(items)
#获得列表之后可以对列表进行操作
del items[0]
print(items)
#可以从列表中取出元组
new_tuple = items[0]
print(new_tuple)
#同样可以对取出元组进行操作
new_tuple = (1,2)
print(new_tuple)

输出：
[('jen', 'Python'), ('sarah', 'c'), ('edward', 'ruby'), ('phil', 'Python')]
[('sarah', 'c'), ('edward', 'ruby'), ('phil', 'Python')]
('sarah', 'c')
(1, 2)

下面展示keys()和values()：

dictionary = {
    'jen': 'Python',
    'sarah': 'c',
    'edward': 'ruby',
    'phil': 'Python',
    }

#不使用keys()的默认情况
first_keys = [key for key in dictionary]
print(first_keys)
#使用keys()取得键
second_keys = [key for key in dictionary.keys()]
print(second_keys)

#直接使用values()可能会得到重复的值
repeat_values = [value for value in dictionary.values()]
print(repeat_values)
#使用set()可以对得到的值列表去重
unrepeat_values = [value for value in set(dictionary.values())]
print(unrepeat_values)

输出：
['jen', 'sarah', 'edward', 'phil']
['jen', 'sarah', 'edward', 'phil']
['Python', 'c', 'ruby', 'Python']
['ruby', 'Python', 'c']

• 字典列表
  有时候需要在列表中嵌套字典，也就是字典的列表。例如在外星人大战游戏中，对于外星人，可能有很多的颜色，消灭不同的外星人有不同的得分，但是我们希望所有的外星人都存在一个列表中以便于访问，我们可以如下做：

aliens = []
color = ('red', 'yellow', 'blue')
for i in range(5):
    alien = {'color':color[i%3], 'score':(i+1)%3,}
    aliens.append(alien)
print(aliens)

输出：
[{'color': 'red', 'score': 1}, {'color': 'yellow', 'score': 2}, {'color': 'blue', 'score': 0}, {'color': 'red', 'score': 1}, {'color': 'yellow', 'score': 2}]

• 在字典中存储列表
  有时候需要将列表存在字典中，比如客人去陕西biangbiang面馆点餐，不同的客人可能要不同的辣度，不同的酸度，宽面或者细面，我们希望将每个客人的需求存储在客人的专属列表中：

orders = {}
spicy = ('wei la', 'zhong la', 'te la')
acidity = ('bu jia', 'shao suan', 'duo suan')
noodles = ('kuan', 'xi')

for i in range(5):
   guest = []                     #此处注意要放在里面初始化，否则会一直往后加
   guest.append(spicy[i%3])
   guest.append(acidity[i%3])
   guest.append(noodles[i%2])
   orders[f"guest{i}"] = guest
print(orders)

输出：
{'guest0': ['wei la', 'bu jia', 'kuan'],
'guest1': ['zhong la', 'shao suan', 'xi'],
'guest2': ['te la', 'duo suan', 'kuan'],
'guest3': ['wei la', 'bu jia', 'xi'], 
'guest4': ['zhong la', 'shao suan', 'kuan']}

这里要注意一个点，列表的深复制和浅复制问题：

first_items = [1,2,3]
second_items = first_items[:]
dic = {'first':first_items, 'second':second_items}
print(dic)

#清除第一个列表
first_items.clear()
print(dic)

输出：
{'first': [1, 2, 3], 'second': [1, 2, 3]}
{'first': [], 'second': [1, 2, 3]}

这里可以看到，当我们清除了第一个列表之后，字典的第一个键值对的值也被清除掉了，这就是浅复制的问题，即使第一个列表作为字典的第一个键值对的值存在，但是它和列表指向的是同一块内存，所以在列表被删除掉之后，该值也消失了，反观第二个深复制的列表就不存在这个问题。这样存在问题的同时在某些情况下也有好处，好处就是当我们改变列表的值时，在字典中会自动同步，不需要我们再次修改字典。
在上一段代码示例的for循环中，我们将guest列表的初始化放在for循环里，这样的效果是每个一循环开始，都会重新分配一块内存区域，这样就可以避免一直在一个列表末尾添加数据的问题，以及相应的进行深复制的问题。

• 在字典中存储字典
  有时我们需要在字典中加入字典，这里和在字典中加入列表不同的点在于：在字典中要加入的数据是有关键字的。例如在一个班级里，每个学生有班级和学号。如下：

students = {
   'xiao ming':{					#这里使用冒号而不是等号
       'class':1,
       'number':111,
   },						        #注意不要忘记逗号
   'xiao hong':{
       'class':2,
       'number':222
   },
}

print(students)

输出：
{'xiao ming': {'class': 1, 'number': 111},
'xiao hong': {'class': 2, 'number': 222}}