10.12 总结
1. 回顾：
1.1 集合中的元素是不可变才行。
python
# 集合的一些问题：里面只能放不能变的，列表报错是它可变
s = {10, 20, 30} # 整型数据
print(s)
s = {1.1,2.2,3.3} # 浮点数
print(s)
s = {True,False,True}
print(s)
s = {'abc','def'} # # 字符串
print(s)
s = {[1,2,3],[4,5,6]} # 列表
print(s) # TypeError: unhashable type: 'list'
num = [**,12,344,e]
pprint.pprint(num) # 能让输出的杂乱的数据变整洁1.2 整洁：
num = [**,12,344,e]
pprint.pprint(num) # 能让输出的杂乱的数据变整洁2. 作业：
2.1 pprint：
- 可进行整理
python
# 1.在一个字典中保存了股票的代码和价格，找出股价大于100元的股票并创建一个新的字典。
stocks = {
'AAPL': 191.88,
'GOOG': 1186.96,
'IBM': 149.24,
'ORCL': 48.44,
'ACN': 166.89,
'FB': 208.09,
'SYMC': 21.29
}
print({k: v for k, v in stocks.items() if v > 100})
# {'AAPL': 191.88, 'GOOG': 1186.96, 'IBM': 149.24, 'ACN': 166.89, 'FB': 208.09}
# 2.# 一个书店中，已知书籍信息如下
book_list = [
{'编号': 1, '名称': '西游记', '作者': '吴承恩', '价格': 58},
{'编号': 2, '名称': '禹鼎记', '作者': '吴承恩', '价格': 56.5},
{'编号': 3, '名称': '三遂平妖传', '作者': '罗贯中', '价格': 105.5},
{'编号': 4, '名称': '三国演义全册', '作者': '罗贯中', '价格': 77.5},
{'编号': 5, '名称': '红楼梦', '作者': '曹雪芹', '价格': 66},
{'编号': 6, '名称': '水浒传', '作者': '施耐庵', '价格': 55},
{'编号': 7, '名称': '赵太祖龙虎风云会', '作者': '罗贯中', '价格': 46}
]
# 完成如下操作：
# 1.找到作者为`罗贯中`的书籍名称
print([book['名称'] for book in book_list if book['作者'] == '罗贯中'])
# 2.找到价格在50到100之间的书籍信息
print([book for book in book_list if book.get('价格') in range(50, 101)])
# 3.找到书籍名称长度超过4的书籍信息
print([book for book in book_list if len(book.get('名称')) > 4])
# 4.找到数据中作者以曹或者吴开头的书籍名称
print([book['名称'] for book in book_list if book['作者'][0] in '曹吴'])
# 5.使用任意排序算法根据价格进行降序排序
# 冒泡
for i in range(1, len(book_list)):
for j in range(0, len(book_list) - i):
if book_list[j]['价格'] < book_list[j + 1]['价格']:
book_list[j], book_list[j + 1] = book_list[j + 1], book_list[j]
# print(book_list)
import pprint
pprint.pprint(book_list)
[{'价格': 105.5, '作者': '罗贯中', '名称': '三遂平妖传', '编号': 3},
{'价格': 77.5, '作者': '罗贯中', '名称': '三国演义全册', '编号': 4},
{'价格': 66, '作者': '曹雪芹', '名称': '红楼梦', '编号': 5},
{'价格': 58, '作者': '吴承恩', '名称': '西游记', '编号': 1},
{'价格': 56.5, '作者': '吴承恩', '名称': '禹鼎记', '编号': 2},
{'价格': 55, '作者': '施耐庵', '名称': '水浒传', '编号': 6},
{'价格': 46, '作者': '罗贯中', '名称': '赵太祖龙虎风云会', '编号': 7}]2.2 set()去重:
python
l = [1, 2, 3, 4, 1, 1, 2, 3, 1, 12, 15, 1, 1]
# 将l中的元素去重，只保留一个
print(list(set(l)))2.3 集合：
python
lst1 = {1, 2, 3, 5, 6}
lst2 = {2, 5, 7, 9}
# 哪些整数既在lst1中，也在lst2中
print(lst1 & lst2)
# 哪些整数在lst1中，不在lst2中
print(lst1 - lst2)
# 两个一共有哪些整数
print(lst1 | lst2)
# 已知学习语文的人有小红，小明，小刚，乐乐，焕焕；学习数学的人有小刚，乐乐，倩倩，茜茜；学习英语的人有乐乐，倩倩，露露，莎莎。
chinese = {'小红', '小明', '小刚', '乐乐', '焕焕'}
math = {'小刚', '乐乐', '倩倩', '茜茜'}
english = {'乐乐', '倩倩', '露露', '莎莎'}
# 1.学习语文和数学 但是没有学习英语的有几个，分别是谁
print(math & chinese - english)
# 2. 学了两门课程的学生有几个 分别是谁
print(math & chinese - english)
print(math & english - chinese)
print(english & chinese - math)
print((math & chinese - english) | (math & english - chinese) | (english & chinese - math))
# 3. 只学一门课程的学生有几个，分别是谁
print(math - chinese - english)
print(chinese - math - english)
print(english - math - chinese)
print((math - chinese - english) | (chinese - math - english) | (english - math - chinese))2.4 深浅拷贝：
- 浅拷贝
python
# 测试 列表.copy() 实现的是深拷贝还是浅拷贝 浅拷贝
# import copy copy.deepcopy() copy.copy()
# 列表.copy() 维数 >=2 内层地址是否是新的
l = [[1, 2, 3], [4, 5, 6]]
l1 = l.copy()
l[-1].append(100)
print(l) # [[1, 2, 3], [4, 5, 6, 100]]
print(l1) # [[1, 2, 3], [4, 5, 6, 100]]- 深拷贝
python
import copy
a = [[1, 2], ['a', 'b']]
b = a # 地址的传递 不管内外变化 互相影响
c = a.copy() # 浅拷贝 外层是新的 内层互相影响
d = copy.deepcopy(b) # 深拷贝 不管内外 都不影响
# (1) a.append(10), 打印b和c, d的结果分别是什么？
# a.append(10)
# print(b) # [[1, 2], ['a', 'b'],10] 作为元素加进来的
# print(c) # [[1, 2], ['a', 'b']]
# print(d) # [[1, 2], ['a', 'b']]
# (2) a[-1].append(10), 打印b和c, d的结果分别是什么？
a[-1].append(10)
print(b) # [[1, 2], ['a', 'b',10]]
print(c) # [[1, 2], ['a', 'b',10]]
print(d) # [[1, 2], ['a', 'b']]3.高阶函数的演化
python
# 演化过程 着重理解 函数的作用位置
# 高阶函数 把函数A作为另一个函数B的参数进行传递
# 获取最值的思路
# 假设第一个值最大的 遍历后面的每一个数据 如果遍历的数据比假设的最大值还大 修改最大值位当前遍历到的数据
def get_max1(l):
max_value = l[0]
for i in l[1:]:
if i > max_value:
max_value = i
return max_value
print(get_max1([10, 20, 30, 40, 25, 17])) # 40
# 如果获取 个位数最大
def get_max2(l):
max_value = l[0]
for i in l[1:]:
# 比较 不是直接比较数值 而是 比较的是个位数
if i % 10 > max_value % 10:
max_value = i
return max_value
print(get_max2([10, 20, 30, 40, 25, 17]))
# 获取 列表中长度最大的
def get_max3(l):
max_value = l[0]
for i in l[1:]:
if len(i) > len(max_value):
max_value = i
return max_value
print(get_max3(['abc', 'aaaaaaa', 'b', 'd']))
# 求绝对值最大 求列表中字符串的最后一个字符最大
# 把判断的条件 封装成函数的参数 求xxx最大
# 把上述代码整合 一个函数
def get_max(l, key=None): # key 指定 求xxx最大的 默认参数 默认值位None 如果这个参数不指定 求默认的最大
max_value = l[0]
for i in l[1:]:
if key == None: # 设定两个变量 分别表示 要比较的内容
compare_i, compare_max_value = i, max_value
else:
compare_i, compare_max_value = key(i), key(max_value)
if compare_i > compare_max_value:
max_value = i
return max_value
# key 的作用位置 作用于序列中的每一个元素 如果使用自定义的函数 参数 就表示序列中的每一个元素
print(get_max(['abc', 'aaaaaaa', 'b', 'd']))
print(get_max(['abc', 'aaaaaaa', 'b', 'd'], key=len))
print(get_max([10, 20, 30, 40, 25, 17]))
print(get_max([10, 20, 30, -40, 25, 17], key=abs))
print(get_max([10, 20, 30, 40, 25, 17], key=lambda x: x % 10)) # key 求一个数的个位数
print(get_max([10, 20, 130, 40, 25, 17], key=lambda x: int(str(x)[0]))) # key
print(get_max(['azzza', 'ad', 'zzzzza'], key=lambda x: x[-1]))4.系统内置的高阶函数
4.1 max & min
python
# max(*args,key=None)
print(max([1, 2, 3, 4, 10, 5])) # 10
print(max([1, 2, -5, 3, 4], key=abs)) # -5
print(max([19, 28, 37, 46], key=lambda x: x % 10)) # 19
# min(*args,key=None)
print(min('azzza', 'ad', 'zzzzza')) # ad
print(min('azzza', 'ad', 'zzzzza', key=lambda x: x[-1])) # azzza4.2 列表.sort()函数
python
# 列表.sort() 默认是升序排序 如果想降序 列表.sort(reverse = True)
# l.sort(key=None,reverse=False) key 指定排序方式的 reverse 指定 升序还是降序
# 列表.sort() 仅能对列表排序 并且 影响的是原列表
l = [10, 20, -30, 50]
l.sort()
print(l) # [-30, 10, 20, 50]
l.sort(key=abs)
print(l) # [10, 20, -30, 50]
l = ['azzza', 'adaaaaaaaaaa', 'zzzzza']
l.sort()
print(l) # ['adaaaaaaaaaa', 'azzza', 'zzzzza']
# 按照长度降序排序
l.sort(key=len, reverse=True)
print(l) # TypeError: object of type 'int' has no len() 元组不行，只能列表4.3 sorted() 函数
- 特点：返回列表
python
# sorted() 排序操作 对任意序列排序 返回的结果是列表 产生的是一个新列表
# sorted(iterable,key,reverse) iterable 指定排序序列的 key 指定排序规则 reverse 升序降序的
print(sorted(['azzza', 'adaaaaaaaaaa', 'zzzzza'])) # 不指定，那按照默认内容排
# ['adaaaaaaaaaa', 'azzza', 'zzzzza']
print(sorted(['azzza', 'adaaaaaaaaaa', 'zzzzza'], key=len))
# ['azzza', 'zzzzza', 'adaaaaaaaaaa']
print(sorted(['azzza', 'adaaaaaaaaaa', 'zzzzza'], key=len, reverse=True))
# ['adaaaaaaaaaa', 'zzzzza', 'azzza']
# 对元组也能排，返回的是列表
print(sorted((19, 28, -35, 47))) # [-35, 19, 28, 47]
print(sorted((19, 28, -35, 47), key=lambda x: x % 10)) # [-35, 47, 28, 19]
print(sorted((19, 28, -35, 47), key=abs)) # [19, 28, -35, 47]
print(sorted((19, 28, -35, 47), key=abs, reverse=True)) # [47, -35, 28, 19]
# 对字符串也能排
print(sorted('bcda')) # ['a', 'b', 'c', 'd']
# 对集合也能排
print(sorted({10, 20, 16})) # [10, 16, 20]
print(sorted({19, 28, 37}, key=lambda x: x % 10)) # [37, 28, 19]4.4 映射 | 筛选 | 累计
python
# 列表推导式
# 两个应用场景 1. 条件 筛选过程 2. 转化 映射过程
# 映射 map(函数，序列)----------------------------------------------------
l = [1, 2, 3, 4]
# 将l中的每一个元素 转化为10倍 放列表中也可以
print(tuple(map(lambda x: x * 10, l))) # (10, 20, 30, 40)
# 将l中的每一个元素都转化为字符串类型
print(list(map(lambda x: str(x), l))) # ['1', '2', '3', '4']
print(list(map(str, l))) # ['1', '2', '3', '4']
# 筛选 满足条件的内容 filter(函数，序列)---------------------------------------------
# range(10) 所有的偶数
# range(10) --- 0 1 2 3 4 5 5 6 7 8
# lambda x: x % 2 -- 0 1 0 1 0 1 0 1 0 1 --非零即为 True 容器 非空既为True
print(list(filter(lambda x: x % 2, range(10)))) # [1, 3, 5, 7, 9]
print(list(filter(lambda x: x % 2 == 0, range(10)))) # [0, 2, 4, 6, 8]
l = ['abc', 'dec', 'bdf', 'def']
# 筛选 列表中元素的最后一个字符为c的
print(list(filter(lambda x: x[-1] == 'c', l))) # ['abc', 'dec']
# 累计 累加和 累乘 字符串的拼接-------------------------------------------------------
from functools import reduce
# reduce(函数，序列)
# 累加求和 1-100的和 range(1,101)
print(reduce(lambda x, y: x + y, range(1, 101))) # 5050
# 1-10的乘积 range(1,11) 阶乘
print(reduce(lambda x, y: x * y, range(1, 11))) # 3628800
# 字符串的拼接
l = ['a', 'b', 'c']
print(reduce(lambda x, y: x + '+' + y, l)) # a+b+c
l = [1, 2, 3]
print(reduce(lambda x, y: str(x) + '+' + str(y), l)) # 1+2+34.5 高阶函数练习：
python
l = [151, -38, 45, 99, 13, -120]
# 根据绝对值 降序排序
print(sorted(l, key=abs, reverse=True))
# 根据个位数 升序排序
print(sorted(l, key=lambda x: abs(x) % 10))
# 获取十位数最大的数字
print(max(l, key=lambda x: abs(x) // 10 % 10))
# 将l中的每一个数据映射为绝对值
print(list(map(abs, l)))
# 获取l中的每一个数的十位数字
print(list(map(lambda x: x // 10 % 10, l)))
# 筛选l中所有的偶数
print(list(filter(lambda x: x % 2 == 0, l)))
# 求l的累加和
print(reduce(lambda x, y: x + y, l))
# 获取l中各个位上的数字和最大的元素
def get_sum(x):
# 求绝对值
abs_x = abs(x)
# 设置一个变量记录和
res = 0
# 获取数字的各个位上的和
for i in str(abs_x):
res += int(i)
return res
print(max(l, key=get_sum))
students = [
{'学号': 1, '姓名': '乐乐', '年龄': 12, '性别': '男', '成绩': 71},
{'学号': 2, '姓名': '倩倩', '年龄': 11, '性别': '女', '成绩': 83},
{'学号': 3, '姓名': '苗苗', '年龄': 13, '性别': '女', '成绩': 98},
{'学号': 4, '姓名': '旭旭', '年龄': 12, '性别': '男', '成绩': 65},
{'学号': 5, '姓名': '花花', '年龄': 11, '性别': '男', '成绩': 66}
]
# 获取成绩最高的学生信息
print(max(students, key=lambda x: x.get('成绩')))
# 根据学生成绩对学生信息进行升序排序
print(sorted(students, key=lambda x: x['成绩']))5.装饰器：
python
# 本质是在简化代码
# 作用： 不修改原有代码的基础上 增加新的功能
# 核心： 虽然还是他，但其实不是他
import time
# time.sleep(5) # 休眠时间 时间单位是秒
def my_add(a,b):
time.sleep(0.2)
return a+b
def my_sub(a,b):
time.sleep(0.3)
return a-b
def sleep():
# 时间休眠
time.sleep(1)
# print(my_add(10, 20))
# print(my_sub(10, 20))
# sleep()
# --------------------------以上是原有代码-------------------------------------------
# 测量一下函数的执行时间
# 例如：跑步 体测
# 函数执行之前 测量时间
start_time= time.time() # 返回时间戳 时间戳 1970-1-1 当前执行到本行代码经历的秒数
print(start_time) # 1768730625.2414973
# 执行函数
print(my_add(10, 20)) # 30
# 函数执行结束之后 测量时间
# end_time = time.time()
# # 时间的差值 函数的执行时间
# print(end_time- start_time)
# 封装成函数
# 函数的作用 求某个函数的执行时间 未知数
# def get_time(fun,*args):
# start_time = time.time()
# res = fun(*args)
# end_time = time.time()
# print(end_time - start_time)
# return res
# print(get_time(my_add, 10, 20))
# print(get_time(my_sub, 10, 20))
# get_time(sleep)
# --------------------------需求： 在不修改原有代码的基础上 实现原有功能 并增加一个新功能 测量时间
# my_add -- 求和 + 测量时间
# my_sun -- 求差值 + 测量时间
# sleep -- 休眠 + 测量时间
# 1. 把求和功能先给第三个变量接受
# other = my_add # other 具有求和功能
# my_add = get_time # my_add 具有测量时间的功能
# print(my_add(other, 10, 20))
# other = my_sub
# my_sub = get_time
# print(my_sub(other, 10, 20))
# other = sleep
# sleep = get_time
# sleep(other)
# ---------------------整合-------------------------------------------
# 重复操作
# 不管传递什么功能 都要返回 get_time
# def trans(other):
# return get_time
# 现在遇到问题 如果 other = my_add
# 涉及到 在 get_time 函数中 使用到了 other这个变量 other变量 在 trans函数中
# 在一个函数中想使用另一个函数的变量 -- 函数嵌套
# ------修改
# 1. 函数嵌套 2. 外部函数的返回为内部函数的引用 3. 内部函数持有了外部函数的变量 闭包
# ---------------------------装饰函数----------------------------------
def trans(other):
def get_time(*args):
start_time = time.time()
res = other(*args)
end_time = time.time()
print(end_time - start_time)
return res
return get_time
# ----------------------------------------------------------
my_add = trans(my_add) # other = my_add my_add = get_time
print(my_add(10, 20)) # my_add 实际调用的是get_time
my_sub = trans(my_sub) # other = my_sub my_sub = get_time
print(my_sub(10, 20))
sleep = trans(sleep)
sleep()
# my_add = trans(my_add) my_sub = trans(my_sub) sleep = trans(sleep)
# 语法糖操作 @6. 装饰器最终结果：
python
import time
# 装饰函数
def trans(other):
def get_time(*args):
start_time = time.time()
res = other(*args)
end_time = time.time()
print(end_time - start_time)
return res
return get_time
@trans # my_add = trans(my_add)
def my_add(a,b):
time.sleep(0.2)
return a+b
@trans # my_sub = trans(my_sub)
def my_sub(a,b):
time.sleep(0.3)
return a-b
@trans # sleep = trans(sleep)
def sleep():
# 时间休眠
time.sleep(1)
print(my_add(10, 20))
print(my_sub(10, 20))
sleep()7.装饰器总结
python
# 装饰器 本质简化代码
# 作用：原有代码不进行修改的前提下，增加新的功能
# 语法
'''
闭包 -- 1. 函数嵌套 2. 外层函数的返回为内存函数的引用 3. 内层中使用外层函数的变量
def outer(other): -- other 接受被装饰函数
def inner(*args): -- *args 给被装饰函数 传递参数的
1. 原有功能的实现 被装饰函数的实现
res = other(*args)
2. 装饰的功能
功能的实现
return res
return inner
装饰函数
@装饰器函数的外层函数名
'''
# 装饰器 实现的功能 买入家具
def outer(other): # other 接受被装饰函数
def inner(*args):
# 实现的功能 有房子 买家具
res = other(*args)
# 买入家具
print('买入新沙发')
print('买了新茶几')
print('买了新冰箱')
print('哈哈哈 房子好漂亮')
return inner
@outer # house1 = outer(other=house1) -- other=house1 house1 = inner
def house1():
print('这是我的第一个新房子')
@outer # house2 = outer(other=house2) -- other = house2 house2 = inner
def house2():
print('这是我的第二个新房子')
house1() # inner()
# 这是我的第一个新房子
# 买入新沙发
# 买了新茶几
# 买了新冰箱
# 哈哈哈 房子好漂亮
house2() # inner()
# 这是我的第二个新房子
# 买入新沙发
# 买了新茶几
# 买了新冰箱
# 哈哈哈 房子好漂亮8.装饰器练习
python
# 增加一个功能 点赞 评论之前
# 输入账号和密码 验证账号密码是否正确 如果正确 执行点赞或者评论
def outer(other):
def inner(*args):
# 新增的功能
username = input('账号')
password = input('密码')
if username == 'admin' and password == '1234':
other()
# 原有功能的实现
else:
print('错了重来')
return inner
@outer
def comment():
print('评论')
@outer
def like():
print('点赞')
comment()
# like()9.包和模块：
9.1 模块
什么是模块？一个python文件就是一个模块，模块分为三类：
- 系统模块【安装python环境自带的】
- 三方模块 【别人写好，上传到网站的，如果使用，需要下载
pip install xxx】 - 自定义模块 【自己写的模块】
python
pip 常用的指令
查看当前环境的三方模块 pip list
下载模块 pip install 模块名
卸载模块 pip uninstall 模块名
下载指定指定版本的模块 pip install 模块名==版本号 模块之间是可以相互调用的，先进行导入，导入方式
'''
1. import 模块名
使用方式 模块名.操作
2. from 模块名 import 操作名
使用 直接使用操作名
3. from 模块名 import *
* 代指该模块下的所有内容
但是 如果在模块中使用 __all__ 规定了对外公开的内容
使用这种方式只能获取到 __all__中的内容
'''
# import string # 导入是 string.py 文件
# import 模块名
# import demo -- 可以自己构建一个模块
# # 导入模块 执行模块中的内容
# # 使用方法 模块名.操作
# print(demo.my_add(10, 20))
# print(demo.my_sub(10, 20))
# from 模块名 import 操作
# from demo import my_add,my_sub
# # 使用方法 操作名称
# print(my_add(10, 20))
# print(my_sub(10, 20))
# from 模块名 import * * 模块中的所有内容
# 使用方法 操作名称
# from demo import *
#
# print(my_add(10, 20))
# print(my_sub(10, 20))
# print(my_mul(10, 20))9.2 包
比较特殊的文件夹
和普通的文件夹的区别，包中自带一个文件 __init__.py 文件
__init__.py的作用：1. 作为普通的目录和包的区别 2. 调用包的内容的时候 首先执行文件中的内容
包的作用：1. 分类管理 2. 增大命名空间
调用包中内容，方式
包 -- 文件夹 -- 文件夹 -- 文件夹
包 -- 包 -- 包 -- 包 -- 文件
1. import 包名1.包名2.模块名 -- 以两层举例子
使用 包名1.包名2.模块名.操作
起别名 import 包名1.包名2.模块名 as 别名
使用 别名.操作
2. from 包名1.包名2.模块名 import 操作1，操作2
使用方法 操作名称
3. from 包名1.包名2.模块名 import *
使用 直接使用操作名
* 代指该模块下的所有内容
但是 如果在模块中使用 __all__ 规定了对外公开的内容
使用这种方式只能获取到 __all__中的内容
使用方法 操作名称
from demo import *
print(my_add(10, 20))
print(my_sub(10, 20))
print(my_mul(10, 20))
##### 9.2 包
比较特殊的文件夹
和普通的文件夹的区别，包中自带一个文件 `__init__.py` 文件
`__init__.py`的作用：1. 作为普通的目录和包的区别 2. 调用包的内容的时候 首先执行文件中的内容
包的作用：1. 分类管理 2. 增大命名空间
调用包中内容，方式 包 -- 文件夹 -- 文件夹 -- 文件夹
包 -- 包 -- 包 -- 包 -- 文件
-
import 包名1.包名2.模块名 -- 以两层举例子
使用 包名1.包名2.模块名.操作
起别名 import 包名1.包名2.模块名 as 别名
使用 别名.操作
-
from 包名1.包名2.模块名 import 操作1，操作2
使用方法 操作名称
-
from 包名1.包名2.模块名 import *
使用 直接使用操作名
- 代指该模块下的所有内容
但是 如果在模块中使用 all 规定了对外公开的内容
使用这种方式只能获取到 __all__中的内容
``
- 代指该模块下的所有内容