字典Dictionary

字典结构

Python中字典是一种非常实用的结构，熟练使用Python中的字典能够有很大的帮助。

author = {'name':'Zhangsong','book_name':'asdfghjkl'}
print(author)
print(author['name'])
print(author['book_name'])

{'name': 'Zhangsong', 'book_name': 'asdfghjkl'}
Zhangsong
asdfghjkl

在Python中，字典使用花括号（{}）括起来的，且字典中都是以键值对的形式存在的内容；键值对是由冒号（：）分开的内容，冒号前面的被称为键，冒号后面的则被成为值；字典的定义形式：dictionary = {'key1':'value1','key2':'value2','key3':'value3'}

键值对是两个相关联的值，如上代码所示，我们访问某个键（key）时，会返回其对应的值，如字符串‘name’是一个键，与之关联的值则是‘Zhangsong’，当然在字典中可以由多个键值对，也可以只有一个键值对。

访问字典中的值

要获取与键相关联的值，可依次指定字典名和键；正如上面的程序所示，我们给出字典名author，并且给出键‘name’，这样组成author[‘name’]，这样就可以访问到键所对应的值。

键值对的相关操作

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

dictionary['key4'] = 'value4'
print(dictionary['key4'])

value4

ch

修改字典中的值，修改字典中的值，可以依次指定字典名，用方括号括起来的键，以及该键所对应的新的值。

print(author['name'])
author['name'] = 'lisi'
print(author)

Zhangsong
{'name': 'lisi', 'book_name': 'asdfghjkl'}

可以看到，author字典的’name‘原本为’Zhangsong‘，现在已经修改为’lisi‘了

删除键值对，有时候我们可能不再需要字典中的某些信息，我们可以使用del语句将相对应的键值对彻底删除，使用del语句，必须指定字典名和要删除的键。

dictionary = {'key1':'value1','key2':'value2','key3':'value3'}
del(dictionary['key3'])
print(dictionary)

{'key1': 'value1', 'key2': 'value2'}

使用get()方法来访问值

我们可以通过使用字典名与方括号中加键的方法来获取值，但是，有时候如果我们记错了，字典中并没有我们想要的键，这时候，以上的获取值的方式就会报错。

del(dictionary['key3'])
print(dictionary)
print(dictionary['key3'])

Traceback (most recent call last):
  File "E:\PycharmProjects\learn\Dictionary.py", line 21, in <module>
    print(dictionary['key3'])
KeyError: 'key3'
{'key1': 'value1', 'key2': 'value2'}

字典的get()方法，有两个参数。第一个参数是不可为空的，用于指定要访问的键；第二个参数是可选的，当指定的键不存在时返回该信息，默认为None。

# get()方法
get1 = dictionary.get('key3')
get2 = dictionary.get('key4')
print(get1)
print(get2)

value3
None

可以看到，这里我都没有指定第二个可选参数，只写入了要访问的键。当要访问的key4不存在时，默认返回None。

get1 = dictionary.get('key3', 'No value assigned')
get2 = dictionary.get('key4', 'No value assigned')
print(get1)
print(get2)

value3
No value assigned

这一段代码中，我指定了可选的参数，当要访问的键不存在时，返回一个‘No value assigned’的提示。

遍历字典

一个Python字典可以包含成千上万个键值对，字典可以包含大量数据，Python也支持对字典进行遍历。由于Python字典存储信息的方式很多，所以我们可以既遍历键也遍历值，也可以只遍历键或只遍历值。

遍历所有键值对

如果想要访问字典中所有的键值对，应该怎么操作呢？还是用for循环来遍历这个字典。由于我们想要遍历字典中的所有键值对，也就是key:value，这样的形式，这里就有两个量需要取出，一个是key，一个是value。所以，在for循环中，我们也需要声明两个变量来进行取值，这样取值的时候，key给到第一个变量，value则给到第二个变量。

