# ✅ 使用有意义的变量名
user_age = 25
max_retry_count = 3

# ❌ 不清晰的命名
a = 25
x = 3

# ✅ 函数只做一件事
def calculate_total(items: list[dict]) -> float:
    return sum(item["price"] * item["quantity"] for item in items)

# ❌ 函数做了太多事
def process_order(order):
    # 验证 + 计算 + 发邮件 + 记录日志 + ... 全部塞在一起
    ...

# ✅ 使用 Early Return 减少嵌套
def validate_user(user: dict) -> bool:
    if not user.get("name"):
        return False
    if not user.get("email"):
        return False
    if user["age"] < 0:
        return False
    return True

# ❌ 深层嵌套
def validate_user(user: dict) -> bool:
    if user.get("name"):
        if user.get("email"):
            if user["age"] >= 0:
                return True
    return False

# 1. 解包赋值
a, b = b, a
first, *rest = [1, 2, 3, 4]

# 2. 列表推导
squares = [x**2 for x in range(10)]

# 3. 字典推导
inverted = {v: k for k, v in original.items()}

# 4. 生成器表达式
total = sum(x**2 for x in range(1_000_000))

# 5. walrus 运算符（Python 3.8+）
if (n := len(data)) > 10:
    print(f"数据量 {n} 过大")

# 6. 上下文管理器
with open("file.txt") as f:
    content = f.read()

# 7. enumerate 替代手动索引
for i, item in enumerate(items):
    print(f"{i}: {item}")

# 8. zip 并行遍历
for name, score in zip(names, scores):
    print(f"{name}: {score}")

# 9. 使用 get 安全取值
value = my_dict.get("key", "default")

# 10. 使用 setdefault
my_dict.setdefault("key", []).append(value)

# 11. 链式比较
if 0 < x < 100:
    pass

# 12. any/all
if any(word in text for word in keywords):
    pass

if all(x > 0 for x in numbers):
    pass

# ❌ 用 == 比较 None
if x == None: ...

# ✅ 用 is
if x is None: ...

# ❌ 用 type() 检查类型
if type(x) is list: ...

# ✅ 用 isinstance()
if isinstance(x, list): ...

# ❌ 用 len() 检查空容器
if len(my_list) == 0: ...

# ✅ 直接布尔判断
if not my_list: ...

# ❌ 用 try/except 替代条件判断
try:
    value = my_dict["key"]
except KeyError:
    value = default

# ✅ 使用 get()
value = my_dict.get("key", default)

# ❌ 手动实现内置功能
total = 0
for x in items:
    total += x

# ✅ 使用内置函数
total = sum(items)

# ❌ 经典陷阱
def append_to(item, target=[]):
    target.append(item)
    return target

append_to(1)  # [1]
append_to(2)  # [1, 2] ← 共享同一个列表！

# ✅ 正确做法
def append_to(item, target=None):
    if target is None:
        target = []
    target.append(item)
    return target

# ❌ 陷阱
funcs = [lambda: i for i in range(5)]
print([f() for f in funcs])  # [4, 4, 4, 4, 4]

# ✅ 使用默认参数捕获
funcs = [lambda i=i: i for i in range(5)]
print([f() for f in funcs])  # [0, 1, 2, 3, 4]

# ❌ 浮点数比较
0.1 + 0.2 == 0.3  # False

# ✅ 使用 math.isclose
import math
math.isclose(0.1 + 0.2, 0.3)  # True

# ✅ 金融计算用 Decimal
from decimal import Decimal
Decimal("0.1") + Decimal("0.2") == Decimal("0.3")  # True

x = 10

def foo():
    print(x)  # ❌ UnboundLocalError
    x = 20    # 局部赋值导致 x 在整个函数中被当作局部变量

# ✅ 使用 global 或 nonlocal
def foo():
    global x
    print(x)  # 10
    x = 20

