Python高级语法之推导式+迭代器+生成器案例代码

my_list = [1, 2, 3, 4, 5, 6]
# 使用推导式，生成一个新的list带条件的列表推导式
condition_squares = [x for x in my_list if x % 2 == 0]
print(f"带条件的列表推导式:{condition_squares}")  # [2, 4, 6]
# 列表推导式（立即计算）
squares_list = [x+3 for x in range(5) if x > 2]
print(squares_list)# [6, 7]
# 基础的列表推导式
basic_squares = (x**2 for x in range(5))
print(f"基础的列表推导式2:{tuple(basic_squares)}")  # [0, 1, 4, 9, 16]
# 包含多个循环的列表推导式
continue1 = [1, 2, 3]
continue2 = ["a", "b", "c"]
tuple_list = [(i, j) for i in continue1 for j in continue2]
print(f"两个循环的列表推导式:{tuple_list}") # [(1, 'a'), (1, 'b'), (1, 'c'), (2, 'a'), (2, 'b'), (2, 'c'), (3, 'a'), (3, 'b'), (3, 'c')]

my_list = [1, 2, 3, 4, 5, 6]
# 使用推导式，生成一个新的tuple
condition_squares = (x for x in my_list if x % 2 == 0)
# 返回的是生成器对象  <generator object <genexpr> at 0x0000026A12285220>
print(condition_squares)
print(f"带条件的需要tuple()进行转换的推导式:{tuple(condition_squares)}")

my_list = [1,2,3,4,5,6]
# 使用推导式，生成一个新的tuple
condition_squares = {x for x in my_list if x % 2 == 0}
print(f"带条件的推导式:{condition_squares}")

my_list = ['Google','Oracle', 'Taobao','Baidu']
#将列表中各字符串值为键，各字符串的长度为值，组成键值对
newdict = {key:len(key) for key in my_list}
print(f"f键值对推导式：{newdict}")

'''
迭代器
迭代是 Python 最强大的功能之一，是访问集合元素的一种方式。
迭代器是一个可以记住遍历的位置的对象。
迭代器对象从集合的第一个元素开始访问，迭代器只能往前不会后退,直到所有的元素被访问完结束。
迭代器有两个基本的方法：iter() 和 next()。
字符串，列表或元组对象都可用于创建迭代器：
'''
# 1 字符串，列表或元组对象都可用于创建迭代器：
my_list = [1, 2, 3, 4]
it = iter(my_list)    # 创建迭代器对象
print (next(it))   # 输出迭代器的下一个元素
print (next(it))
# 如果再调用 next(it) 直到没数据，程序会报错 StopIteration
# 2 迭代器对象可以使用常规for语句进行遍历：
my_tuples = (1, 2, 3, 4)
my_iterator = iter(my_tuples)    # 创建迭代器对象
for x in my_iterator:
    print (x, end=" ")

'''
跟普通函数不同的是，生成器是一个返回迭代器的函数，只能用于迭代操作，更简单点理解生成器就是一个迭代器。
当在生成器函数中使用 yield 语句时，函数的执行将会暂停，并将 yield 后面的表达式作为当前迭代的值返回。
然后，每次调用生成器的 next() 方法或使用 for 循环进行迭代时，函数会从上次暂停的地方继续执行，
直到再次遇到 yield 语句。这样，生成器函数可以逐步产生值，而不需要一次性计算并返回所有结果。
调用一个生成器函数，返回的是一个迭代器对象。
'''
def countdown(n):
    """
    countdown 函数是一个生成器函数。它使用 yield 语句逐步产生从 n 到 1 的倒数数字。
    在每次调用 yield 语句时，函数会返回当前的倒数值，并在下一次调用时从上次暂停的地方继续执行。
    通过创建生成器对象并使用 next() 函数或 for 循环迭代生成器，我们可以逐步获取生成器函数产生的值。
    在这个例子中，我们首先使用 next() 函数获取前三个倒数值，然后通过 for 循环获取剩下的两个倒数值。
    生成器函数的优势是它们可以按需生成值，避免一次性生成大量数据并占用大量内存。
    :param n:
    :return:
    """
    while n > 0:
        yield n
        n -= 1
# 创建生成器对象
generator = countdown(5)
print(type(generator))
# 通过迭代生成器获取值
print(next(generator))  # 输出: 5
print(next(generator))  # 输出: 4
print(next(generator))  # 输出: 3
# 使用 for 循环迭代生成器
for value in generator:
    print(value)  # 输出: 2 1
# 生成器表达式（Generator Expression）
gen = (x * 2 for x in range(3))
print(type(gen))      # <class 'generator'>
print(list(gen))      # [0, 2, 4]

'''
推导式(comprehension) VS  生成器（generator）
'''
# 1 基本用法
# 列表推导式 - 立即创建完整列表
list_comp = [x * 2 for x in range(5)]
print("列表推导式:", list_comp)  # [0, 2, 4, 6, 8]
print("类型:", type(list_comp))  # <class 'list'>
# 元组推导式(生成器表达式)，先生成器表达式 - 创建生成器对象
gen_expr = (x * 2 for x in range(5))
print("生成器表达式:", gen_expr)  # <generator object <genexpr> at 0x...>
# 生成器(generator)是一个返回迭代器(Iterator)的函数，只能用于迭代操作，更简单点理解生成器就是一个迭代器。
print(next(gen_expr))
print(next(gen_expr))
print(next(gen_expr))
print(next(gen_expr))
print(next(gen_expr))
# print(next(gen_expr)) # 超过了下表会如何?StopIteration
print("类型:", type(gen_expr))   # <class 'generator'>
print("元组推导式(生成器表达式):", tuple(gen_expr))  # (0, 2, 4, 6, 8) 如果前面next()迭代过了为空
print()
print()
# 2 内存占用对比
import sys
CONST_1w = 10000
# 列表推导式 - 占用较多内存
large_list = [x for x in range(100 * CONST_1w)]
print("列表内存占用:", sys.getsizeof(large_list), "bytes")  # 约 8-9MB
# 元组推导式(生成器表达式) - 占用很少内存
large_gen = (x for x in range(100 * CONST_1w))
print("生成器内存占用:", sys.getsizeof(large_gen), "bytes")  # 约 100-200 bytes
print()
print()
# 3 执行时机对比
def expensive_operation(x):
    print(f"计算 {x} 的平方...")
    return x * x
print("=== 列表推导式（立即执行）===")
squares_list = [expensive_operation(x) for x in range(3)]
# 会立即打印所有"计算..."消息
print("=== 元组推导式(生成器表达式)（惰性执行）===")
squares_gen = (expensive_operation(x) for x in range(3))
# 此时不会打印任何东西
print("元组推导式(生成器表达式):")
print(next(squares_gen))
print(next(squares_gen))
print(next(squares_gen))
for result in squares_gen:
    print("----->结果:", result)
#只有在迭代时才会执行计算
# 4 可重用性对比
# 列表推导式 - 可重用
numbers_list = [1, 2, 3, 4, 5]
squared_list = [x*x for x in numbers_list]
print("列表推导式第一次遍历:")
for num in squared_list:
    print(num)  # 1, 4, 9, 16, 25
print("列表推导式第二次遍历:")
for num in squared_list:
    print(num)  # 可以再次遍历
# 生成器表达式 - 通常一次性
squared_gen = (x*x for x in numbers_list)
print("元组推导式(生成器表达式)第一次遍历:")
for num in squared_gen:
    print(num)  # 1, 4, 9, 16, 25
print("元组推导式(生成器表达式)第二次遍历:")
for num in squared_gen:
    print(num)  # 不会输出任何内容（生成器已耗尽）