Python学习日志08 - 字典

Posted 2021-08-29 苟用

Python学习日志

RBHGO的主页欢迎关注

温馨提示：创作不易，如有转载，注明出处，感谢配合~

目录

文章目录

• • Python学习日志
  • • 目录
    • Python学习日志08课 - 字典
    • • 前言
      • 进入正题
      • 创建字典
      • 字典的运算
      • 字典的方法
      • 字典的应用
      • 总结

Python学习日志08课 - 字典

前言

和大家分享几个比较好用的函数，可以提前了解，使用。后面我分享函数的时候应该会再次提到。下面这条码同时用到了这三个函数，map函数让我们一行就完成之前3行代码才能完成的任务，而try和except保证代码成功运行之前不会崩溃。

# map函数:映射作用，用于单行多条输入，将分裂的字符串映射为整型、浮点型······
# try函数:把可能出现状况的代码保护起来执行
# except函数:如果出现了状况，通过except进行错误捕获，然后执行相应的处理代码

while True:
    try:
        a, b, c = map(int, input('请输入三条边的长度: ').split())
        print(a, type(a))
        print(b, type(b))
        print(c, type(c))
        break
    except ValueError:
        print('输入错误，请重新输入!! ! ')

进入正题

至今为止，我们已经给大家分享了Python中的三种容器型数据类型，但是这些数据类型还不足以帮助我们解决所有的问题。例如，我们要保存一个人的信息，包括姓名、年龄、体重、家庭住址、个人爱好、本人手机号等信息，你会发现我们之前学过的列表、元组和集合都不是最理想的选择。学习日志08课主要和大家分享容器型数据类型的第四种—>字典。字典dict(dictionary) —>元素由键和值两部分构成，冒号前面的称为键，冒号后面的称为值，合在一起叫键值对。

创建字典

在Python中创建字典可以使用{}字面量语法，这点跟上节课分享的集合是一样的。但是字典的{}中的元素是以键值对的形式存在的，每个元素由:分隔的两个值构成，:前面是键，:后面是值。

# 在学习日志07课提到，空字典的创建
dict07 = {}

# 用字典保存一个人的信息，字典里可以有列表、字典
student1 = {
    'id': '3016',
    'name': 'RBHGO',
    'sex': 'male',
    'weight': '73',
    'hight': '175',
    'address': '慕尼黑',
    'favorites': ['足球', '主机游戏', '音乐'],
    'contacts': {
        'QQ': '4*******9',
        'TEL': '191*****466'
    }
}
print(student1['name'])                        # 运行结果：RBHGO
print(student1['favorites'])                   # 运行结果：['足球', '主机游戏', '音乐']
print(student1['contacts']['TEL'])             # 运行结果：191*****466
for fav in student1['favorites']:
    print(fav，end = ' ')                     # 运行结果：足球 主机游戏 音乐 

通过上面的代码，相信大家已经看出来了，用字典来保存一个人的信息远远优于使用列表或元组，因为我们可以用:前面的键来表示条目的含义，而:后面就是这个条目所对应的值。接下来我细细介绍创建字典的方法。

温馨提示：键值对中的建必须是不可变的数据类型

# 创建字典
# 字面量语法
student1 = {
    'id': 1001,
    'name': '蛇皮怪',
    'sex': True,
    'birthday': '1616-2-29'
}

# 构造器函数
student2 = dict(id=1002, name='猪大肠', sex=True, birthday='1989-9-13')
print(student2)

# 可以通过Python内置函数zip压缩两个序列并创建字典
items1 = dict(zip('ABCDE', '12345'))
print(items1)    # 运行结果:{'A': '1', 'B': '2', 'C': '3', 'D': '4', 'E': '5'}
items2 = dict(zip('ABCDE', range(1, 10)))
print(items2)    # 运行结果:{'A': 1, 'B': 2, 'C': 3, 'D': 4, 'E': 5}
items3 = {'A': 1, 'B': 2, 'C': 3, 'D': 4}
items4 = dict(zip(dict3.values(), dict3.keys()))
print(dict4)     # 运行结果:{1: 'A', 2: 'B', 3: 'C', 4: 'D'}

# 生成式(推导式)语法(我把多种容器型数据的生成式写法写到一起，方便认清)
# 列表
list1 = [i for i in range(1, 10)]
print(list1)
# 集合
set1 = {i for i in range(1, 10)}
print(set1)
# 字典
dict1 = {i: i ** 2 for i in range(1, 10)}
print(dict1)
# 生成器(generator) ---> 元组没有生成式语法，下面是一个生成器数据类型
x = (i for i in range(1, 10))
print(type(x))

想知道字典中一共有多少组键值对，仍然是使用len函数；如果想对字典进行遍历，可以用for循环，但是需要注意，单纯的for循环只是对字典的键进行了遍历。

# 构造器函数
print(len(student2))              # 运行结果：4
print(len(student1))              # 运行结果：4

# 遍历
# 遍历字典中的键
for key in student1:
    # 可以输出键值对
    # print(key, student1[key])
    print(key)                    # 运行结果：id name sex birthday


# 遍历字典中的值
for value in student1.values():
    print(value)                  # 运行结果：1001 蛇皮怪 True 1616-2-29


# 遍历字典中的键值对
for key, value in student1.items():
    print(key, value)             # id 1001  name 蛇皮怪  sex True  birthday 1616-2-29

字典的运算

