Python小白学习：超级详细的字典介绍（字典的定义、存储、修改、遍历元素和嵌套）_python 定义字典

一、字典简介

字典由花括号{ }中的一系列键值对表示。

1.1 创建字典

使用一对空花括号来定义一个字典，再分别添加各个键值对。

alien = {}
alien['color'] = 'green'
alien['points'] = 5
print(alien)
1
2
3
4

1.2 访问字典中的值

字典中的元素由键值对组成，要获取与键相关联的值，可依次指定字典名和放在方括号内的键。

alien_0 = {'color':'green','points':5}
print(alien_0['color'])
print(alien_0['points'])
1
2
3

字典中可包含任意数量的键值对。

1.3 添加键值对

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

alien_0 = {'color':'green','points':5}
print(alien_0)
alien_0['x_position'] = 0
alien_0['y_position'] = 25
print(alien_0)
1
2
3
4
5

1.4 修改字典中的值

想要修改字典中的值，可以依次指定字典名，用方括号括起来的键，以及与该键相关联的新值。

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

实例

对一个能够以不同速度移动的外星人进行位置跟踪，设置外星人的移动速度有‘快、慢、中等’3个速度，快速一次向右移动3m，慢速一次向右移动1m，中等速度一次向右移动2m，现在外星人的位置为（0,25），机器人以不同的速度移动后的位置分别为多少？

alien = {'name':'alen','color':'red','x_position':0,'y_position':25,'speed':'medium'}
position = (alien['x_position'],alien['y_position'])
print(f"The position is {position}")
if alien['speed'] == 'fast':
    x = 3
elif alien['speed'] == 'medium':
    x = 2
elif alien['speed'] == 'slow':
    x = 1
alien['x_position'] += x
new_position = (alien['x_position'],alien['y_position'])
print(f"The new position with the speed of {alien['speed']} is {new_position}")
1
2
3
4
5
6
7
8
9
10
11
12

代码中设置的是速度为medium时的位置坐标。

修改字典中speed键对应的值，可以得到不同速度的位置。

1.5 删除键值对

使用del语句删除不需要的键值对

alien = {'name':'alen','color':'red','x_position':0,'y_position':25,'speed':'fast'}
print(alien)
del alien['name']
print(alien)
1
2
3
4

1.6 由多个类似对象组成的字典

在前面的例子中，字典存储的是一个对象（alien）的多个属性，也可以用字典存储诸多对象的同种信息，如使用一个字典存储每个人最喜欢的编程语言。

favorite_lauguague = {
    'ken':'python',
    'jack':'c++',
    'will':'java',
    'mary':'ruby'
}
print(f"Will's favorite lauguague is {favorite_lauguague['will'].title()}")
1
2
3
4
5
6
7

在定义长字典时可以使用上面所示的多行定义。

1.7 使用get()访问值

• get(键，指定键不存在时返回的值)

该函数可以处理当想要查询的键不存在时的异常情况。

favorite_languague = {
    'ken':'python',
    'jack':'c++',
    'will':'java',
    'mary':'ruby'
}
print(favorite_languague)
languague = favorite_languague.get('diane','ERROR!No Such People Named Diane!')
print(languague)
favorite_languague['diane'] = 'c'
languague = favorite_languague.get('diane','ERROR!No Such People Named Diane!')
print(favorite_languague)
print(languague)
1
2
3
4
5
6
7
8
9
10
11
12
13

上述代码中：

• 使用get查询不存在的键时（diane不存在），会返回get方法中定义的发生异常时的字符串；
• 使用get查询存在的键时（为diane键赋对应的值为c），会返回该键对应的值。

1.8 练习题

print('6-1')
people = {
    'first_name':'winnie',
    'last_name':'ma',
    'age':22,
    'city':'zibo'
}
print(people)

