函数

def 函数名(参数列表):
    """文档字符串"""
    函数体
    [return 返回值]

def greet(name):
    """打印问候语"""
    print(f"Hello, {name}!")

greet("Alice")

import inspect

def inner():
    # 获取当前栈帧
    frame = inspect.currentframe()
    print(f"函数名: {frame.f_code.co_name}")       # inner
    print(f"局部变量: {frame.f_locals}")            # {'frame': ...}
    print(f"所在行号: {frame.f_lineno}")             # 当前行号

def outer():
    x = 42
    inner()

outer()

def shout(text):
    return text.upper()

action = shout            # 赋值
callbacks = [shout, len]  # 放入容器

def run(func, value):     # 作为参数
    if not callable(func):
        raise TypeError("必须传入可调用对象")
    return func(value)

print(action("hello"))         # 输出: HELLO
print(run(len, "python"))      # 输出: 6

def add(a, b):
    return a + b

result = add(3, 5)
print(result)  # 输出: 8

def greet(name, message="Hello"):
    print(f"{message}, {name}!")

greet("Bob")          # 输出: Hello, Bob!
greet("Charlie", "Hi") # 输出: Hi, Charlie!

def sum_all(*args):
    total = 0
    for num in args:
        total += num
    return total

print(sum_all(1, 2, 3))      # 输出: 6
print(sum_all(1, 2, 3, 4))   # 输出: 10

def describe_pet(animal_type, pet_name):
    print(f"I have a {animal_type} named {pet_name}.")

describe_pet(pet_name="Whiskers", animal_type="cat")

# 输出：I have a cat named Whiskers.

def display_info(**kwargs):
    for key, value in kwargs.items():
        print(f"{key}: {value}")

display_info(name="Alice", age=30, city="New York")

name: Alice
age: 30
city: New York

def demo(pos_only, /, standard, *, keyword_only):
    print(pos_only, standard, keyword_only)

demo(1, 2, keyword_only=3)   # ✅
demo(pos_only=1, standard=2, keyword_only=3)  # ❌ pos_only 只能位置传递

# 仅关键字参数的典型应用：布尔开关
def connect(host, port=3306, *, ssl=False, timeout=30):
    """连接数据库 —— ssl 和 timeout 必须用关键字传入，避免混淆"""
    print(f"连接 {host}:{port}, ssl={ssl}, timeout={timeout}")

connect("localhost")                    # ✅ 使用默认值
connect("localhost", 5432, ssl=True)    # ✅ ssl 必须写关键字
connect("localhost", 5432, True)        # ❌ TypeError: 位置参数过多

def full_params_demo(
    a, b,           # 1. 普通位置参数：必须传入，可按位置或关键字传
    /,              # 2. / 分隔符：左侧参数只能按位置传
    c, d=10,        # 3. 位置或关键字参数；d 有默认值
    *args,          # 4. 可变位置参数：收集多余位置实参为元组
    e, f=20,        # 5. 仅关键字参数；f 有默认值
    **kwargs        # 6. 可变关键字参数：收集多余关键字实参为字典
):
    """演示 Python 函数参数的所有形式"""
    print(f"a={a}, b={b}")      # 仅位置参数
    print(f"c={c}, d={d}")      # 位置或关键字参数
    print(f"args={args}")       # 多余位置参数 → 元组
    print(f"e={e}, f={f}")      # 仅关键字参数
    print(f"kwargs={kwargs}")   # 多余关键字参数 → 字典

# 调用示例
full_params_demo(
    1, 2,           # a, b —— 只能按位置传
    3,              # c 按位置传，d 使用默认值 10
    4, 5,           # 多余位置参数 → args=(4, 5)
    e=6,            # e 必须按关键字传
    g=7, h=8        # 多余关键字参数 → kwargs={'g': 7, 'h': 8}
)

a=1, b=2
c=3, d=10
args=(4, 5)
e=6, f=20
kwargs={'g': 7, 'h': 8}

def process_data(a, b, c):
    print(f"a: {a}, b: {b}, c: {c}")

# 使用 * 解包列表或元组
data_list = [1, 2, 3]
process_data(*data_list)  # 等价于 process_data(1, 2, 3)

