容器型数据类型——字典

容器型数据类型——字典

​ Python程序中的字典跟现实生活中的字典很像，它以键值对（键和值的组合）的方式把数据组织到一起，我们可以通过键找到与之对应的值并进行操作。就像《新华字典》中，每个字（键）都有与它对应的解释（值）一样，每个字和它的解释合在一起就是字典中的一个条目，而字典中通常包含了很多个这样的条目。

注意：英文冒号前的是键，冒号后的是值，键不能随意改变，但键里的值可以改变。

字典的创建

字面量语法

student1 = {
    'id':1001,
    'name':'gongfan',
    'sex':'男',
    'birthday':'1998-06'
}

构造器语法

student2 = dict(id=1002,name='王大锤',sex='男')

生成式语法

dict1 = {i: i ** 2 for i in range(1,10)}
print(dict1)

字典的遍历

遍历键值对

student1 = {
    'id':1001,
    'name':'gongfan',
    'sex':'男',
    'birthday':'1998-06'
}
for x in student1:#循环遍历的是键  x表示键  通过键索引
    print(x,student1[x])#键值都取出来

for key,value in student1.items():
    print(key, value)
'''
id 1001
name gongfan
sex 男
birthday 1998-06
'''

遍历字典中的键

• keys() 字典的键

for key in student1.keys():
    print(student1[key])#把值取出来
'''
1001
gongfan
男
1998-06
'''

遍历的字典中的值

• values() 字典的值

for value in student1.values():
    print(value)#    值的遍历
'''
1001
gongfan
男
1998-06
'''

字典的运算

字典键值对的添加

• 方法一

student = dict(id=1002,name='王大锤',sex='男',birthday='1990-1')
#字典的索引运算放在赋值运算符的左边
#如果索引对应的键是存在的，就更新(替换)它的值 
print(student)
student['name'] = '王美丽'
student['sex'] = '女'
#如果字典中没有对应的索引，就增加一组新的“键值对”
student['address'] = '贵州贵阳'
print(student)
'''
{'id': 1002, 'name': '王大锤', 'sex': '男', 'birthday': '1990-1'}
{'id': 1002, 'name': '王美丽', 'sex': '女', 'birthday': '1990-1', 'address': '贵州贵阳'}
'''

• 方法二

• setdefault()如果键在字典中 则返回原来键对应的值 没有就添加指定键 和指定的值

# 如果键在字典中 则返回原来键对应的值  没有就添加指定键 和指定的值
dict1 = {'A':100,'B':200,'C':300}
print(dict1.setdefault('C','李四'))
dict1.setdefault('K','张三')
print(dict1)
'''
300
{'A': 100, 'B': 200, 'C': 300, 'K': '张三'}
'''

成员运算

student = dict(id=1002,name='王大锤',sex='男',birthday='1990-1')
print('name' in student)
print('age' in student)
print('address' in student)
'''
True
False
True
'''

使用get函数通过key获取value

#使用get函数通过key获取value时，如果key不存在，不会发生keyError错误
#而是得到一个None(空值)  相较于下标索引此方法更好
student = dict(id=1002,name='王大锤',sex='男',birthday='1990-1')
print(student.get('age'))
print(student.get('age',20))#拿不到就返回一个指定值替代 如20
print(student.get('name','无名氏'))#拿得到则返回值 拿不到返回无名氏
'''
None
20
王大锤
'''

删除键值对

#del student['name']
print(student.pop('name'))#删除键对应的值 并返回值
print(student.get('name','无名氏'))
'''
无名氏
'''

下标（索引）运算

if 'birthday' in student:
    print(student['birthday'])
'''
1990-1
'''

字典相关操作

更新操作

字典不能直接相加来拼接

• update()

