# 低效寫法
data = []
for i in range(1000000):
    data.append(i * 2)

# 高效寫法
data = [i * 2 for i in range(1000000)]  # 列表推導式快30%

# 低效：手動實現(xiàn)字符串連接
result = ""
for s in string_list:
    result += s  # 每次創(chuàng)建新字符串

# 高效：使用str.join()
result = "".join(string_list)  # 快100倍

# 慢：頻繁訪問全局變量
global_var = 10
def func():
    for i in range(1000000):
        val = global_var * i

# 快：使用局部變量
def func_fast():
    local_var = global_var
    for i in range(1000000):
        val = local_var * i  # 快20-30%

# O(n2) → O(n) 優(yōu)化示例
def find_pairs_naive(nums, target):
    """暴力搜索"""
    result = []
    for i in range(len(nums)):
        for j in range(i+1, len(nums)):
            if nums[i] + nums[j] == target:
                result.append((nums[i], nums[j]))
    return result

def find_pairs_optimized(nums, target):
    """哈希表優(yōu)化"""
    seen = set()
    result = []
    for num in nums:
        complement = target - num
        if complement in seen:
            result.append((complement, num))
        seen.add(num)
    return result  # 萬級數(shù)據(jù)快1000倍

# 斐波那契數(shù)列計算優(yōu)化
from functools import lru_cache

@lru_cache(maxsize=None)
def fib(n):
    return n if n < 2 else fib(n-1) + fib(n-2)  # 從O(2^n)降到O(n)

# 低效：立即計算所有結果
def process_all(data):
    return [expensive_compute(x) for x in data]  # 內(nèi)存爆炸風險

# 高效：生成器延遲計算
def process_lazy(data):
    for x in data:
        yield expensive_compute(x)  # 按需計算

# 安裝PyPy
pypy3 -m pip install numpy  # 多數(shù)庫兼容

# 執(zhí)行腳本
pypy3 my_script.py

# cython: language_level=3
def cython_compute(int n):
    cdef int i, total = 0
    for i in range(n):
        total += i
    return total

# setup.py
from setuptools import setup
from Cython.Build import cythonize

setup(ext_modules=cythonize("compute.pyx"))

from multiprocessing import Pool

def process_chunk(chunk):
    return [x**2 for x in chunk]

if __name__ == '__main__':
    data = range(10**7)
    with Pool(4) as p:  # 4個進程
        results = p.map(process_chunk, [data[i::4] for i in range(4)])

import numpy as np

# 慢：Python循環(huán)
def slow_dot(a, b):
    total = 0
    for x, y in zip(a, b):
        total += x * y
    return total

# 快：NumPy向量化
def fast_dot(a, b):
    return np.dot(np.array(a), np.array(b))  # 快100-1000倍

from numba import jit
import random

@jit(nopython=True)  # 脫離Python解釋器
def monte_carlo_pi(n):
    count = 0
    for _ in range(n):
        x = random.random()
        y = random.random()
        if x**2 + y**2 < 1:
            count += 1
    return 4 * count / n  # 比純Python快50-100倍

def compute_naive(n):
    result = 0
    for i in range(n):
        if i % 2 == 0:
            result += i ** 2
        else:
            result -= i ** 0.5
    return result
# 10^6次調(diào)用耗時：3.2秒

@jit(nopython=True)
def compute_optimized(n):
    result = 0.0
    for i in range(n):
        if i % 2 == 0:
            result += i ** 2
        else:
            result -= i ** 0.5
    return result
# 10^6次調(diào)用耗時：0.04秒 (80倍提升)