student1 = {
    'stu_name':'Sun',
    'grade':'1',
    'data_structure': 90,
    'operating_system': 85,
    'C program': 85
}
for key,value in student1.items():
    print(f"{key}:{value}")

stu_name:Sun
grade:1
data_structure:90
operating_system:85
C program:85

这里可以看到for循环声明的两个变量，一个为key，一个为value，in后面则是调用了字典的items()方法，返回可遍历的(键, 值) 元组列表。

这里小提一下items()方法，

print(student1.items())

dict_items([('stu_name', 'Sun'), ('grade', '1'), ('data_structure', 90), ('operating_system', 85), ('C program', 85)])

可以看到items()方法返回的是一个列表，列表中的每一个元素又是一个元组，元组中有两个原子元素，分别对应字典中的key和value。

遍历字典中的所有键

有时候，也许我们只需要遍历字典中的键，而不需要值，方法keys()非常合适。

# keys()方法
for key in student1.keys():
    print(f"{key}")

stu_name
grade
data_structure
operating_system
C program

通过这个方法，是非常适合的。不过，即使不用keys()方法，也可以只访问键：

for key in student1:
    print(f"{key}")

stu_name
grade
data_structure
operating_system
C program

遍历字典时，会默认遍历所有的键。但是，显式地使用方法keys()方法可以让代码更加容易理解。

Python 字典(Dictionary) keys() 函数以列表返回一个字典所有的键，其返回的是一个列表。

按特定顺序遍历字典中的所有键

从Python 3.7起，遍历字典时将按插入的顺序返回其中的元素。不过，有些时候我们希望按照某些特定的顺序来访问字典的键。前面，我们提到了，keys()方法返回的是一个列表，而在更之前的列表一章中，我们知道可以对列表进行使用sorted方法进行排序，所以，我们也可以按照排序的键来进行访问。

for key in sorted(student1.keys()):
    print(f"{key}")

C program
data_structure
grade
operating_system
stu_name

注释：

list1 = student1.keys()
print(type(list1))

<class 'dict_keys'>

可以通过keys()方法得到的，具体来说，其类别并不是‘list’而是一个‘dict_keys’类别，所以它没有sort方法，因为sort方法是列表的特有方法。

遍历字典中的所有值

如果只想对字典中的值进行访问，可以使用values()方法来返回一个值列表，不包含任何键。

# values()方法
for value in student1.values():
    print(f"{value}")

Sun
1
90
85
85

当然，准确地说，values()方法返回地类型并不是一个list列表类型，准确地说是一个

print(type(student1.values()))

<class 'dict_values'>

有时候，字典中的值可能会有大量的重复，例如，对于一个学生列表，里面其中记录学生名字和学院名。这其中就会有重复的学院名，有时候我们只希望知道都有那些学院而已，而不必重复，所以可以使用set()方法，set()会去除重复的内容。

info = {
    'Sun': 'CS',
    'Li': 'CS',
    'Wang': 'CE',
    'Wu': 'SS',
    'Zhou': 'CE',
}
for academy in set(info.values()):
    print(f"{academy}")

SS
CE
CS

注释：可以直接使用一对花括号直接创建集合，并在其中用逗号分隔元素。集合和字典很容易混淆，因为他们都是用一对花括号定义的，但是集合中并没有键值对。

academy = {'CS', 'CE', 'SS'}
print(type(academy))
print(academy)

<class 'set'>
{'SS', 'CE', 'CS'}

嵌套

Python的多个结构均可以进行嵌套，例如可以将字典存储在列表中，或将列表作为值存储在字典中，这成为嵌套。我们可以在字典中嵌套列表，可以在列表中嵌套字典，可以在字典中嵌套字典。

列表中嵌套字典

假设我们想在student1字典中存储更多人信息怎么办呢，毕竟现在这里只有一个人的信息。那我们可以建立多个字典，再将字典嵌套再列表中，实现一个字典列表。

