Python 中的迭代器和生成器

﹏ヽ暗。殇╰゛Y 2021-11-10 04:32 411阅读 0赞

#### 生成器验证数学表达式 ####

""" 验证 (1 + 2 + 3 + 4 + 5 + ...) ^ 2 = 1^3 + 2^3 + 3^3 + 4^3 + 5^3 + ... # 分别用生成器 生成 左边 1次方 和右边 3次方 的sum """
    
    
    
    
    def generator(k):
        i = 1
        while True:
            yield i ** k
            i += 1
    
    
    
    
    gen_1 = generator(1)
    gen_3 = generator(3)
    print(gen_1)  # 生成器 ：I 的 1次方
    print(gen_3)  # 生成器 ：I 的 3次方
    
    
    
    
    def get_sum(n):
        sum_1, sum_3 = 0, 0
        for i in range(n):
            next_1 = next(gen_1)  # 返回 gen_1 的yield i ** 1
            next_3 = next(gen_3)  # 返回 gen_3 的yield i ** 3
            print('next_1 = {}, next_3 = {}'.format(next_1, next_3))
            sum_1 += next_1  # sum_1 ：1 + 2 + 3 + 4 + 5 + ...
            sum_3 += next_3  # sum_3 ：1^3 + 2^3 + 3^3 + 4^3 + 5^3 + ...
        print(sum_1 * sum_1, sum_3)
        # (1 + 2 + 3 + 4 + 5 + ...) ^ 2 = 1^3 + 2^3 + 3^3 + 4^3 + 5^3 + ...
    
    
    
    
    get_sum(8)

<generator object generator at 0x00000136B1370A98>
    <generator object generator at 0x00000136B1546C00>
    next_1 = 1, next_3 = 1
    next_1 = 2, next_3 = 8
    next_1 = 3, next_3 = 27
    next_1 = 4, next_3 = 64
    next_1 = 5, next_3 = 125
    next_1 = 6, next_3 = 216
    next_1 = 7, next_3 = 343
    next_1 = 8, next_3 = 512
    1296 1296

*  迭代器：  
    1 通过 next 方法 ，调用这个方法后，要么得到这个容器的下一个对象，要么返回 StopIteration 的错误
    
    2 next 函数 可以一个一个拿到所有的元素
    
    3 除了数字 ，字符串、list列表 、 set 集合、 dict 字典、tuple元组 都是可迭代对象
 *  生成器：  
    1 若一个函数中有yield关键字，那这个函数就是一个 `generator` 。并且其执行流程和普通的函数有区别。generator每次调用 `next` 才运行，遇到yield关键字返回。再次执行next,又返回上次yield的位置接着执行。生成器 通过 yield 暂停，跳到 next 函数 将 yield 表达式作为 next 函数的返回值
    
    2 这里 生成器 gen\_1 和 gen\_3 每被调用一次 ，各自的局部变量 i 自增1 ，注意 for 中每次都重新调用了一次 gen
    
    3 当 next 被调用的时候， 生成器可以生成无数个元素

#### 生成器和迭代器的内存占用 ####

import os
    import psutil
    
    
    
    
    # 显示当前 python 程序占用的内存大小
    def show_memory_info(hint):
        pid = os.getpid()
        p = psutil.Process(pid)
    
    
        info = p.memory_full_info()
        memory = info.uss / 1024. / 1024
        print('{} memory used: {} MB'.format(hint, memory))
    
    
    
    
    def test_iterator():
        show_memory_info('initing iterator')
        list_1 = [i for i in range(100000000)]
        show_memory_info('after iterator initiated')
        print(sum(list_1))
        show_memory_info('after sum called')
    
    
    
    
    def test_generator():
        show_memory_info('initing generator')
        list_2 = (i for i in range(100000000))
        show_memory_info('after generator initiated')
        print(sum(list_2))
        show_memory_info('after sum called')
    
    
    
    
    test_iterator()
    test_generator()
    
    
    
    
    initing iterator memory used: 8.6796875 MB
    after iterator initiated memory used: 1835.44140625 MB
    4999999950000000
    after sum called memory used: 2648.34765625 MB
    initing generator memory used: 2.39453125 MB
    after generator initiated memory used: 2.4140625 MB
    4999999950000000
    after sum called memory used: 2.4375 MB

生成器并不会一次产生1亿个元素占用内存，他保存的仅仅是生产1亿个元素的 `算法`，当调用的时候，才会生成，所以占用内存少，而List的所有元素都会存在内存中，在海量数据场景下，会占用大量的内存。