Python生成器与迭代器_python 生成器结束_songyi10的博客

列表生成式

列表生成式就是一个用来生成列表的特定语法形式的表达式。是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
生成器的基础是，所以在学习本博客之前，一定要先学习迭代器
1. 什么是生成器
利用迭代器，我们可以在每次迭代获取数据（通过next()方法）时按照特定的规律进行生成。但是我们在实现一个迭代器时，关于当前迭代到的状态需要我们自己记录，进而才能根据当前的状态生成下一个数据。为了达到记录当前的状态，并配合next()函数进行迭代使用，我们可以采用更加简便的语法，即生成器。生成器是一种特殊的迭代器
2.创建生成器的两种方法
2.1 类似列表解析
我们都清楚列表解析，举个例子：
data = [x*2 fo
                                    函数名的使用：函数名是一个变量, 但它是一个特殊的变量, 与括号配合可以执行函数的变量函数名的内存地址：deffunc():passprint(func)  #函数的内存地址结果：函数名可以赋值给其他变量：deffunc():print(1)a=funca()func()#函数名可以当做值赋值给变量结果：11函数名可以当做容器类的元素：deffunc():print(1)deffunc2():pr...
迭代器是访问集合内元素的一种方式，一般用来遍历数据
迭代器和以下标的访问方式不一样，迭代器是不能返回的（比如下标方式 list[2],之后可以访问list[0],list[1]，只能__next__），迭代器提供了一种惰性方式获取数据（就是只有在访问数据的时候才去计算或者说才去获取数据）
python使用生
                                    我们很幸运地生活在市场力量将内存，磁盘甚至CPU的价格推至以前难以想象的低点的时候。 但是，与此同时，大数据，人工智能和认知计算等蓬勃发展的应用程序正以令人眼花rate乱的速度推动我们对这些资源的需求。 具有讽刺意味的是，在计算资源丰富的时代，对于开发人员来说，了解如何降低其消耗量以保持竞争力越来越重要。 
 Python保持如此流行的编程语言近二十年的主要原因是它非常易于学习。 在一个小时内...
                                    输入输出input() 输入函数print() 输出函数程序一运行，会首先打印出please enter your name:，这样，用户就可以根据提示，输入名字后，得到hello, xxx的输出：name = input('please enter your name: ')print('hello,', name)输出的时候 ,分隔开，会自动加一个空格python基础# 开头的是注释。当语句以...
    current_num = 0
    while current_num < all_num:
        yield a  # 如果一个函数中有yield语句，那么这个就不在是函数，而是一个生成器的模板
        a, b = b, a+b
        cu...
                                    迭代器是可以迭代的对象。 在本教程中，您将了解迭代器的工作原理，以及如何使用__iter__和__next__方法构建自己的迭代器。迭代器在Python中无处不在。 它们优雅地实现在循环，推导，生成器等中，但隐藏在明显的视觉中。Python中的迭代器只是一个可以迭代的对象。一个将一次返回数据的对象或一个元素。从技术上讲，Python迭代器对象必须实现两个特殊的方法__iter__()和__next...
                                    1.生成器本质：迭代器2.自带yeild 关键字，调用此函数得到一个生成器3.多次调用函数就得到多个生成器4.send、yeild、while True循环要配套使用 
使用send前要初始化将程序停到yeild位置将程序挂起，然后send()可以执行，直到遇到下一个yeild程序挂起并将下一个yeild后面的值返回（精华，理解了这句话就真正理解了send的用法）5.yeild返回值的时候不管yei
                                    三个实例带你了解生成器的作用python的生成器究竟有什么作用? 本文通过3个具体的例子向你阐述生成器的作用, 1. 使用生成器非常便利的结束两层for循环, 2. 一个for循环遍历多个列表, 3. 并行遍历多个可迭代对象提到生成器，你可能会有一个简单的概念，如果函数里使用yield关键字，那么这个函数就是一个生成器，不同于return，生成器使用yield来返回值。令人感到困惑之处在于，似乎y...
                    ♚作者：酱油哥，清华大学计算机硕士，泰康资管/军工央企职场经历。0.本集概览1.生成器可以避免一次性生成整个列表 2.生成器函数的运行过程解析及状态保存 3.生成器表达式...
                                    1.生成器利用迭代器，我们可以在每次迭代获取数据（通过next()方法）时按照特定的规律进行生成。但是我们在实现一个迭代器时，关于当前迭代到的状态需要我们自己记录，进而才能根据当前状态生成下一个数据。 
为了达到记录当前状态，并配合next()函数进行迭代使用，我们可以采用更简便的语法，即生成器(generator)。生成器是一类特殊的迭代器。2.创建生成器方法1要创建一个生成器，有很多种方法。第一