# 使用 ** 解包字典
data_dict = {'a': 10, 'b': 20, 'c': 30}
process_data(**data_dict) # 等价于 process_data(a=10, b=20, c=30)

def mutate(seq, value):
    seq.append(value)

numbers = [1, 2]
mutate(numbers, 3)
print(numbers)  # [1, 2, 3]

def reassign(x):
    x = 99

n = 10
reassign(n)
print(n)        # 10，外部变量未改变

def square(x):
    return x * x

result = square(4)
print(result)  # 输出: 16

def get_coordinates():
    x = 10
    y = 20
    return x, y  # 等同于 return (x, y)

coords = get_coordinates()
print(coords)      # 输出: (10, 20)
print(type(coords)) # 输出: <class 'tuple'>

def check_even(n):
    if n % 2 == 0:
        return True
    else:
        return False

# 或者更简洁的写法
def check_even(n):
    return n % 2 == 0

print(check_even(4))  # 输出: True
print(check_even(5))  # 输出: False

# 演示 LEGB 四层作用域
x = "global x"            # G —— 全局作用域

def outer():
    x = "enclosing x"     # E —— 嵌套作用域（外层函数）
    def inner():
        x = "local x"     # L —— 局部作用域（当前函数）
        print(x)          # 找到 L 层，输出 "local x"
    inner()

outer()

x = "global x"

def outer():
    x = "enclosing x"
    def inner():
        # 没有 L 层的 x，向外查找
        print(x)          # 找到 E 层，输出 "enclosing x"
    inner()

outer()

x = "global x"

def outer():
    # 没有 E 层的 x
    def inner():
        # 没有 L 层的 x
        print(x)          # 找到 G 层，输出 "global x"
    inner()

outer()

# 故意覆盖内置函数名，观察 B 层查找
len = "我覆盖了内置 len"    # G 层覆盖了 B 层
print(len)                   # 输出: 我覆盖了内置 len
print(__builtins__.len([1,2,3]))  # 仍然可以通过 __builtins__ 访问 B 层

del len  # 删除 G 层的覆盖
print(len([1,2,3]))          # 恢复为 B 层，输出: 3

total = 0  # 全局变量

def increment():
    total += 1  # 尝试修改全局变量，会报错
    print(total)

increment()

UnboundLocalError: local variable 'total' referenced before assignment

total = 0

def increment():
    global total
    total += 1
    print(total)

increment()  # 输出: 1
increment()  # 输出: 2

def outer():
    count = 0
    def inner():
        nonlocal count
        count += 1
        print(count)
    return inner

counter = outer()
counter()  # 输出: 1
counter()  # 输出: 2

# LEGB 规则：完整演示
BUILTIN_VAR = len            # B 层：内置作用域（保存内置函数的引用）
global_var = "我是全局变量"    # G 层：全局/模块作用域

def outer_func():
    enclosing_var = "我是嵌套变量"  # E 层：嵌套作用域

    def inner_func():
        local_var = "我是局部变量"  # L 层：局部作用域

        print(local_var)       # 1. L 层：找到
        print(enclosing_var)   # 2. E 层：找到
        print(global_var)      # 3. G 层：找到
        print(BUILTIN_VAR([1, 2, 3]))  # 4. B 层：找到，输出 3

    inner_func()

outer_func()

我是局部变量
我是嵌套变量
我是全局变量
3

lambda 参数列表: 表达式

# 普通函数
def add(a, b):
    return a + b

# Lambda 函数
add_lambda = lambda a, b: a + b

print(add(3, 5))        # 输出: 8
print(add_lambda(3, 5)) # 输出: 8

students = [
    {"name": "Alice", "age": 20},
    {"name": "Bob", "age": 18},
    {"name": "Charlie", "age": 22}
]

# 按年龄排序
students_sorted = sorted(students, key=lambda x: x["age"])
print(students_sorted)

[{'name': 'Bob', 'age': 18}, {'name': 'Alice', 'age': 20}, {'name': 'Charlie', 'age': 22}]

# ✅ 适合 lambda：简短的回调
names = ["Alice", "Bob", "Charlie"]
names.sort(key=lambda n: n.lower())   # 一行搞定

# ❌ 不适合 lambda：逻辑复杂，难以阅读
# 反面教材 —— 虽然语法合法，但可读性极差
# result = filter(lambda x: x.startswith('A') and len(x) > 3 and x.isalpha(), names)