print('6-2')
favorate_numbers={
    'will':5,
    'jack':10,
    'diane':6,
    'peter':51,
    'mary':8
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

二、遍历字典

2.1 遍历所有键值对

使用for循环和items方法遍历所有键值对。

for key, value in dictionary.items( )

• 在for循环中声明两个变量key、value来代表键和值，可以使用任意变量名（如k、v等）。
• items方法返回一个键值对列表，返回的值赋给两个变量。

user_0 = {
    'username' : 'jack',
    'age' : 20,
    'city' : 'los angeles'
}
for key,value in user_0.items():
    print(key,value)
1
2
3
4
5
6
7

实例

打印每个人最喜欢的语言是什么，此处使用的2个变量名即与变量对应，分别为name和language.

favorite_languages = {
 'jen': 'python',
 'sarah': 'c',
 'edward': 'ruby',
 'phil': 'python',
 }
for name,lauguage in favorite_languages.items():
    print(f"{name.title()}'s favorate language is {lauguage.title()}.")
1
2
3
4
5
6
7
8

2.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

keys()方法不仅可用来遍历，还可以用来判断键是否包含在字典中。

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

if 'will' not in favorite_languages.keys():
  print('Will, please enter your name!')
1
2
3
4
5
6
7
8
9

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

使用sorted方法对键进行排序：sorted ( dictionary.keys( ) )

favorite_languages = {
  'jen': 'python',
  'sarah': 'c',
  'edward': 'ruby',
  'phil': 'python',
 }
for name in sorted(favorite_languages.keys()):
  print(f"{name.title()}, thank you!")

1
2
3
4
5
6
7
8
9

可以看到输出的名字都根据字母进行了排序。

2.4 遍历字典中的所有值

values( )方法返回一个值列表。

favorite_languages = {
  'jen': 'python',
  'sarah': 'c',
  'edward': 'ruby',
  'phil': 'python',
  'will' : 'python'
 }
for lauguage in sorted(favorite_languages.values()):
  print(lauguage)
1
2
3
4
5
6
7
8
9

可以看到该方法输出的值中有重复项Python，想要去掉重复项则可使用set方法去重。

如何对输出值进行去重

set( )：集合，集合中的每个元素都是唯一的。

favorite_languages = {
  'jen': 'python',
  'sarah': 'c',
  'edward': 'ruby',
  'phil': 'python',
  'will' : 'python'
 }
for lauguage in set(favorite_languages.values()):
  print(lauguage)
1
2
3
4
5
6
7
8
9

可以看到去掉了Python重复项。

集合

集合和字典一样都使用花括号进行定义。当花括号内没有键值对时，定义的很可能就是集合。

lauguages = {'python','python','c'}
print(lauguages)
1
2

可以看到定义的集合中有重复元素，而集合输出会自动去重。

2.5 练习题

代码

print('6-5')
rivers_countrys = {
  'nile':'egypt',
  'changjiang':'china',
  'amazon':'brazil'
}
for river,country in rivers_countrys.items():
  print(f"The {river.title()} runs through {country.title()}.")

print('6-6')
favorite_languages = {
  'jen': 'python',
  'sarah': 'c',
  'edward': 'ruby',
  'phil': 'java',
  'will' : 'python'
 }
names = ['will','jen','peter','ken']
for name in names:
  if name in favorite_languages.keys():
    print(f"Dear {name.title()}, thank you!")
  else:
    print(f'Dear {name.title()}, please joy our party.')
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

输出

三、字典和列表的嵌套使用

3.1 在列表中存储字典

加入我们需要一个多人名单，每个人都需要包含其姓名、年龄、性别的信息，那么如何统筹管理这些多人信息呢？

答案是创建一个users列表，其中每个user都是一个字典，包含该user的各种信息。

将字典手动输入列表

user_1 = {'name':'will','age':40,'gender':'male'}
user_2 = {'name':'diane','age':37,'gender':'female'}
user_3 = {'name':'cary','age':25,'gender':'male'}

users = [user_1,user_2,user_3]

for user in users:
  print(user)
1
2
3
4
5
6
7
8

自动生成多人的字典并添加进列表

若需要生成更多人的信息，则可以先创建一个users空列表，然后使用range方法生成需要的user数目。

users = []
for number in range(30):
  new_user = {'name':'will','age':40,'gender':'male'}
  users.append(new_user)
  #显示前5个
for user in users[:5]:
  print(user)
1
2
3
4
5
6
7

使用range（30）自动生成30个user字典，然后依次使用append方法添加进users列表中。

下图显示输出前users列表中的前五个user字典。

3.2 在字典中存储列表

假如想要建立人们所掌握的编程语言的字典，每个人可能掌握多种编程语言，所以就需要一个键对应多个值，此时可以在字典中嵌套列表。

people_lauguages = {
  'will' : ['python','c'],
  'peter' : ['c++','java'],
  'ken' : ['ruby','c++','go']
}
for people,lauguages in people_lauguages.items():
  print(f"{people.title()} can master:",end=" ")
  for lauguage in lauguages:
    print(lauguage.title(),end=" ")
  else:
    print("\n")
1
2
3
4
5
6
7
8
9
10
11

输出字典中各个列表的长度

使用values方法来获取字典中的列表，然后使用len方法统计列表长度。

people_lauguages = {
  'will' : ['python','c'],
  'peter' : ['c++','java'],
  'diane' : ['python'],
  'ken' : ['ruby','c++','go'],
  'cary' : ['c']
}

for lauguages in people_lauguages.values():
  print(len(lauguages))
1
2
3
4
5
6
7
8
9
10

练习

假如需要进一步对人们掌握的语言个数进行判断，若只能掌握一种语言，则输出“你需要继续加油学习”语句。

people_lauguages = {
  'will' : ['python','c'],
  'peter' : ['c++','java'],
  'diane' : ['python'],
  'ken' : ['ruby','c++','go'],
  'cary' : ['c']
}
for people,lauguages in people_lauguages.items():
  if len(lauguages) == 1:
    print(f"{people.title()}, you need to learn more lauguages!",end=" ")
  elif len(lauguages) >=2:
    print(f"{people.title()}, you already master",end=" ")
    for lauguage in lauguages:
      print(lauguage,end=" ")
  else:
    print("error!")
  print("\n")
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

3.3 在字典中存储字典

字典中嵌套了相同结构的字典。

users = {
  'mary' : {
    'age':21,
    'gender':'female'
  },
  'will' : {
    'age':40,
    'gender':'male'
  }
}

for name, name_info in users.items():
  print(f"{name}")
  for age,gender in name_info.items():
    print(age,gender)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

四、练习题

6-7

#6-7
people_1 = {
    'first_name':'winnie',
    'last_name':'ma',
    'age':22,
    'city':'zibo'
}
people_2 = {
    'first_name':'will',
    'last_name':'zhao',
    'age':40,
    'city':'qingdao'
}
people_3 = {
    'first_name':'mary',
    'last_name':'wang',
    'age':20,
    'city':'jinan'
}
people = [people_3,people_2,people_1]

for p in people:
  for k,v in p.items():
      print(k,v)

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

6-8

6-9

#6-9
favorate_place = {
    'peter' : ['america'],
    'cary' : ['china','brazil','italy'],
    'diane' : ['india','france']
}
for name,places in favorate_place.items():
    if len(places) == 1:
        print(f"{name.title()}'s avorate place is {places[0].title()}!")
    elif len(places)>=2:
        print(f"{name.title()}'s favorate places are",end=" ")
        i=1
        for place in places:
            if i<=len(places)-1:
                print(f"{place.title()}",end=" and ")
                i+=1
            else:
                print(f"{place.title()}",end="!\n")
    else:
        print("error")
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

6-11

#6-11
cities = {
    'zibo':{
        'country':'china',
        'num_people':9000,
        'food':'barbecue'
    },
    'jinan':{
        'country':'china',
        'num_people':500,
        'food':'meet'
    },
    'qingdao':{
        'country':'china',
        'num_people':6300,
        'food':'sea food'
    }
}
for city,city_info in cities.items():
    print(f"{city.title()}")
    for k,v in city_info.items():
        print(k,v)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22