my_list = [1, 2, 3, 4, 5, 6]
# 使用推導(dǎo)式，生成一個新的list帶條件的列表推導(dǎo)式
condition_squares = [x for x in my_list if x % 2 == 0]
print(f"帶條件的列表推導(dǎo)式:{condition_squares}")  # [2, 4, 6]
# 列表推導(dǎo)式（立即計算）
squares_list = [x+3 for x in range(5) if x > 2]
print(squares_list)# [6, 7]
# 基礎(chǔ)的列表推導(dǎo)式
basic_squares = (x**2 for x in range(5))
print(f"基礎(chǔ)的列表推導(dǎo)式2:{tuple(basic_squares)}")  # [0, 1, 4, 9, 16]
# 包含多個循環(huán)的列表推導(dǎo)式
continue1 = [1, 2, 3]
continue2 = ["a", "b", "c"]
tuple_list = [(i, j) for i in continue1 for j in continue2]
print(f"兩個循環(huán)的列表推導(dǎo)式:{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]
# 使用推導(dǎo)式，生成一個新的tuple
condition_squares = (x for x in my_list if x % 2 == 0)
# 返回的是生成器對象  <generator object <genexpr> at 0x0000026A12285220>
print(condition_squares)
print(f"帶條件的需要tuple()進(jìn)行轉(zhuǎn)換的推導(dǎo)式:{tuple(condition_squares)}")

my_list = [1,2,3,4,5,6]
# 使用推導(dǎo)式，生成一個新的tuple
condition_squares = {x for x in my_list if x % 2 == 0}
print(f"帶條件的推導(dǎo)式:{condition_squares}")

my_list = ['Google','Oracle', 'Taobao','Baidu']
#將列表中各字符串值為鍵，各字符串的長度為值，組成鍵值對
newdict = {key:len(key) for key in my_list}
print(f"f鍵值對推導(dǎo)式：{newdict}")

'''
迭代器
迭代是 Python 最強大的功能之一，是訪問集合元素的一種方式。
迭代器是一個可以記住遍歷的位置的對象。
迭代器對象從集合的第一個元素開始訪問，迭代器只能往前不會后退,直到所有的元素被訪問完結(jié)束。
迭代器有兩個基本的方法：iter() 和 next()。
字符串，列表或元組對象都可用于創(chuàng)建迭代器：
'''
# 1 字符串，列表或元組對象都可用于創(chuàng)建迭代器：
my_list = [1, 2, 3, 4]
it = iter(my_list)    # 創(chuàng)建迭代器對象
print (next(it))   # 輸出迭代器的下一個元素
print (next(it))
# 如果再調(diào)用 next(it) 直到?jīng)]數(shù)據(jù)，程序會報錯 StopIteration
# 2 迭代器對象可以使用常規(guī)for語句進(jìn)行遍歷：
my_tuples = (1, 2, 3, 4)
my_iterator = iter(my_tuples)    # 創(chuàng)建迭代器對象
for x in my_iterator:
    print (x, end=" ")

'''
跟普通函數(shù)不同的是，生成器是一個返回迭代器的函數(shù)，只能用于迭代操作，更簡單點理解生成器就是一個迭代器。
當(dāng)在生成器函數(shù)中使用 yield 語句時，函數(shù)的執(zhí)行將會暫停，并將 yield 后面的表達(dá)式作為當(dāng)前迭代的值返回。
然后，每次調(diào)用生成器的 next() 方法或使用 for 循環(huán)進(jìn)行迭代時，函數(shù)會從上次暫停的地方繼續(xù)執(zhí)行，
直到再次遇到 yield 語句。這樣，生成器函數(shù)可以逐步產(chǎn)生值，而不需要一次性計算并返回所有結(jié)果。
調(diào)用一個生成器函數(shù)，返回的是一個迭代器對象。
'''
def countdown(n):
    """
    countdown 函數(shù)是一個生成器函數(shù)。它使用 yield 語句逐步產(chǎn)生從 n 到 1 的倒數(shù)數(shù)字。
    在每次調(diào)用 yield 語句時，函數(shù)會返回當(dāng)前的倒數(shù)值，并在下一次調(diào)用時從上次暫停的地方繼續(xù)執(zhí)行。
    通過創(chuàng)建生成器對象并使用 next() 函數(shù)或 for 循環(huán)迭代生成器，我們可以逐步獲取生成器函數(shù)產(chǎn)生的值。
    在這個例子中，我們首先使用 next() 函數(shù)獲取前三個倒數(shù)值，然后通過 for 循環(huán)獲取剩下的兩個倒數(shù)值。
    生成器函數(shù)的優(yōu)勢是它們可以按需生成值，避免一次性生成大量數(shù)據(jù)并占用大量內(nèi)存。
    :param n:
    :return:
    """
    while n > 0:
        yield n
        n -= 1
# 創(chuàng)建生成器對象
generator = countdown(5)
print(type(generator))
# 通過迭代生成器獲取值
print(next(generator))  # 輸出: 5
print(next(generator))  # 輸出: 4
print(next(generator))  # 輸出: 3
# 使用 for 循環(huán)迭代生成器
for value in generator:
    print(value)  # 輸出: 2 1
# 生成器表達(dá)式（Generator Expression）
gen = (x * 2 for x in range(3))
print(type(gen))      # <class 'generator'>
print(list(gen))      # [0, 2, 4]

'''
推導(dǎo)式(comprehension) VS  生成器（generator）
'''
# 1 基本用法
# 列表推導(dǎo)式 - 立即創(chuàng)建完整列表
list_comp = [x * 2 for x in range(5)]
print("列表推導(dǎo)式:", list_comp)  # [0, 2, 4, 6, 8]
print("類型:", type(list_comp))  # <class 'list'>
# 元組推導(dǎo)式(生成器表達(dá)式)，先生成器表達(dá)式 - 創(chuàng)建生成器對象
gen_expr = (x * 2 for x in range(5))
print("生成器表達(dá)式:", gen_expr)  # <generator object <genexpr> at 0x...>
# 生成器(generator)是一個返回迭代器(Iterator)的函數(shù)，只能用于迭代操作，更簡單點理解生成器就是一個迭代器。
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("元組推導(dǎo)式(生成器表達(dá)式):", tuple(gen_expr))  # (0, 2, 4, 6, 8) 如果前面next()迭代過了為空
print()
print()
# 2 內(nèi)存占用對比
import sys
CONST_1w = 10000
# 列表推導(dǎo)式 - 占用較多內(nèi)存
large_list = [x for x in range(100 * CONST_1w)]
print("列表內(nèi)存占用:", sys.getsizeof(large_list), "bytes")  # 約 8-9MB
# 元組推導(dǎo)式(生成器表達(dá)式) - 占用很少內(nèi)存
large_gen = (x for x in range(100 * CONST_1w))
print("生成器內(nèi)存占用:", sys.getsizeof(large_gen), "bytes")  # 約 100-200 bytes
print()
print()
# 3 執(zhí)行時機對比
def expensive_operation(x):
    print(f"計算 {x} 的平方...")
    return x * x
print("=== 列表推導(dǎo)式（立即執(zhí)行）===")
squares_list = [expensive_operation(x) for x in range(3)]
# 會立即打印所有"計算..."消息
print("=== 元組推導(dǎo)式(生成器表達(dá)式)（惰性執(zhí)行）===")
squares_gen = (expensive_operation(x) for x in range(3))
# 此時不會打印任何東西
print("元組推導(dǎo)式(生成器表達(dá)式):")
print(next(squares_gen))
print(next(squares_gen))
print(next(squares_gen))
for result in squares_gen:
    print("----->結(jié)果:", result)
#只有在迭代時才會執(zhí)行計算
# 4 可重用性對比
# 列表推導(dǎo)式 - 可重用
numbers_list = [1, 2, 3, 4, 5]
squared_list = [x*x for x in numbers_list]
print("列表推導(dǎo)式第一次遍歷:")
for num in squared_list:
    print(num)  # 1, 4, 9, 16, 25
print("列表推導(dǎo)式第二次遍歷:")
for num in squared_list:
    print(num)  # 可以再次遍歷
# 生成器表達(dá)式 - 通常一次性
squared_gen = (x*x for x in numbers_list)
print("元組推導(dǎo)式(生成器表達(dá)式)第一次遍歷:")
for num in squared_gen:
    print(num)  # 1, 4, 9, 16, 25
print("元組推導(dǎo)式(生成器表達(dá)式)第二次遍歷:")
for num in squared_gen:
    print(num)  # 不會輸出任何內(nèi)容（生成器已耗盡）