# ✅ 改用 def
def is_valid_name(name):
    """筛选以 A 开头、长度大于 3 且全为字母的名字"""
    return name.startswith('A') and len(name) > 3 and name.isalpha()

result = list(filter(is_valid_name, names))

def factorial(n):
    if n == 0 or n == 1:
        return 1
    else:
        return n * factorial(n - 1)

print(factorial(5))  # 输出: 120

def fibonacci(n):
    if n <= 0:
        return []
    elif n == 1:
        return [0]
    elif n == 2:
        return [0, 1]
    else:
        fib_seq = fibonacci(n - 1)
        fib_seq.append(fib_seq[-1] + fib_seq[-2])
        return fib_seq

print(fibonacci(10))  # 输出: [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]

import sys
print(sys.getrecursionlimit())  # 输出: 1000

# 可以调整限制（但不要随意调大，可能导致解释器崩溃）
# sys.setrecursionlimit(5000)

# 普通递归 —— 不是尾递归（返回后还要乘 n）
def factorial(n):
    if n <= 1:
        return 1
    return n * factorial(n - 1)   # 递归返回后还要做乘法

# 尾递归形式 —— 递归调用是最后一步
def factorial_tail(n, acc=1):
    """尾递归阶乘：acc 累积结果"""
    if n <= 1:
        return acc
    return factorial_tail(n - 1, n * acc)  # 直接返回递归结果

print(factorial_tail(5))  # 输出: 120

def factorial_iterative(n):
    """迭代实现阶乘 —— 无栈溢出风险"""
    result = 1
    for i in range(2, n + 1):
        result *= i
    return result

print(factorial_iterative(1000))  # ✅ 正常工作

def read_large_file(file_path):
    """逐行读取文件，返回一个生成器"""
    with open(file_path, 'r', encoding='utf-8') as f:
        for line in f:
            yield line.strip()

# 假设存在一个名为 large.log 的大文件
# for line in read_large_file('large.log'):
#     if 'ERROR' in line:
#         print(line)

# 创建一个斐波那契数列生成器
def fibonacci_generator(n):
    a, b = 0, 1
    count = 0
    while count < n:
        yield a
        a, b = b, a + b
        count += 1

# 迭代生成器对象
fib_gen = fibonacci_generator(10)
for num in fib_gen:
    print(num, end=' ') # 输出: 0 1 1 2 3 5 8 13 21 34

# === 生成器函数：逐步生成数据，节省内存 ===

def countdown(n):
    """倒计时生成器 —— 每次返回一个倒计时数字"""
    print(f"开始倒计时: {n}")    # 第一次 next() 时执行
    while n > 0:
        yield n                  # 暂停，返回当前值
        n -= 1                   # 恢复后执行
    print("倒计时结束!")          # 最后一次 next() 时执行

# 创建生成器对象 —— 函数体尚未执行
gen = countdown(3)
print(type(gen))                 # <class 'generator'>

# 第一次 next()：从头执行到第一个 yield
print(next(gen))                 # 输出: 开始倒计时: 3 \n 3

# 第二次 next()：从上次暂停处恢复
print(next(gen))                 # 输出: 2

# 第三次 next()：继续
print(next(gen))                 # 输出: 1

# 第四次 next()：没有更多 yield，抛出 StopIteration
# print(next(gen))              # StopIteration

# 更常用的方式：用 for 循环自动处理 StopIteration
print("--- for 循环方式 ---")
for num in countdown(3):
    print(num, end=" ")          # 输出: 3 2 1
print()

def sub_gen():
    """子生成器"""
    yield 1
    yield 2

def main_gen():
    """主生成器：委托给子生成器"""
    yield "start"
    yield from sub_gen()        # 等价于: for v in sub_gen(): yield v
    yield "end"

print(list(main_gen()))          # 输出: ['start', 1, 2, 'end']

def outer_function(x):
    def inner_function(y):
        return x + y
    return inner_function

closure = outer_function(10)
print(closure(5))  # 输出: 15

def outer(x):
    def inner(y):
        return x + y
    return inner

fn = outer(42)
print(fn.__closure__)          # (<cell at 0x...: int object at 0x...>,)
print(fn.__closure__[0].cell_contents)  # 42