# ❌ 链式比较可能出错
x = 5
if 1 < x < 10:  # ✅ 正确
    pass

# ❌ 字符串 join 时注意类型
numbers = [1, 2, 3]
# ",".join(numbers)  # TypeError

# ✅ 需要先转换
",".join(str(n) for n in numbers)  # "1,2,3"

from functools import cache

@cache
def get_config():
    return load_config()

# 或使用类
class Singleton:
    _instance = None

    def __new__(cls, *args, **kwargs):
        if cls._instance is None:
            cls._instance = super().__new__(cls)
        return cls._instance

from typing import Protocol

class Serializer(Protocol):
    def serialize(self, data: dict) -> str: ...

class JSONSerializer:
    def serialize(self, data: dict) -> str:
        import json
        return json.dumps(data)

class YAMLSerializer:
    def serialize(self, data: dict) -> str:
        import yaml
        return yaml.dump(data)

def get_serializer(format: str) -> Serializer:
    serializers = {"json": JSONSerializer, "yaml": YAMLSerializer}
    cls = serializers.get(format)
    if cls is None:
        raise ValueError(f"Unknown format: {format}")
    return cls()

from typing import Callable

def process_data(data: list, strategy: Callable) -> list:
    return [strategy(item) for item in data]

# 不同策略
uppercase = str.upper
lowercase = str.lower
strip = str.strip

words = [" hello ", " WORLD "]
print(process_data(words, uppercase))
print(process_data(words, strip))

from dataclasses import dataclass, field

@dataclass
class EmailService:
    smtp_host: str = "localhost"

    def send(self, to: str, subject: str, body: str) -> None:
        print(f"Sending email to {to}")

@dataclass
class UserService:
    email_service: EmailService = field(default_factory=EmailService)

    def register(self, email: str) -> None:
        # 业务逻辑
        self.email_service.send(email, "Welcome", "Welcome aboard!")

# 测试时注入 Mock
class MockEmailService:
    def send(self, to, subject, body):
        pass

service = UserService(email_service=MockEmailService())

from typing import TypeVar, Generic, Protocol
from collections.abc import Sequence

# 函数签名
def process(items: Sequence[int]) -> list[str]:
    return [str(x) for x in items]

# 泛型
T = TypeVar("T")

def first(items: Sequence[T]) -> T | None:
    return items[0] if items else None

# Protocol（结构化类型）
class Renderable(Protocol):
    def render(self) -> str: ...

def render_all(items: Sequence[Renderable]) -> str:
    return "\n".join(item.render() for item in items)

# TypedDict
from typing import TypedDict

class UserData(TypedDict):
    name: str
    age: int
    email: str | None

from pydantic import BaseModel, Field, field_validator

class CreateUser(BaseModel):
    name: str = Field(..., min_length=1, max_length=100)
    email: str
    age: int = Field(..., ge=0, le=150)

    @field_validator("email")
    @classmethod
    def validate_email(cls, v: str) -> str:
        if "@" not in v:
            raise ValueError("Invalid email")
        return v.lower()

# 自动验证
user = CreateUser(name="Alice", email="alice@example.com", age=30)

def calculate_shipping(
    weight: float,
    distance: float,
    express: bool = False,
) -> float:
    """计算运费。

    根据重量和距离计算运费，支持普通和快递两种方式。

    Args:
        weight: 包裹重量，单位为千克，必须大于 0。
        distance: 运输距离，单位为公里。
        express: 是否使用快递，默认为 False。

    Returns:
        运费金额（元）。

    Raises:
        ValueError: 当重量或距离为非正数时。

    Examples:
        >>> calculate_shipping(1.0, 100)
        10.0
        >>> calculate_shipping(1.0, 100, express=True)
        20.0
    """
    if weight <= 0 or distance <= 0:
        raise ValueError("重量和距离必须为正数")
    rate = 0.1 if not express else 0.2
    return weight * distance * rate

import this