# 慢速版本
def find_in_list(items, targets):
    result = []
    for target in targets:
        if target in items:  # O(n) 查找
            result.append(target)
    return result

# 快速版本
def find_in_set(items, targets):
    items_set = set(items)  # 一次性轉(zhuǎn)換
    result = []
    for target in targets:
        if target in items_set:  # O(1) 查找
            result.append(target)
    return result

# 慢速版本
def get_discount(level):
    if level == 'bronze':
        return 0.05
    elif level == 'silver':
        return 0.10
    elif level == 'gold':
        return 0.15
    elif level == 'platinum':
        return 0.20
    else:
        return 0

# 快速版本
def get_discount(level):
    discounts = {
        'bronze': 0.05,
        'silver': 0.10,
        'gold': 0.15,
        'platinum': 0.20
    }
    return discounts.get(level, 0)

# 慢速版本
numbers = range(1000000)
result = []
for num in numbers:
    result.append(num * 2)

# 快速版本
numbers = range(1000000)
result = list(map(lambda x: x * 2, numbers))

# 更快：列表推導(dǎo)式
result = [num * 2 for num in numbers]

from collections import Counter, defaultdict, deque

# 統(tǒng)計(jì)元素出現(xiàn)次數(shù)
words = ['apple', 'banana', 'apple', 'orange', 'banana', 'apple']
# 快速統(tǒng)計(jì)
count = Counter(words)

# 使用defaultdict避免鍵檢查
word_positions = defaultdict(list)
for i, word in enumerate(words):
    word_positions[word].append(i)

# 使用deque實(shí)現(xiàn)高效的隊(duì)列操作
queue = deque()
queue.append(1)  # O(1)
queue.popleft()  # O(1)，list.pop(0)是O(n)

from functools import lru_cache

# 慢速版本：重復(fù)計(jì)算
def fibonacci(n):
    if n < 2:
        return n
    return fibonacci(n-1) + fibonacci(n-2)

# 快速版本：使用緩存
@lru_cache(maxsize=None)
def fibonacci_cached(n):
    if n < 2:
        return n
    return fibonacci_cached(n-1) + fibonacci_cached(n-2)

# fibonacci(35) 可能需要幾秒
# fibonacci_cached(35) 幾乎瞬間完成

# 慢速版本：一次性創(chuàng)建所有數(shù)據(jù)
def process_large_file(filename):
    with open(filename) as f:
        lines = f.readlines()  # 一次性讀入內(nèi)存
        return [line.strip().upper() for line in lines]

# 快速版本：使用生成器
def process_large_file_lazy(filename):
    with open(filename) as f:
        for line in f:  # 逐行處理
            yield line.strip().upper()

# 使用
for processed_line in process_large_file_lazy('huge_file.txt'):
    # 處理每一行，內(nèi)存占用小
    pass

# 慢速版本：使用+拼接
def join_strings_slow(strings):
    result = ""
    for s in strings:
        result += s  # 每次創(chuàng)建新字符串對象
    return result

# 快速版本：使用join
def join_strings_fast(strings):
    return "".join(strings)

# 性能對比：處理10000個(gè)字符串
# 慢速版本：約0.5秒
# 快速版本：約0.001秒（快500倍）

import math

# 慢速版本
def calculate_slow(numbers):
    result = []
    for num in numbers:
        result.append(math.sqrt(num))  # 每次都要查找math.sqrt
    return result

# 快速版本
def calculate_fast(numbers):
    sqrt = math.sqrt  # 局部變量查找更快
    result = []
    for num in numbers:
        result.append(sqrt(num))
    return result

# 更快：列表推導(dǎo)式
def calculate_fastest(numbers):
    sqrt = math.sqrt
    return [sqrt(num) for num in numbers]

items = ['a', 'b', 'c', 'd']

# 慢速版本
for i in range(len(items)):
    print(i, items[i])

# 快速版本
for i, item in enumerate(items):
    print(i, item)

from concurrent.futures import ProcessPoolExecutor, ThreadPoolExecutor
import time

# CPU密集型任務(wù)示例
def cpu_bound_task(n):
    return sum(i * i for i in range(n))

# 使用多進(jìn)程
def process_with_multiprocessing(numbers):
    with ProcessPoolExecutor() as executor:
        results = list(executor.map(cpu_bound_task, numbers))
    return results

# IO密集型任務(wù)使用多線程
import requests

def download_url(url):
    response = requests.get(url)
    return len(response.content)

def download_parallel(urls):
    with ThreadPoolExecutor(max_workers=10) as executor:
        results = list(executor.map(download_url, urls))
    return results

import numpy as np

# 慢速版本：純Python
def sum_of_squares_python(n):
    return sum(i**2 for i in range(n))

# 快速版本：NumPy
def sum_of_squares_numpy(n):
    arr = np.arange(n)
    return np.sum(arr**2)

# 性能對比（n=1000000）
# Python版本：約0.5秒
# NumPy版本：約0.01秒（快50倍）

import cProfile
import pstats

# 使用cProfile分析
def my_function():
    # 你的代碼
    pass

profiler = cProfile.Profile()
profiler.enable()
my_function()
profiler.disable()

stats = pstats.Stats(profiler)
stats.sort_stats('cumulative')
stats.print_stats(10)  # 顯示最慢的10個(gè)函數(shù)

# 使用line_profiler進(jìn)行行級分析
# pip install line_profiler
# 在函數(shù)前添加@profile裝飾器
# 運(yùn)行：kernprof -l -v script.py

GLOBAL_LIST = list(range(10000))

# 慢速版本
def process_global():
    result = 0
    for item in GLOBAL_LIST:
        result += item
    return result

# 快速版本
def process_local():
    local_list = GLOBAL_LIST  # 創(chuàng)建局部引用
    result = 0
    for item in local_list:
        result += item
    return result

# 普通類
class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

# 優(yōu)化類
class PointOptimized:
    __slots__ = ['x', 'y']
    
    def __init__(self, x, y):
        self.x = x
        self.y = y

# 創(chuàng)建100萬個(gè)實(shí)例
# 普通類：約300MB內(nèi)存
# 優(yōu)化類：約150MB內(nèi)存（節(jié)省50%）