def make_counter(start=0, step=1):
    """
    创建一个计数器闭包

    参数:
        start: 起始值，默认 0
        step: 每次递增的步长，默认 1
    返回:
        一个可调用的计数器函数
    """
    count = start                    # 外层局部变量，被内层捕获

    def counter():
        nonlocal count               # 声明修改外层变量
        count += step
        return count

    return counter                   # 返回内层函数，形成闭包

# 创建两个独立的计数器，互不干扰
c1 = make_counter()                  # start=0, step=1
c2 = make_counter(start=100, step=10)

print(c1())  # 1
print(c1())  # 2
print(c2())  # 110
print(c2())  # 120
print(c1())  # 3 —— c1 和 c2 完全独立

def config_factory(host, port):
    """
    创建数据库配置闭包 —— 固定 host 和 port，动态指定数据库名

    参数:
        host: 数据库主机地址
        port: 数据库端口
    返回:
        一个接受 db_name 参数的配置生成函数
    """
    def make_dsn(db_name, user="root"):
        # 内层函数捕获了 host 和 port 这两个自由变量
        return f"mysql://{user}@{host}:{port}/{db_name}"

    return make_dsn

# 创建生产环境和测试环境的配置工厂
prod_config = config_factory("db.prod.com", 3306)
test_config = config_factory("db.test.com", 3307)

print(prod_config("users", user="admin"))    # mysql://admin@db.prod.com:3306/users
print(test_config("orders"))                  # mysql://root@db.test.com:3307/orders

# 陷阱：late binding 导致意外结果
def create_multipliers():
    multipliers = []
    for i in range(4):
        multipliers.append(lambda x: x * i)   # i 是自由变量，引用而非值
    return multipliers

funcs = create_multipliers()
print(funcs[0](10))   # 30 —— 期望 0，实际是 3 * 10
print(funcs[1](10))   # 30 —— 期望 10，实际是 3 * 10
print(funcs[2](10))   # 30
print(funcs[3](10))   # 30 —— 所有 lambda 都引用同一个 i

# 原因：循环结束后 i = 3，所有 lambda 调用时才查找 i 的值

def create_multipliers_fixed():
    multipliers = []
    for i in range(4):
        # 默认参数在定义时求值，实现了 early binding（早绑定）
        multipliers.append(lambda x, i=i: x * i)
    return multipliers

funcs = create_multipliers_fixed()
print(funcs[0](10))   # 0  ✅
print(funcs[1](10))   # 10 ✅
print(funcs[2](10))   # 20 ✅
print(funcs[3](10))   # 30 ✅

def my_decorator(func):
    def wrapper(*args, **kwargs):
        print("Before the function is called.")
        result = func(*args, **kwargs)
        print("After the function is called.")
        return result
    return wrapper

@my_decorator
def say_hello(name):
    print(f"Hello, {name}!")

say_hello("Alice")

Before the function is called.
Hello, Alice!
After the function is called.

# 这两种写法完全等价：

# 写法一：使用 @ 语法糖
@my_decorator
def say_hello(name):
    print(f"Hello, {name}!")

# 写法二：手动包装
def say_hello(name):
    print(f"Hello, {name}!")

say_hello = my_decorator(say_hello)

from functools import wraps
import time

