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)

参数说明：

1. iterable：可迭代对象，如列表、元组等。参数不能为空并且提供的参数必须是可迭代器对象，否则将提示 TypeError 错误信息。
2. 返回值：返回值为 True 或 False，如果可迭代对象不包括空、0、False 的元素，那么返回值为 True，否则返回值为 False。

注意：如果可迭代对象中元素个数为 0，则返回值为 True，例如空列表、空元组、空字典、空字符串的返回值为 True

二、any() 函数——判断可迭代对象是否全为假值

​ any() 函数用于判断可迭代对象元素是否都是假值即 0、空、False。如果全部为假值则返回 False，否则返回 True。any() 函数的语法格式如下：

any(iterable)

参数说明：

1. iterable：可迭代对象，如列表、元组、字符串等。同样的，参数不能为空并且提供的参数必须是可迭代器对象，否则将提示 TypeError 错误信息。
2. 返回值为 True 或 False，如果可迭代对象中只要有一个元素不是假值，则返回值为 True，如果可迭代对象中所有的元素都是假值，则返回值为 False。

三、filter() 函数——通过指定条件过滤序列

​ filter() 函数用于过滤掉可迭代对象中不符合条件的元素，返回由符合条件的元素组成的新的迭代器。filter() 函数把传入的函数依次作用于每个元素，然后根据返回值是 True 还是 False 决定保留还是丢弃该元素。filter() 函数的语法格式如下：

filter(function,iterable)

参数说明：

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

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

参数说明：

1. function：函数。
2. iterable：一个或多个可迭代对象。
3. 返回值：返回迭代器。

注意：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)

参数说明：

1. start：表示起始整数(包含起始整数)，默认起始值为 0，起始整数可以省略，如果省略则表示从 0 开始。
2. end：表示结束整数(但不包括该值，如 range(7) 得到的值为 0~6，不包括7)，结束数值不能省略。当 range() 函数中只有一个参数时，即表示指定计数的结束值。结束整数可以大于 0，也可以小于或等于 0，但是结束整数小于或等于 0 时，生成的 range 对象是不包含任何元素的。
3. step：表示步长，即两个数之间的间隔，参数 step 可以省略，如果省略则表示步长为 1。例如，range(1,7) 将得到 1、2、3、4、5、6。
4. 返回值：返回一个 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. seq：序列，如列表、元组、字符串或 range 对象等。
2. 返回值：返回一个反转的迭代器。

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

参数说明如下：

1. iterable：表示可迭代对象，如列表、字符串、字典等。
2. key：可选参数，可选参数 key 是一个函数(方法)，用来指定排序的规则(即按照指定的方法或函数对可迭代对象进行排序)。例如，设置 key=str.lower，表示可迭代对象中的每个元素转换为小写字母后再进行排序，返回的仍然是可迭代对象中的元素。默认key=None，表示直接比较元素进行排序。
3. 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

参数说明：

1. iterables：可迭代对象，如列表、字典、元组、字符串等，zip() 函数允许多个可迭代对象作为参数。
2. 当 zip() 函数没有参数时，则返回空的迭代器。
3. 当 zip() 函数只有一个参数时，则从参数中依次取一个元素组成一个元组，再将依次组成的元组组合成一个新的迭代器。
4. 当 zip() 函数有两个参数时，分别从两个参数中依次各取出一个元素组成元组，再将依次组成的元组组合成一个新的迭代器。
5. 返回值：返回一个可迭代的 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