对于字典类型来说，成员运算和索引运算肯定是最为重要的，前者可以判定指定的键在不在字典中，后者可以通过键获取对应的值或者向字典中加入新的键值对。值得注意的是，字典的索引不同于列表的索引，列表中的元素因为有属于自己有序号，所以列表的索引是一个整数；字典中因为保存的是键值对，所以字典的索引是键值对中的键，通过索引操作可以修改原来的值或者向字典中存入新的键值对。

# 成员运算
student2 = dict(id=1002, name='猪大肠', sex=True, birthday='1988-3-17')
print('name' in student2)
print('age' in student2)
print('favorite' in student2)
print('birthday' not in student2)

# 字典的索引运算放在赋值运算符的左边
# 如果索引对应的键是存在的，就更新它的值
student2['name'] = '金轮'
student2['sex'] = 'hermaphrodite'

# 如果字典中没有对应的索引，就增加一组新的"键值对"
student2['address'] = '芜湖'
student2['favorite'] = '肉蛋葱鸡'
print(student2)

# 如果要使用下标（索引）运算，那么必须要保证键一定存在
if 'birthday' in student2:
    print(student2['birthday'])
print(student2)

温馨提示：再次特别提醒大家注意的是，字典中的键必须是不可变类型，例如整数（int）、浮点数（float）、字符串（str）、元组（tuple）等类型的值；显然，列表（list）和集合（set）是不能作为字典中的键的，当然字典类型本身也不能再作为字典中的键，因为字典也是可变类型，但是字典可以作为字典中的值。

字典的方法

字典类型的方法基本上都跟字典的键值对操作相关，可以通过下面的例子来了解这些方法的使用。

student2 = dict(id=1002, name='猪大肠', favorite='散弹枪', sex=True, birthday='1988-3-17')

# 使用get函数通过key获取value时，如果key不存在，不会发生KeyError错误
# 而是得到—个None(空值)
print(student2.get('age'))                  # 运行结果:None
print(student2.get('age', 20))              # 运行结果:20
print(student2.get('name', '无名氏'))        # 运行结果:猪大肠


# 删除 ---> 键必须存在，如果不存在会产生KeyError异常
# 删除键值对
del student2['name']
# pop删除键值对，会返回值
print(student2.pop('favorite'))             # 运行结果:散弹枪
# popitem方法返回并删除字典中的最后一对键和值,并返回对应的二元组。
# 如果字典已经为空，却调用了此方法，就报出 KeyError 异常。
print(student2.popitem())                   # 运行结果:('birthday', '1988-3-17')

# setdefault可以更新字典中的键对应的值或向字典中存入新的键值对
# setdefault方法的第一个参数是键，第二个参数是键对应的值
# 如果这个键在字典中存在，更新这个键之后会返回原来与这个键对应的值
# 如果这个键在字典中不存在，方法将返回第二个参数的值，默认为None
result1 = student2.setdefault(id, 1018)
result2 = student2.setdefault('age', 82)
print(result1)                              # 运行结果:1018
print(result2)                              # 运行结果:82
print(student2)                             # 运行结果:{'id': 1002, 'name': '猪大肠', 'favorite': '散弹枪', 'sex': True, 'birthday': '1988-3-17', <built-in function id>: 1018, 'age': 82}


# 使用update更新字典元素，相同的键会用新值覆盖掉旧值，不同的键会添加到字典中
dict1 = {'A': 100, 'B': 200, 'C': 300}
dict2 = {'D': 400, 'E': 500, 'A': 600}
# update方法进行更新和合并
dict1.update(dict2)
print(dict1)                               # 运行结果:{'A': 600, 'B': 200, 'C': 300, 'D': 400, 'E': 500}

字典的应用

第一题题目如下

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).找出股票价格大于100元的股票并创建—个新的字典
# 字面量语法
temps = {}
for key, value in stocks.items():
    if value > 100:
        temps[key] = value
print(temps)
# 生成式（推导式）语法
new_stocks = {key: value for key, value in stocks.items() if value > 100}
print(new_stocks)


# (2).max函数和min函数找到价格最高和最低的股票对应的股票代码
# 这里也分享两种写法
# print(max(zip(stocks.values(), stocks.keys()))[1])
# print(min(zip(stocks.values(), stocks.keys()))[1])
print(max(stocks, key=stocks.get))
print(min(stocks, key=stocks.get))


# (3).用sorted函数，按照股票价格从高到低给股票代码排序
# 注意key控制排序的方式，如果以值的长短排序就可以写 key=len
print(sorted(stocks, key=stocks.get, reverse=True))
print(sorted(stocks, key=stocks.get))

例子1:输入一段话，统计每个英文单词出现的次数。

# 字符串replace去掉字符串句子里的','和'.'然后再用字符串split方法字符串以空格撕裂成单词
sentence = map(str, input('请输入一段英文句子: ').replace('.', '').replace(',', '').split(' '))
counter = {}
for word in sentence:
    # 遍历后，将对应的值加上一并且赋值给对应的键
    counter[word] = counter.get(word, 0) + 1
print(counter)
# 遍历字典中的键值对，将每一个字母和它出现的次数输出
for key, value in counter.items():
    print(f'单词{key}出现了{value}次.')

总结

Python程序中的字典跟现实生活中字典非常像，允许我们以键值对的形式保存数据，再通过键索引对应的值。这是一种非常有利于数据检索的数据类型，重要的话说三遍:字典中的键必须是不可变类型，字典中的值可以是任意类型。

感谢学习陪伴，您的点赞，评论就是我更新的动力