def timing(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        start = time.perf_counter()
        result = func(*args, **kwargs)
        duration = time.perf_counter() - start
        print(f"{func.__name__} took {duration:.3f}s")
        return result
    return wrapper

from functools import wraps

def log_calls(func):
    """基础装饰器：记录函数调用信息"""
    @wraps(func)                       # 保留原函数元信息
    def wrapper(*args, **kwargs):
        print(f"[调用] {func.__name__}()")
        print(f"  位置参数: {args}")
        print(f"  关键字参数: {kwargs}")
        result = func(*args, **kwargs)  # 调用原函数
        print(f"[返回] {func.__name__}() -> {result}")
        return result
    return wrapper

@log_calls
def add(a, b):
    """两数相加"""
    return a + b

add(3, 5)
# [调用] add()
#   位置参数: (3, 5)
#   关键字参数: {}
# [返回] add() -> 8

from functools import wraps

def retry(max_attempts=3, delay=1):
    """
    带参数的装饰器：失败时自动重试

    参数:
        max_attempts: 最大重试次数
        delay: 每次重试间隔（秒）
    """
    def decorator(func):               # 外层接收装饰器参数
        @wraps(func)
        def wrapper(*args, **kwargs):   # 内层接收被装饰函数的参数
            for attempt in range(1, max_attempts + 1):
                try:
                    return func(*args, **kwargs)
                except Exception as e:
                    print(f"第 {attempt} 次尝试失败: {e}")
                    if attempt == max_attempts:
                        raise           # 最后一次仍失败，抛出异常
                    import time
                    time.sleep(delay)   # 等待后重试
        return wrapper
    return decorator

@retry(max_attempts=3, delay=0.5)      # 带参数使用
def fetch_data(url):
    """模拟网络请求（可能失败）"""
    import random
    if random.random() < 0.7:           # 70% 概率失败
        raise ConnectionError("连接超时")
    return f"数据来自 {url}"

# fetch_data("https://example.com")    # 可能重试多次后成功或抛出异常

class CountCalls:
    """
    类装饰器：统计函数被调用的次数
    类实现 __call__ 方法即可作为装饰器
    """
    def __init__(self, func):
        self.func = func               # 保存原函数
        self.count = 0                  # 调用计数器
        self.__name__ = func.__name__   # 保留函数名
        self.__doc__ = func.__doc__     # 保留文档字符串

    def __call__(self, *args, **kwargs):
        self.count += 1
        print(f"{self.func.__name__} 已被调用 {self.count} 次")
        return self.func(*args, **kwargs)

@CountCalls
def say_hi(name):
    """打招呼"""
    print(f"Hi, {name}!")

say_hi("Alice")   # say_hi 已被调用 1 次 → Hi, Alice!
say_hi("Bob")     # say_hi 已被调用 2 次 → Hi, Bob!
print(say_hi.count)  # 2

from functools import wraps

# 假设有一个简单的用户系统
CURRENT_USER = {"name": "Alice", "role": "admin"}

def require_role(role):
    """检查用户是否具有特定角色的装饰器"""
    def decorator(func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            if CURRENT_USER.get("role") == role:
                print(f"用户 {CURRENT_USER['name']} 权限校验通过。")
                return func(*args, **kwargs)
            else:
                print(f"权限不足！需要 '{role}' 角色。")
                return None
        return wrapper
    return decorator

@require_role("admin")
def delete_user(user_id):
    """删除用户的敏感操作"""
    print(f"正在删除用户 {user_id}... 操作完成。")

@require_role("editor")
def edit_article(article_id):
    """编辑文章"""
    print(f"正在编辑文章 {article_id}...")

delete_user(101) # 权限足够，会执行
edit_article(202)  # 权限不足，被阻止

from functools import lru_cache
import time

@lru_cache(maxsize=128) # maxsize 定义了缓存的大小
def fibonacci(n):
    """计算斐波那契数（计算密集型）"""
    if n < 2:
        return n
    return fibonacci(n-1) + fibonacci(n-2)

# 第一次调用，会进行计算
start_time = time.perf_counter()
fibonacci(35)
end_time = time.perf_counter()
print(f"第一次计算耗时: {end_time - start_time:.4f} 秒")

# 第二次调用，几乎瞬间完成，因为结果已在缓存中
start_time = time.perf_counter()
fibonacci(35)
end_time = time.perf_counter()
print(f"第二次计算耗时: {end_time - start_time:.4f} 秒")

def repeat(num_times):
    def decorator(func):
        def wrapper(*args, **kwargs):
            for _ in range(num_times):
                result = func(*args, **kwargs)
            return result
        return wrapper
    return decorator

@repeat(num_times=3)
def greet(name):
    print(f"Hello, {name}!")

greet("Bob")

Hello, Bob!
Hello, Bob!
Hello, Bob!

@decorator_a      # 等价于 func = decorator_a(decorator_b(func)
@decorator_b      # 先包装
def func():
    pass

# 执行顺序：decorator_a 的 wrapper → decorator_b 的 wrapper → 原函数

def 函数名(参数: 注解, ...) -> 返回值注解:
    ...

def greet(name: str, age: int) -> str:
    return f"Hello {name}, you are {age} years old."

print(greet("Alice", 30))
# 输出：Hello Alice, you are 30 years old.

print(greet.__annotations__)
# 输出: {'name': <class 'str'>, 'age': <class 'int'>, 'return': <class 'str'>}

from typing import Optional, Union, List, Dict, Callable, Any

# 1. 基本类型注解
def add(a: int, b: int) -> int:
    """两整数相加，返回整数"""
    return a + b

# 2. 可选参数：Optional[T] 等价于 Union[T, None]
def find_user(user_id: int) -> Optional[dict]:
    """查找用户，可能返回 None"""
    users = {1: {"name": "Alice"}, 2: {"name": "Bob"}}
    return users.get(user_id)          # 找不到返回 None

# 3. 联合类型：Union[A, B] 表示可能是 A 或 B
def process(value: Union[int, str]) -> str:
    """接受整数或字符串，统一返回字符串"""
    return str(value)

# 4. 容器类型注解
def analyze(scores: List[float]) -> Dict[str, float]:
    """分析分数列表，返回统计字典"""
    return {
        "avg": sum(scores) / len(scores),
        "max": max(scores),
        "min": min(scores),
    }

# 5. 回调函数类型注解
def apply_transform(
    data: List[int],
    transform: Callable[[int], int]    # 接受 int 参数，返回 int 的函数
) -> List[int]:
    """对列表中每个元素应用变换函数"""
    return [transform(x) for x in data]

# 6. Any 类型：任意类型（尽量少用，会削弱类型检查的作用）
def echo(value: Any) -> Any:
    """原样返回任意值"""
    return value

# 使用示例
print(add(1, 2))                            # 3
print(find_user(1))                          # {'name': 'Alice'}
print(find_user(99))                         # None
print(process(42))                           # '42'
print(analyze([85.5, 90.0, 78.5]))           # {'avg': 84.666..., 'max': 90.0, 'min': 78.5}
print(apply_transform([1, 2, 3], lambda x: x * 2))  # [2, 4, 6]

import inspect

def add(a: int, b: int = 0) -> int:
    return a + b

print(add.__name__)        # 函数名: add
print(add.__defaults__)    # 位置参数默认值: (0,)
print(add.__kwdefaults__)  # 关键字参数默认值: None
print(add.__annotations__) # 注解字典
print(inspect.signature(add))  # (a: int, b: int = 0) -> int

def fetch_user(user_id: int) -> dict:
    """
    根据用户 ID 获取用户信息。

    参数:
        user_id (int): 用户的唯一标识。
    返回:
        dict: 包含用户名和邮箱的字典。
    """
    ...

print(fetch_user.__doc__)
help(fetch_user)

from functools import reduce

# 销售数据记录
sales = [
    {"product": "A", "amount": 120, "quantity": 2},
    {"product": "B", "amount": 80, "quantity": 5},
    {"product": "C", "amount": 200, "quantity": 1},
    {"product": "D", "amount": 150, "quantity": 3},
]

# 1. 过滤高价值订单 (amount > 100)
high_value_sales = filter(lambda sale: sale["amount"] > 100, sales)

# 2. 提取这些订单的金额
amounts = map(lambda sale: sale["amount"], high_value_sales)

# 3. 计算总销售额
total_revenue = reduce(lambda x, y: x + y, amounts, 0) # 初始值设为 0

print(f"高价值订单的总销售额为: {total_revenue}") # 输出: 470

total_revenue_lc = sum([sale["amount"] for sale in sales if sale["amount"] > 100])
print(f"使用列表推导式的总销售额: {total_revenue_lc}") # 输出: 470

from functools import partial

def greet(greeting, name):
    return f"{greeting}, {name}!"

# 创建一个固定问候语的新函数
say_hello = partial(greet, "Hello")

print(say_hello("Alice"))  # 输出: Hello, Alice!
print(say_hello("Bob"))    # 输出: Hello, Bob!

from functools import lru_cache

@lru_cache(maxsize=None)  # maxsize=None 表示缓存大小无限制
def fibonacci(n):
    if n <= 1:
        return n
    return fibonacci(n-1) + fibonacci(n-2)

print(fibonacci(10))  # 输出: 55
print(fibonacci(20))  # 输出: 6765

# 使用 map 和 lambda
numbers = [1, 2, 3, 4]
squared_map = list(map(lambda x: x ** 2, numbers))
print(squared_map)  # 输出: [1, 4, 9, 16]

# 使用列表推导式
squared_lc = [x ** 2 for x in numbers]
print(squared_lc)   # 输出: [1, 4, 9, 16]

# 使用 filter 和 lambda
evens_filter = list(filter(lambda x: x % 2 == 0, numbers))
print(evens_filter)  # 输出: [2, 4]

# 使用生成器表达式
evens_gen = (x for x in numbers if x % 2 == 0)
print(list(evens_gen))  # 输出: [2, 4]

# 装饰器方式：自动包裹每次调用
import time
from functools import wraps

def timing(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        start = time.perf_counter()
        result = func(*args, **kwargs)
        print(f"{func.__name__} 耗时: {time.perf_counter() - start:.3f}s")
        return result
    return wrapper

@timing  # 每次调用自动计时
def slow_func():
    time.sleep(0.1)

# 上下文管理器方式：显式控制作用范围
from contextlib import contextmanager

@contextmanager
def timer(label=""):
    start = time.perf_counter()
    yield                                # with 块内的代码在此执行
    print(f"{label} 耗时: {time.perf_counter() - start:.3f}s")

with timer("数据处理"):                   # 只在 with 块内计时
    time.sleep(0.1)

import sys

# 列表推导式：一次性生成所有元素
nums_list = [x * x for x in range(1000000)]
print(f"列表占用内存: {sys.getsizeof(nums_list) / 1024 / 1024:.1f} MB")

# 生成器表达式：按需生成，内存极小
nums_gen = (x * x for x in range(1000000))
print(f"生成器占用内存: {sys.getsizeof(nums_gen)} bytes")

from functools import partial

def multiply(a, b):
    return a * b

double = partial(multiply, b=2)
triple = partial(multiply, b=3)

print(double(5))  # 输出: 10
print(triple(5))  # 输出: 15

def compose(*functions):
    def composed(arg):
        result = arg
        for func in reversed(functions):
            result = func(result)
        return result
    return composed

def add_one(x):
    return x + 1

def double(x):
    return x * 2

composed_func = compose(double, add_one)
print(composed_func(5))  # 输出: 12  ( (5 + 1) * 2 )

def memoize(func):
    cache = {}

    def wrapper(*args):
        if args in cache:
            return cache[args]
        result = func(*args)
        cache[args] = result
        return result
    return wrapper

@memoize
def fibonacci(n):
    if n <= 1:
        return n
    return fibonacci(n-1) + fibonacci(n-2)

print(fibonacci(10))  # 输出: 55

def add(a: int, b: int) -> int:
    return a + b

print(add("1", 2))  # TypeError: can only concatenate str (not "int") to str

print(add(int("1"), 2))  # 输出: 3

def greet():
    print(message)  # NameError: name 'message' is not defined

greet()

def greet():
    message = "Hello!"
    print(message)

greet()  # 输出: Hello!

def greet(message):
    print(message)

greet("Hello!")  # 输出: Hello!

def greet():
print("Hello!")  # IndentationError: expected an indented block

greet()

def greet():
    print("Hello!")

greet()  # 输出: Hello!

def infinite_recursion():
    return infinite_recursion()

infinite_recursion()  # RecursionError: maximum recursion depth exceeded

def countdown(n):
    if n <= 0:
        print("Done!")
    else:
        print(n)
        countdown(n-1)

countdown(5)

5
4
3
2
1
Done!

# ❌ 陷阱：可变默认参数在函数定义时只创建一次
def append_to(element, target=[]):
    target.append(element)
    return target

print(append_to(1))   # [1]
print(append_to(2))   # [1, 2] —— 期望 [2]，实际共享了同一个列表！
print(append_to(3))   # [1, 2, 3] —— 越来越长！

# ✅ 正确做法：用 None 作为哨兵值
def append_to_fixed(element, target=None):
    if target is None:
        target = []                # 每次调用都创建新列表
    target.append(element)
    return target

print(append_to_fixed(1))   # [1]
print(append_to_fixed(2))   # [2] ✅

# ❌ 不用 functools.wraps，元信息丢失
def decorator_bad(func):
    def wrapper(*args, **kwargs):
        return func(*args, **kwargs)
    return wrapper

@decorator_bad
def my_function():
    """这是一个重要的函数"""
    pass

print(my_function.__name__)  # "wrapper" —— 不是 "my_function"！
print(my_function.__doc__)   # None —— docstring 丢了！

# ✅ 使用 functools.wraps 保留元信息
from functools import wraps

def decorator_good(func):
    @wraps(func)                              # 自动复制 __name__, __doc__ 等
    def wrapper(*args, **kwargs):
        return func(*args, **kwargs)
    return wrapper

@decorator_good
def my_function():
    """这是一个重要的函数"""
    pass

print(my_function.__name__)  # "my_function" ✅
print(my_function.__doc__)   # "这是一个重要的函数" ✅

import sys
print(sys.getrecursionlimit())  # 1000

# ❌ 深度递归可能崩溃
def deep_recursion(n):
    if n <= 0:
        return 0
    return 1 + deep_recursion(n - 1)

# deep_recursion(2000)  # RecursionError

# ✅ 改用迭代
def deep_iterative(n):
    result = 0
    for _ in range(n):
        result += 1
    return result

print(deep_iterative(2000))  # 正常工作

# ❌ 误用 1：用 *args 接收本应命名的参数，降低可读性
def create_user(*args):
    # 调用者不知道 args[0] 是名字还是年龄
    name = args[0]
    age = args[1]
    ...

# ✅ 使用命名参数
def create_user(name, age, email):
    ...

# ❌ 误用 2：过度使用 **kwargs 代替合理的参数设计
def process(**kwargs):
    # 调用者不知道该传什么参数
    # IDE 也无法提示
    ...

# ✅ 显式声明参数，仅在真正需要灵活接口时使用 **kwargs
def process(host, port, *, timeout=30, **extra_config):
    ...

# ❌ 误用 3：在 *args 上依赖索引顺序
def calculate(*args):
    return args[0] * args[1] + args[2]  # 神秘数字

# ✅ 使用命名参数，语义清晰
def calculate(price, quantity, discount):
    return price * quantity + discount

count = 0

def increment():
    count += 1   # ❌ UnboundLocalError: 函数内赋值会创建局部变量

# ✅ 解决方法 1：用 global 声明
def increment_fixed():
    global count
    count += 1

# ✅ 解决方法 2（更好）：将状态封装在类中
class Counter:
    def __init__(self):
        self.count = 0
    def increment(self):
        self.count += 1

# ✅ 解决方法 3（函数式）：使用闭包
def make_counter():
    count = 0
    def increment():
        nonlocal count
        count += 1
        return count
    return increment

print(abs(-5))        # 输出: 5
print(divmod(10, 3))  # 输出: (3, 1)
print(pow(2, 3))      # 输出: 8
print(round(3.14159, 2))  # 输出: 3.14

print(int("10"))      # 输出: 10
print(float("3.14"))  # 输出: 3.14
print(str(100))       # 输出: "100"
print(list((1, 2, 3))) # 输出: [1, 2, 3]

numbers = [1, 2, 3, 4, 5]
print(len(numbers))    # 输出: 5
print(max(numbers))    # 输出: 5
print(min(numbers))    # 输出: 1
print(sum(numbers))    # 输出: 15

for i in range(5):
    print(i)  # 输出: 0 1 2 3 4

gen = (x * x for x in range(5))
print(next(gen))  # 输出: 0
print(next(gen))  # 输出: 1

values = [True, False, True]
print(all(values))  # 输出: False
print(any(values))  # 输出: True

fruits = ['apple', 'banana', 'cherry']
for index, fruit in enumerate(fruits):
    print(f"{index}: {fruit}")
# 输出:
# 0: apple
# 1: banana
# 2: cherry

names = ['Alice', 'Bob', 'Charlie']
ages = [25, 30, 35]
for name, age in zip(names, ages):
    print(f"{name} is {age} years old.")
# 输出:
# Alice is 25 years old.
# Bob is 30 years old.
# Charlie is 35 years old.

from toolz import compose, pipe

def add_one(x):
    return x + 1

def double(x):
    return x * 2

# 使用 compose
composed = compose(double, add_one)
print(composed(5))  # 输出: 12

# 使用 pipe
piped = pipe(add_one, double)
print(piped(5))  # 输出: 12

pip install toolz