Python生成器与迭代器
1. 生成式
列表生成式
列表生成式就是一个用来生成列表的特定语法形式的表达式。是Python提供的一种生成列表的简洁形式, 可快速生成一个新的list。
普通的语法格式 [exp for iter_var in iterable]
带过滤功能语法格式: [exp for iter_var in iterable if_exp]
循环嵌套语法格式: [exp for iter_var_A in iterable_A for iter_var_B in iter_var_A]
实例
- 取出字典中所有的值并组成相应的列表
# 一般循环语句
d={"name":"weixin","age":17}
for item in d:
value = d[item]
# 生成式
value = [i for i in d.keys()]
- 找出1-100之间可以被7整除的数
# 一般循环
nums = []
for num in range(0, 100):
if num % 7 == 0:
nums.append(num)
print(nums)
# 生成式
nums = [num for num in range(0, 100) if num % 7 == 0]
print(nums)
集合生成式
result = {i**2 for i in range(10)}
字典生成式
result = {i:i**2 for i in range(10)}
2. 生成器
在Python中,一边循环一边计算的机制,称为生成器:Generator。
性能限制时,例如当读取一个10G的文件,如果一次性将10G的文件加载到内存处理的话(read方法),内存肯定会溢出;但使用生成器把读写交叉处理进行,比如使用(readline和readlines)就可以再循环读取的同时不断处理,这样就可以节省大量的内存空间.
生成器的特点
- 解耦. 爬虫与数据存储解耦;
- 减少内存占用. 随时生产, 即时消费, 不用堆积在内存当中;
- 可不终止调用. 写上循环, 即可循环接收数据, 对在循环之前定义的变量, 可重复使用;
- 生成器的循环, 在 yield 处中断, 没那么占 cpu.
创建生成器
- 由生成式改写([ ]➡️( ))
nums = (i**2 for i in range(10))
- yield关键字
yield:遇到yield则停止执行代码, 当再次调用next方法时,会从上次停止的地方继续执行,遇到yield停止
def login():
print('step 1') # 'step 1'
yield 1 # output 1
print('step 2')
yield 2
print('step 3')
yield 3
# 如果函数里面有yield关键字,函数的返回值就是一个生成器
g = login()
print(g)
print(next(g))
print(next(g))
生成器、迭代器与可迭代对象之间的关系
3. 装饰器
装饰器本质上是一个函数,该函数用来处理其他函数 ,它可以让其他函数在不需要修改代码的前提下增加额外的功能,装饰器的返回值也是一个函数对象。
装饰器经常用于有切面需求的场景,比如:插入日志、性能测试、事务处理、缓存、权限校验等应用场景。
装饰器的实现
- 基于闭包
def timeit(f): # f=add
def wrapper(x, y):
start = time.time()
result = f(x, y) # f实质上是add函数
end = time.time()
print("函数运行的时间为: %.4f" %(end-start))
return result
return wrapper
@timeit # 1. 语法, add=timeit(add)
def add(x, y):
return x + y
result = add(1, 3)
print(result)
- 万能装饰器(模版)
def 装饰器名称(f):
@wraps(f) # 保留被装饰函数的属性信息和帮助文档
def wrapper(*args, **kwargs):
# 执行函数之前做的事情
result = f(*args, **kwargs)
# 执行函数之后做的事情
return result
return wrapper
- 含参数的装饰器
# 需求: 计算函数的运行时间
import time
from functools import wraps
def timeit(f):
"""计时器的装饰器"""
@wraps(f) # 保留被装饰函数的属性信息和帮助文档
def wrapper(*args, **kwargs):
"""wrapper内部函数"""
start = time.time()
result = f(*args, **kwargs)
end = time.time()
print(f"函数{f.__name__}运行时间为{end-start}秒")
return result
return wrapper
@timeit
def login():
"""login desc"""
print('login....')
@timeit
def crawl():
import requests
url = 'https://upload.wikimedia.org/wikipedia/commons/thumb/0/0a/Python.svg/1200px-Python.svg.png'
content = requests.get(url).content
with open('doc/python.png', 'wb') as f:
f.write(content)
print("下载图片成功")
# print(help(login))
# login()
crawl()
- 多装饰器
from functools import wraps
def is_login(f):
# @wraps(f)
def wrapper1(*args, **kwargs):
print('is_login, 用户是否登录')
result = f(*args, **kwargs)
return result
return wrapper1
def is_permission(f):
# @wraps(f)
def wrapper2(*args, **kwargs):
print('is_permission, 用户是否有权限')
result = f(*args, **kwargs)
return result
return wrapper2
# 规则: 执行装饰器内容是从上到下。 被装饰的顺序是从下到上。
@is_login # show_hosts=is_login(wrapper2) show_hosts=wrapper1
@is_permission # show_hosts = is_permission(show_hosts) show_hosts=wrapper2
def show_hosts():
print("显示所有的云主机")
"""
--: show_hosts()
1). wrapper1()
2). wrapper2()
3). show_hosts()
"""
show_hosts()
4. 闭包
常见形式: 内部函数使用了外部函数的临时变量,且外部函数的返回值是内部函数的引用。
闭包的一个常用场景就是装饰器。
import time
# 闭包:
# 1. 函数里面嵌套函数
# 2. 外部函数的返回值是内部函数的引用
# 3. 内部函数可以使用外部函数的变量
def timeit(name):
def wrapper():
start_time = time.time()
print('wrapper ' + name)
end_time = time.time()
print(end_time - start_time)
print('timeit')
return wrapper
in_fun = timeit(name='westos') # wrapper函数, in_fun实质上就是wrapper函数
in_fun()
5. 内置高阶函数
高阶函数: 高阶函数英文叫 Higher-order function。编写高阶函数,就是让函数的参数能够接收别的函数。把函数作为参数传入,这样的函数称为高阶函数,函数式编程就是指这种高度抽象的编程范式。高阶函数以及迭代函数还可以帮我们省去使用循环遍历元素的操作,在内部已经帮我们实现好了!
一、all() 函数——判断可迭代对象中的元素是否全为True
all() 函数用于判断可迭代对象是否包括假值即 0、空、False,除此之外都属于真值。如果包括假值结果就为 False,否则结果就为 True。
all() 函数的语法格式如下:
all(iterable)
参数说明:
- iterable:可迭代对象,如列表、元组等。参数不能为空并且提供的参数必须是可迭代器对象,否则将提示 TypeError 错误信息。
- 返回值:返回值为 True 或 False,如果可迭代对象不包括空、0、False 的元素,那么返回值为 True,否则返回值为 False。
注意:如果可迭代对象中元素个数为 0,则返回值为 True,例如空列表、空元组、空字典、空字符串的返回值为 True
二、any() 函数——判断可迭代对象是否全为假值
any() 函数用于判断可迭代对象元素是否都是假值即 0、空、False。如果全部为假值则返回 False,否则返回 True。any() 函数的语法格式如下:
any(iterable)
参数说明:
- iterable:可迭代对象,如列表、元组、字符串等。同样的,参数不能为空并且提供的参数必须是可迭代器对象,否则将提示 TypeError 错误信息。
- 返回值为 True 或 False,如果可迭代对象中只要有一个元素不是假值,则返回值为 True,如果可迭代对象中所有的元素都是假值,则返回值为 False。
三、filter() 函数——通过指定条件过滤序列
filter() 函数用于过滤掉可迭代对象中不符合条件的元素,返回由符合条件的元素组成的新的迭代器。filter() 函数把传入的函数依次作用于每个元素,然后根据返回值是 True 还是 False 决定保留还是丢弃该元素。filter() 函数的语法格式如下:
filter(function,iterable)
参数说明:
# 1. filter()函数的基本应用。使用filter()函数过滤出0~20(不包括20)之间的所有奇数,代码如下:
def odd_number(num): # 定义一个判断奇数的函数
return num % 2 != 0
# 使用filter()函数过滤出序列中的奇数
new_list = filter(odd_number, range(1, 20))
print(new_list) # 返回一个迭代器对象
print(list(new_list)) # 使用list()函数将迭代器转换为列表
# 2. 筛选指定范围的数据。定义学生列表,实现按照2020年高考理科成绩进行筛选,得出成绩在600分到700分之间的学生信息,代码如下:
def find(item): # 创建函数
total = int(item[1])
if 600 <= total <= 700: # 判断条件
return True
return False
list1 = [('小明', 600), ('小刚', 601), ('小雅', 524), ('小旭', 714), ('小章', 624),
('小白', 635), ('小赵', 480), ('小高', 580), ('小王', 541), ('小琪', 680)]
new_list = filter(find, list1) # 过滤序列中不符合条件的元素
list2 = list(new_list) # 使用list()函数转换为列表
print(list2) # 输出学生列表
print(f'600分以上:{len(list2)}人') # 输出人数
# 3. 筛选类型不是字符的元素。例如,在一个集合中有一组数据,包括字符串、数字等,下面筛选出类型不是字符串的元素,代码如下:
set1 = {'Amo', 123, 12.1, -1, "Paul"}
# {123, 12.1, -1}
print(set(filter(lambda x: type(x) != str, set1)))
# 4. 取出字符串中的数字并转换为整型。取出一组注册信息中的数字,然后转换为整数。首先判断字符串是否为数字,然后使用filter()函数过滤数字,最后转换为整型输出,代码如下:
str1 = 'ISVO20N2WTRJ4T0XXGQ5QWP9Z'
str2 = filter(str.isdigit, str1) # 过滤数字
new_list = list(str2) # 转换为列表
str3 = ''.join(new_list) # 连接列表
print(int(str3)) # 转换为整型输出 2024059
# 5. 去除序列中所有值为假的元素。如果将 filter() 函数的第一个参数 function 的值设置为 None,就会默认去除序列中所有值为假的元素,如 None、False、0、’’、()、[] 和 {}等,代码如下:
L = [1, '', 0, 'C', None, [0, 1, 2], False, 3.14, [], {'c': 1, 3: None}, {}]
f = filter(None, L) # 去除序列中为假的元素
print(list(f)) # [1, 'C', [0, 1, 2], 3.14, {'c': 1, 3: None}]
# 6. 获取序列中被删除的元素。filter() 函数的返回值是一个可迭代对象,利用 for 循环将返回数据与原始数据比较,就可以判断出哪些元素被删除了。代码如下:
L = [1, '', 0, 'C', None, [0, 1, 2], False, 3.14, [], {'c': 1, 3: None}, {}]
f = list(filter(None, L))
print(f)
delete_data = L
for i in f:
if i in L:
delete_data.remove(i)
print(f"被删除的元素为: {delete_data}")
# 7. 获取索引中以索引为基数所对应的元素。通过 filter() 和 lambda() 函数输出列表 list_a 中以索引为基数出现次数最多的元素。代码如下:
list_a = [12, 213, 22, 2, 2, 2, 22, 2, 2, 32]
li = filter(lambda x: x in list_a, [i for i in range(len(list_a))])
print(list(li)) # [2]
四、map() 函数——通过函数实现对可迭代对象的操作
map() 函数接收一个函数为参数和一个或者多个可迭代对象为参数,返回一个迭代器。此迭代器中每个元素都是函数参数依次作用于可迭代对象后的结果。map()函数的语法格式如下:
map(function, iterable, …)
参数说明:
注意:map()函数在Python 2.x返回的是列表,而在Python 3.x中返回的是可迭代器对象。
# 1.将列表中的元素转换为Unicode字符。
num1 = [25105, 29233, 80, 89]
a = map(chr, num1) # 返回一个迭代器对象
print(a)
print(list(a)) # 使用list()函数转换为列表
# 从程序的运行结果可以看出,map() 函数返回的是一个可迭代器对象,我们通过使用 list() 函数将其转换为列表。
# 2.规范英文的大小写。通过map()函数规范英文短句中单词的大小写(即首字母大写,其余字母小写),代码如下:
name_list = ['Being', 'SinGle', 'IS', 'better', 'than',
'being', 'in', 'an', 'unfaithful', 'relationship'] # 创建列表
def function(x): # 定义函数
return x.capitalize() # 实现首字母大写,其他字母小写
print("规范后的英文短句:", list(map(function, name_list))) # 使用list()函数转换为列表
aa = list(map(function, name_list))
print(' '.join(aa)) # 连接列表
# 3.对列表中的元素进行平方计算。
num_list = [i for i in range(10)] # 创建空列表
list2 = map(lambda x: x ** 2, num_list) # 返回一个迭代器对象
# [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
print(list(list2)) # 使用list()函数转换为列表
# 3.传入多个可迭代对象。当使用map()函数传入多个可迭代对象时,且里面的元素长度不一致时,生成的迭代器以最短长度为主,例如下面的代码:
list1 = [1, 3, 5] # 列表1
list2 = [2, 4, 6, 8, 10] # 列表2
result = map(lambda x, y: x + y, list1, list2) # 返回一个迭代器对象
# [3, 7, 11]
print(list(result)) # 使用list()函数转换为列表
# 注意:当map()函数传入多个可迭代对象时,参数function必须能够接收足够多的参数,以保证每个可迭代对象同一索引的值均能正确传入函数,否则将出现错误提示TypeError。
五、range() 函数——生成器函数
range() 函数用于生成一个新的 range 类型,多用于 for 循环语句中,用于生成指定范围的整数。range() 函数的语法格式如下:
range(start,end,step)
参数说明:
- start:表示起始整数(包含起始整数),默认起始值为 0,起始整数可以省略,如果省略则表示从 0 开始。
- end:表示结束整数(但不包括该值,如 range(7) 得到的值为 0~6,不包括7),结束数值不能省略。当 range() 函数中只有一个参数时,即表示指定计数的结束值。结束整数可以大于 0,也可以小于或等于 0,但是结束整数小于或等于 0 时,生成的 range 对象是不包含任何元素的。
- step:表示步长,即两个数之间的间隔,参数 step 可以省略,如果省略则表示步长为 1。例如,range(1,7) 将得到 1、2、3、4、5、6。
- 返回值:返回一个 range 对象。
range()函数接收的参数必须是整数,不能是浮点数等其他数据类型,否则会提示类型错误。在使用range()函数时,如果只有一个参数,那么表示指定的是stop结束整数;如果是两个参数,则表示指定的是start开始整数和end结束整数;只有三个参数都存在时,最后一个参数才表示step步长。
# 1.根据提供的参数生成一个range类型。
range(6) #只有一个参数时,如果放入for循环中,就代表for循环执行多少次
# 2.使用list()函数将range类型转换为列表。
list(range(0)) # []
list(range(-1)) # []
# 当传入的参数为0或负数时,输出列表为空
list(range(6)) # [0, 1, 2, 3, 4, 5]
# 3.使用range()函数实现数字的累加。使用range()函数实现从1到100的累加,代码如下:
result = 0 # 保存累加结果的变量
for i in range(101):
result += i # 实现累加功能
print(result) # 在循环结束时输出结果
# 4.遍历字符串。下面使用range()函数结合for循环输出英文单词“Python”中的每个字母,代码如下:
str1 = 'Python'
for i in range(len(str1)):
print(str1[i])
# 5.生成指定步长的数值序列。下面使用range()函数分别输出12月份中的奇数月份和偶数月份,代码如下:
num1 = range(2, 14, 2)
num2 = range(1, 13, 2)
print('偶数月份:', end=' ') # 输出偶数月份
for i in num1:
print(i, end=' ')
print('\n', end='') # 换行
print('奇数月份:', end=' ') # 输出奇数月份
for i in num2:
print(i, end=' ')
六、reversed ()函数——反转序列对象
reversed() 函数用于反转一个序列对象,将其元素从后向前颠倒构建成一个新的迭代器,reversed() 函数的语法格式如下:
reversed(seq)
参数说明:
# 1.反转数字列表并排序。定义一个保存Python成绩的列表,然后使用sort()方法排序,使用reversed()函数对列表反转,实现降序排序,代码如下:
num_list = [100, 85, 56, 59, 75, 77] # 分数列表
num_list.sort() # 对分数排序
print(num_list)
print(list(reversed(num_list))) # 降序输出
# 2.将部分列表元素反转-使用切片操作
a = [1, '23', 4, 5, 6]
ra = list(reversed(a[:3]))
print(ra) # [4, '23', 1]
a[0:3] = ra
print(a) # [4, '23', 1, 5, 6]
七、sorted() 函数——对可迭代对象进行排序
sorted() 函数用于对可迭代对象进行 排序,返回一个重新排序的列表,当使用该函数进行排序后,原列表的元素顺序不变。语法格式如下:
sorted(iterable, key=None, reverse=False):
参数说明如下:
- iterable:表示可迭代对象,如列表、字符串、字典等。
- key:可选参数,可选参数 key 是一个函数(方法),用来指定排序的规则(即按照指定的方法或函数对可迭代对象进行排序)。例如,设置 key=str.lower,表示可迭代对象中的每个元素转换为小写字母后再进行排序,返回的仍然是可迭代对象中的元素。默认key=None,表示直接比较元素进行排序。
- reverse:可选参数,排序规则,默认 reverse=False,表示升序排列,如果 reverse=True,则表示降序排列。
返回值:返回重新排序的列表。
# 1.对字符列表进行排序。定义一个保存字符的列表,然后应用 sorted() 函数对其进行排序,并指定参数 key=str.lower,代码如下:
char_list = ['a', 'b', 'c', 'd', '*', 'M', 'R', 'S', 'O', 'F', 'T'] # 定义列表
# 默认按字符ASCII码进行排序
# 升序: ['*', 'F', 'M', 'O', 'R', 'S', 'T', 'a', 'b', 'c', 'd']
print(f"升序: {sorted(char_list)}") # 进行升序排列
# 降序: ['d', 'c', 'b', 'a', 'T', 'S', 'R', 'O', 'M', 'F', '*']
print(f"降序: {sorted(char_list, reverse=True)}") # 进行降序排列
# 转换为小写字母后升序: ['*', 'a', 'b', 'c', 'd', 'F', 'M', 'O', 'R', 'S', 'T']
print(f"转换为小写字母后升序: {sorted(char_list, key=str.lower)}")
# 转换为小写字母后升序: ['T', 'S', 'R', 'O', 'M', 'F', 'd', 'c', 'b', 'a', '*']
print(f"转换为小写字母后升序: {sorted(char_list, key=str.lower, reverse=True)}")
# 2.按照列表中嵌套元组的指定元素进行排序。依据英语小 A 班学生列表 students 中元组的第 1 个下标值 (年龄) 和 第 2 个下标值 (身高) 进行升序和降序排列,代码如下:
# 定义列表(姓名、年龄、身高)
students = [('Adas', 3, 99), ('Lily', 4, 110), ('Bella', 4, 112), ('Anna', 3, 95)]
s1 = sorted(students, key=lambda x: x[2]) # 按身高进行升序排列
print('按身高升序:', s1)
s2 = sorted(students, key=lambda x: x[2], reverse=True) # 按身高进行降序排列
print('按身高降序:', s2)
s3 = sorted(students, key=lambda x: x[1]) # 按年龄进行升序排列
print('按年龄升序:', s3)
s4 = sorted(students, key=lambda x: x[1], reverse=True) # 按年龄进行降序排列
print('按年龄降序:', s4)
# 3.将数字按绝对值进行排序。定义一个含有多个正负数的列表,然后应用 sorted() 函数对其进行排序,并指定参数 key=abc,代码如下:
s = [39, 15, -12, 9, -21, 66]
s_positive = sorted(s) # 正常排序
print(s_positive)
s_negative = sorted(s, key=abs) # 按绝对值排序
print(s_negative)
# 4.将数字和数字字符串进行排序。在一组数据列表中,有时候可能会混入一些为字符串格式的数字,在 python3 中是不能将字符串与数字进行比较的,而是需要使用 functools模块 中的 cmp_to_key 来指定比较函数是什么。代码如下:
import functools
def compare(x1, x2):
if isinstance(x1, str):
x1 = float(x1)
if isinstance(x2, str):
x2 = float(x2)
return x1 - x2
nums = [3.9, 15, -1.2, 9, -21, 6.6, '-1', '2.4', '-3.3']
nums_sort = sorted(nums, key=functools.cmp_to_key(compare))
# 输出==>[-21, '-3.3', -1.2, '-1', '2.4', 3.9, 6.6, 9, 15]
print(nums_sort)
# 5.通过 key 的值对字典进行排序。定义一个包含多个字典的列表,然后应用 sorted() 函数对其进行排序,并指定参数 key=lambda x:x[“age”]。代码如下:
age_name = [{"age": 20, "name": "coc"},
{"age": 25, "name": "ctt"},
{"age": 10, "name": "ctc"}]
age_name_sort = sorted(age_name, key=lambda x: x["age"]) # 通过字典中的age进行排序
# [{'age': 10, 'name': 'ctc'}, {'age': 20, 'name': 'coc'}, {'age': 25, 'name': 'ctt'}]
print(age_name_sort)
# 6.对类的实例对象进行排序。如果要排序的元素是自定义类,例如使用 Student 类中的 age 参数来排序。代码如下:
class Student(object):
def __init__(self, name, grade, age):
self.name = name
self.grade = grade
self.age = age
def __repr__(self):
return repr((self.name, self.grade, self.age))
s_examples = [
Student('coc', 'A', 15),
Student('dod', 'B', 12),
Student('god', 'A', 12),
Student('cod', 'B', 10), ]
s_examples_sorted = sorted(s_examples, key=lambda t: t.age) # 使用类的age属性进行排序
# [('cod', 'B', 10), ('dod', 'B', 12), ('god', 'A', 12), ('coc', 'A', 15)]
print(s_examples_sorted)
# 7.使用多个条件排序。在根据类中的某个属性进行排序时,难免会出现相同的元素,此时可以再指定一条属性用于排序。代码如下:
class Student(object):
def __init__(self, name, grade, age):
self.name = name
self.grade = grade
self.age = age
def __repr__(self):
return repr((self.name, self.grade, self.age))
s_examples = [
Student('coc', 'A', 15),
Student('dod', 'B', 12),
Student('god', 'A', 12),
Student('cod', 'B', 10), ]
s_examples_age_grade = sorted(s_examples, key=lambda t: (t.age, t.grade)) # 使用多个条件排序
print(s_examples_age_grade)
列表对象的 sort() 方法 和 内置 sorted() 函数的作用基本相同,所不同的就是使用 sort() 方法时,会改变原列表的元素排列顺序,而使用 sorted() 函数时,会建立一个原列表的副本,该副本为排序后的列表。
八、zip() 函数——将可迭代对象打包成元组
zip() 函数用于将可迭代的对象作为参数,将对象中对应的元素打包成一个个元组,然后返回由这些元组组成的 zip 对象。语法格式如下:
zip(*iterables) --> zip object
参数说明:
- iterables:可迭代对象,如列表、字典、元组、字符串等,zip() 函数允许多个可迭代对象作为参数。
- 当 zip() 函数没有参数时,则返回空的迭代器。
- 当 zip() 函数只有一个参数时,则从参数中依次取一个元素组成一个元组,再将依次组成的元组组合成一个新的迭代器。
- 当 zip() 函数有两个参数时,分别从两个参数中依次各取出一个元素组成元组,再将依次组成的元组组合成一个新的迭代器。
- 返回值:返回一个可迭代的 zip 对象,其内部元素为元组,可以使用 list() 函数 或 tuple() 函数将其转换为列表或元组。
# 1.用 zip() 函数实现列表合并。下面使用 zip() 函数实现将两个列表进行合并。例如,将 name_list、age_list 两个列表合并,代码如下:
name_list = ["Amo", "Paul", "Jason", "Seven"]
age_list = [18, 19, 20, 21]
# 输出 ==> [('Amo', 18), ('Paul', 19), ('Jason', 20), ('Seven', 21)]
print(list(zip(name_list, age_list)))
# 2.使用 zip() 函数建立字典。
# 有两个列表 name_list 和 score_list,其中 name_list 中存储着学生姓名,score_list 存储着每个学生的考试成绩,如果要通过某个学生姓名来查找其考试成绩,则需要一个字典,zip() 函数可以很方便地建立字典,代码如下:
name_list = ["Amo", "Paul", "Jason", "Seven"] # 定义列表name_list
score_list = [80, 96, 77, 88] # 定义成绩
my_dict = dict(zip(name_list, score_list)) # 使用dict()函数将zip对象转换为字典
print(my_dict["Amo"]) # 输出 80
# 3.zip() 函数妙用 1— 矩阵的旋转。矩阵是高等数学中的常见工具,也常用于统计分析和数学应用中。
# 下面使用 zip() 函数实现一个 xyz 的矩阵的旋转,代码如下:
x = [1, 2, 3]
y = [4, 5, 6]
z = [7, 8, 9]
xyz = list(zip(x, y, z))
print(xyz)
for a, b, c in zip(x, y, z):
print(f"{a},{b},{c}")
# 4.输出字典中值最大所对应的键。
# 在一个字典当中,求值最大所对应的键时,zip() 函数就派上了大用场。代码如下:
data = {"张三": 100, "李四": 20, "王五": 500, "赵六": 12}
obj = zip(data.values(), data.keys())
# 输出:分数最高的学生姓名为: 王五
print(f"分数最高的学生姓名为: {max(obj)[1]}")
九、reduce() 函数
reduce把一个函数作用在一个序列 [x1, x2, x3, …]上,这个函数必须接收两个参数,reduce 把结果继续和序列的下一个元素做累积计算,其效果就是: reduce(f, [x1, x2, x3, x4]) = f(f(f(x1, x2), x3), x4)
# 演示reduce函数的用法。
from functools import reduce
# 例子: 对一个序列求和 注意reduce不是python内置的 在functools模块中
print(reduce(lambda a, b: a + b, [1, 3, 5, 7, 9])) # 这里的话其实可以直接使用sum() 25
# 但是如果想把[1, 3, 5, 7, 9]变成13579 高阶函数reduce就可以派上用场了
print(reduce(lambda a, b: a * 10 + b, [1, 3, 5, 7, 9])) # 13579
# 第一次:1*10+3 -->13
# 第二次:13*10+5 -->135
# 第三次:135*10+7 -->1357
# 第四次:1357*10+9 -->13579
# Python提供的sum()函数可以接受一个list并求和,请编写一个prod()函数,可以接受一个list并利用reduce()求积:
def prod(num_list2):
return reduce(lambda x, y: x * y, num_list2)
print(prod([3, 5, 7, 9])) # 945
版权声明:本文内容由互联网用户自发贡献,该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容, 请发送邮件至 dio@foxmail.com 举报,一经查实,本站将立刻删除。