student2 = {
    'stu_name': 'Wu',
    'grade': '1',
    'data_structure': 85,
    'operating_system': 85,
    'C program': 87,
}

student3 = {
    'stu_name': 'Li',
    'grade': '2',
    'data_structure': 83,
    'operating_system': 86,
    'C program': 80,
}
stu_list = [student1, student2, student3]
for student in stu_list:
    print(student)

{'stu_name': 'Sun', 'grade': '1', 'data_structure': 90, 'operating_system': 85, 'C program': 85}
{'stu_name': 'Wu', 'grade': '1', 'data_structure': 85, 'operating_system': 85, 'C program': 87}
{'stu_name': 'Li', 'grade': '2', 'data_structure': 83, 'operating_system': 86, 'C program': 80}

我们又创建两个字典，其中每个字典都是一个学生的信息，然后将这些字典加入到列表stu_list中，最后遍历这个列表，并将每个学生信息打印出来。

字典中嵌套列表

有时候，我们需要在字典中存储列表，那要怎么做呢。

students = {
    'name': ['Sun', 'Li', 'Wu'],
    'grade': ['2', '1', '3'],
    'data_structure': ['90', '85', '83'],
    'operating_system': ['87', '85', '86'],
    'C_program': ['85', '85', '86'],
}
print(students)

{'name': ['Sun', 'Li', 'Wu'], 'grade': ['2', '1', '3'], 'data_structure': ['90', '85', '83'], 'operating_system': ['87', '85', '86'], 'C_program': ['85', '85', '86']}

这样就可以定义一个嵌套着字典的列表。

students = {
    'name': ['Sun', 'Li', 'Wu'],
    'grade': ['2', '1', '3'],
    'data_structure': ['90', '85', '83'],
    'operating_system': ['87', '85', '86'],
    'C_program': ['85', '85', '86'],
}
for key in students.keys():
    str_key = key.__str__()
    for values in students[str_key]:
        print(f"{key, values}")

('name', 'Sun')
('name', 'Li')
('name', 'Wu')
('grade', '2')
('grade', '1')
('grade', '3')
('data_structure', '90')
('data_structure', '85')
('data_structure', '83')
('operating_system', '87')
('operating_system', '85')
('operating_system', '86')
('C_program', '85')
('C_program', '85')
('C_program', '86')

有时候，我们希望像表格一样，来看待一些数据，我们希望了解都有那些学生，希望了解这些学生的某些成绩。我们可以利用for循环来获取这些数据，实际上，我们用一个for循环来得到所有的键（key）信息，因为我们知道所有的键对应的实际上是一个列表，所以我们通过这些键来获取对应的列表，最后通过for循环来访问这个列表。所以，整个流程实际上是比较简单的。所有的程序都可以被拆解，我们需要想的问题是我们

当然，以上的格式总让人觉得不够美观，我们可以有更美观的输出方式。

for key in students.keys():
    str_key = key.__str__()
    print(str_key, ":", end=' ')
    for values in students[str_key]:
        print(f"{values}", end='\t')
        if values == students[str_key][-1]:
            print()

name : Sun	Li	Wu
grade : 2	1	3
data_structure : 90	85	83
operating_system : 87	85	86
C_program : 85	85	86

字典中嵌套字典

我们可以在字典中嵌套字典，现实中也有一些地方可能会用到字典嵌套字典的地方。

如《Python编程从入门到实践 第2版》中的例子所示，“如果有多个网站用户， 每个都有独特的用户名， 可在字典中将用户名作为键， 然后将每位用户的信息存储在一个字典中， 并将该字典作为与用户名相关联的值。”

users = {
    'einstein': {
        'first': 'albert',
        'last': 'einstein',
        'location': 'princeton'
    },
    'curie': {
        'first': 'marie',
        'last': 'curie',
        'location': 'pairs',
    },
}

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()}")

Username: einstein
	Full_name:Alberteinstein
	Location:Princeton

Username: curie
	Full_name:Mariecurie
	Location:Pairs