# 不推薦：使用循環(huán)求和
my_list = list(range(1_000_000))
total = 0
for x in my_list:
    total += x

# 推薦：使用內(nèi)置 sum() 函數(shù)
total_builtin = sum(my_list)

# print(f"循環(huán)求和結(jié)果: {total}")
# print(f"內(nèi)置函數(shù)求和結(jié)果: {total_builtin}")
# # 使用 timeit 對比兩者性能差異會非常明顯

large_list = list(range(1_000_000))
large_set = set(large_list)
element_to_find = 999_999

# 不推薦：在列表中查找
# start_time = time.time()
# found_in_list = element_to_find in large_list
# list_time = time.time() - start_time

# 推薦：在集合中查找
# start_time = time.time()
# found_in_set = element_to_find in large_set
# set_time = time.time() - start_time

# print(f"列表查找耗時: {list_time:.6f} 秒") # 較慢
# print(f"集合查找耗時: {set_time:.6f} 秒") # 非?？?/code>

# 不推薦：使用循環(huán)創(chuàng)建平方列表
squares_loop = []
for i in range(1000):
    squares_loop.append(i * i)

# 推薦：使用列表推導(dǎo)式
squares_comp = [i * i for i in range(1000)]

# 推薦：處理大數(shù)據(jù)時使用生成器表達式 (計算總和)
# squares_gen = (i * i for i in range(1_000_000)) # 不會立即創(chuàng)建大列表
# total_sum = sum(squares_gen) # 按需計算

# print(f"列表推導(dǎo)式結(jié)果 (前10): {squares_comp[:10]}")
# print(f"生成器計算總和: {total_sum}")

my_strings = ['string' + str(i) for i in range(10000)]

# 不推薦：使用 + 循環(huán)拼接
# result_plus = ''
# for s in my_strings:
#     result_plus += s

# 推薦：使用 join 方法
result_join = ''.join(my_strings)

# print(f"Join 方法結(jié)果長度: {len(result_join)}")
# # 使用 timeit 對比兩者性能差異會非常顯著

# 假設(shè)有一個大文件 large_file.txt
def process_large_file(filepath):
    try:
        with open(filepath, 'r') as f:
            for line in f: # 文件對象本身就是迭代器/生成器
                # 每次處理一行，不加載整個文件
                processed_line = line.strip().upper()
                yield processed_line # 使用 yield 返回處理后的行
    except FileNotFoundError:
        print(f"文件 {filepath} 未找到")

# 使用生成器處理文件
# for processed_line in process_large_file('large_file.txt'):
#     print(processed_line) # 每次處理一行

import functools
import time

# 假設(shè)有一個計算成本高的函數(shù) (例如，遞歸斐波那契)
@functools.lru_cache(maxsize=None) # maxsize=None 表示緩存無限大
def fibonacci(n):
    if n < 2:
        return n
    return fibonacci(n-1) + fibonacci(n-2)

# # 對比有無緩存的性能
# start = time.time()
# result_cached = fibonacci(35)
# time_cached = time.time() - start

# # 如果定義一個沒有緩存的 fibonacci_no_cache 函數(shù)
# # start = time.time()
# # result_no_cache = fibonacci_no_cache(35)
# # time_no_cache = time.time() - start

# print(f"帶緩存計算 fib(35) 結(jié)果: {result_cached}, 耗時: {time_cached:.6f} 秒")
# print(f"無緩存計算 fib(35) 結(jié)果: {result_no_cache}, 耗時: {time_no_cache:.6f} 秒") # 會慢很多

# 場景：循環(huán)內(nèi)頻繁調(diào)用簡單函數(shù)
def add_one(x):
    return x + 1

my_list = list(range(1_000_000))
result = []
# 可能稍慢的方式
# for item in my_list:
#     result.append(add_one(item))

# 可能稍快的方式 (內(nèi)聯(lián))
result_inline = []
for item in my_list:
    result_inline.append(item + 1)

# 注意：對于簡單操作，列表推導(dǎo)式通常是最佳選擇
# result_comp = [item + 1 for item in my_list]

import numpy as np

# 假設(shè)有兩個大列表需要逐元素相加
list_a = list(range(1_000_000))
list_b = list(range(1_000_000))

# 不推薦：使用 Python 循環(huán)
# result_loop = [a + b for a, b in zip(list_a, list_b)]

# 推薦：使用 NumPy 向量化操作
array_a = np.array(list_a)
array_b = np.array(list_b)
result_numpy = array_a + array_b # 直接對數(shù)組進行加法

# print(f"NumPy 結(jié)果 (前10): {result_numpy[:10]}")
# # 使用 timeit 對比性能差異會極其顯著