dict1 = {'A':100,'B':200,'C':300}
dict2 = {'D':400,'E':500,'A':600}
#不能字典相加
#更新操作  重复的键会更新替代  不重复的合并成新字典
dict1.update(dict2)
print(dict1)
'''
{'A': 600, 'B': 200, 'C': 300, 'D': 400, 'E': 500}
'''

删除

删除—>键必须存在，如果不存在会产生错误 KeyError

del dict1['k']
dict1.pop('A')
print(dict1)

清空字典

dict1.clear()

小练习

输入一段英文字符计算每个字母出现的次数并整理成字典。

import string
dict1 = {i: 0 for i in string.ascii_lowercase}
sces = input('请输入：').lower()
for sce in sces:
    if sce in dict1:
        sces.count(sce)
        dict1[sce] = sces.count(sce)
for key, value in dict1.items():
    print(f'{key}:{value}次')
print(dict1)

1. 找出股票价格大于100元的股票并创建一个新的字典

2. 找出价格最高和最低的股票对应的股票代码

3. 按照股票价格从高到低给股票代码排号

   不完全代码

   stocks = {
       'AAPL': 191.88,
       'GOOG': 1186.96,
       'IBM': 149.24,
       'ORCL': 48.44,
       'ACN': 166.89,
       'FB': 208.09,
       'SYMC': 21.29
   }
   #1
   new_dict = {}
   for key,value in stocks.items():
       if value > 100:
           print(stocks[key])
           new_dict[key] = value
   print(new_dict)
   #同上更专业
   new_dict = {key:value for key,value in stocks.items() if value > 100}
   print(new_dict)
   
   #2
   #zip()压在一起
   #键值反转成二元组可以再前加dict()变成字典 先求最大值  再用[1],取出键
   print(max(zip(stocks.values(),stocks.keys()))[1])
   #
   print(max(stocks, key=stocks.get))
   
   #sorted()排序升序
   sorted(stocks, key=stocks.get,reverse=True)
   print(sorted(stocks, key=stocks.get,reverse=True)[0])
   

#参考代码
stocks = {
    'AAPL': 191.88,
    'GOOG': 1186.96,
    'IBM': 149.24,
    'ORCL': 48.44,
    'ACN': 166.89,
    'FB': 208.09,
    'SYMC': 21.29
}

# new_stocks = {}
# for key, value in stocks.items():
#     if value > 100:
#         new_stocks[key] = value
new_stocks = {key: value for key, value in stocks.items() if value > 100}
print(new_stocks)
# max、min、sorted函数都有一个名为key的参数，该参数可以指定比较元素大小的规则
# 例如下面的key=len可以通过对元素指定len函数获得一个长度值来作为比大小的规则
# words = ['apple', 'zoo', 'watermelon', 'zealot', 'internationalization', 'pear']
# # lens = [5, 3, 10, 6, 20, 4]
# print(max(words, key=len))
# print(min(words, key=len))
# words.sort(key=len)
# print(words)
# keys = ['AAPL', 'GOOG', 'IBM', 'ORCL', 'ACN', 'FB', 'SYMC']
# values = [stocks.get('AAPL'), stocks.get('GOOG'), ...]
# values = [191.88, 1186.96, 149.24, ...]
print(max(stocks, key=stocks.get))
print(min(stocks, key=stocks.get))
print(sorted(stocks, key=stocks.get, reverse=True))
# _, max_code = max(zip(stocks.values(), stocks.keys()))
# print(max_code)
# print(min(zip(stocks.values(), stocks.keys()))[1])
# dict1 = {'A': 1, 'B': 2, 'C': 3, 'D': 4}
# dict2 = dict(zip(dict1.values(), dict1.keys()))
# print(dict1)
# print(dict2)

总结

​ Python程序中的字典跟现实生活中字典非常像，允许我们以键值对的形式保存数据，再通过键索引对应的值。这是一种非常有利于数据检索的数据类型，底层原理我们在后续的课程中再研究。再次提醒大家注意，字典中的键必须是不可变类型，字典中的值可以是任意类型。