Python生成器与迭代器

最新推荐文章于 2022-10-25 09:12:50 发布

songyi10

最新推荐文章于 2022-10-25 09:12:50 发布

阅读量382

点赞数

分类专栏： Python基础知识文章标签： python

本文链接：https://blog.csdn.net/songyi10/article/details/118326511

版权

Python基础知识专栏收录该内容

1 篇文章 0 订阅

订阅专栏

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))

生成器、迭代器与可迭代对象之间的关系

迭代是访问容器元素的一种方式。迭代器是一个可以记住遍历的位置的对象。

迭代器对象从集合的第一个元素开始访问,直到所有的元素被访问完结束。

可迭代对象：可以直接作用于for循环的对象(如何判断是否可以迭代?)

一类是集合数据类型,如list， tuple，dict， set，str等;
一类是generator,包括生成器和带yield的generator function。

可以被next()函数调用并不断返回下一个值的对象称为迭代器:Iterator。

生成器都是Iterator对象,但list、dict、str虽然是Iterable,却不是Iterator。

把list、dict、str等Iterable变成Iterator可以使用iter()函数

3. 装饰器

装饰器本质上是一个函数，该函数用来处理其他函数，它可以让其他函数在不需要修改代码的前提下增加额外的功能，装饰器的返回值也是一个函数对象。

装饰器经常用于有切面需求的场景，比如：插入日志、性能测试、事务处理、缓存、权限校验等应用场景。

定义: 用来装饰函数的工具。
功能: 在不改变源代码的情况下，添加额外功能(eg: 计算运行时间, 记录日志，权限判断)的工具.

装饰器的实现

基于闭包

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)

参数说明：

function：用于实现判断的函数。注意：这里的函数指的是函数的名字，不要打()调用。
iterable：可迭代对象，如列表、range 对象等。
返回值：返回一个迭代器对象。

# 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, …)

参数说明：

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)

参数说明：

seq：序列，如列表、元组、字符串或 range 对象等。
返回值：返回一个反转的迭代器。

# 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

songyi10

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Python生成器与迭代器

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
复制链接

扫一扫