1
# 不可变：重新赋值 = 标签换对象
2
a = 10
3
print(id(a))  # 140234866423056
4
a = 20
5
print(id(a))  # 140234866423376 ← 不同的对象
6

7
# 可变：修改 = 原地改对象
8
b = [1, 2, 3]
9
print(id(b))  # 140234851234560
10
b.append(4)
11
print(id(b))  # 140234851234560 ← 同一个对象！

1
fruits = ["apple", "banana", "cherry"]
2

3
# 常用操作
4
fruits.append("date")       # 末尾添加
5
fruits.extend(["fig", "grape"])  # 批量追加（注意和 append 的区别）
6
fruits.insert(1, "avocado") # 指定位置插入
7
fruits.pop()                # 弹出末尾元素
8
fruits.pop(0)               # 弹出指定位置

1
user = {"name": "Alice", "age": 25}
2

3
# 安全取值
4
user.get("email", "未设置")  # 不存在时返回默认值，不会抛 KeyError
5

6
# Python 3.9+ 合并语法
7
defaults = {"theme": "dark", "lang": "zh"}
8
config = defaults | user  # 合并字典，右侧优先

1
# 函数返回多个值本质是返回元组
2
def get_user():
3
    return "Alice", 25, "alice@example.com"
4

5
name, age, email = get_user()  # 解包

1
def example(
2
    name,                  # 必备参数（位置参数）
3
    age=25,                # 默认参数
4
    *args,                 # 可变位置参数 → 打包为元组
5
    **kwargs               # 可变关键字参数 → 打包为字典
6
):
7
    print(f"{name}, {age}")
8
    print(f"额外位置参数: {args}")
9
    print(f"额外关键字参数: {kwargs}")
10

11
example("Alice", 30, "extra1", "extra2", city="Beijing")
12
# Alice, 30
13
# 额外位置参数: ('extra1', 'extra2')
14
# 额外关键字参数: {'city': 'Beijing'}

1
count = 0
2

3
def increment():
4
    global count    # 声明使用全局变量
5
    count += 1
6

7
def outer():
8
    x = 10
9
    def inner():
10
        nonlocal x  # 声明使用外层函数的变量
11
        x += 1
12
    inner()
13
    print(x)  # 11

1
# ✗ 不推荐：命名空间污染，不知道函数来自哪里
2
from os import *
3

4
# ✓ 推荐：明确来源
5
import os
6
os.path.join("/home", "user")
7

8
# ✓ 推荐：只导入需要的
9
from os.path import join, exists

1
nums = [1, 2, 3]
2
it = iter(nums)       # 获取迭代器
3
print(next(it))       # 1
4
print(next(it))       # 2
5
print(next(it))       # 3
6
# next(it)            # StopIteration!

1
def countdown(n):
2
    while n > 0:
3
        yield n    # 产出 n，暂停
4
        n -= 1     # 下次 next() 从这里继续
5

6
gen = countdown(5)
7
print(next(gen))  # 5
8
print(next(gen))  # 4
9

10
for val in gen:   # 继续迭代剩余的
11
    print(val)    # 3, 2, 1

1
from contextlib import contextmanager
2
import time
3

4
@contextmanager
5
def timer(label):
6
    start = time.perf_counter()
7
    yield  # 这里是 with 块内的代码执行点
8
    elapsed = time.perf_counter() - start
9
    print(f"{label}: {elapsed:.4f}s")
10

11
with timer("数据处理"):
12
    data = [x**2 for x in range(1000000)]
13
# 输出: 数据处理: 0.0823s

1
import functools
2

3
def log_calls(func):
4
    @functools.wraps(func)  # 保留原函数的元信息
5
    def wrapper(*args, **kwargs):
6
        print(f"→ 调用 {func.__name__}({args}, {kwargs})")
7
        result = func(*args, **kwargs)
8
        print(f"← {func.__name__} 返回 {result}")
9
        return result
10
    return wrapper
11

12
@log_calls
13
def add(a, b):
14
    """两数相加"""
15
    return a + b
16

17
add(3, 5)
18
# → 调用 add((3, 5), {})
19
# ← add 返回 8

1
import functools
2

3
def retry(max_times=3, delay=1):
4
    """带参数的重试装饰器"""
5
    def decorator(func):
6
        @functools.wraps(func)
7
        def wrapper(*args, **kwargs):
8
            for attempt in range(1, max_times + 1):
9
                try:
10
                    return func(*args, **kwargs)
11
                except Exception as e:
12
                    print(f"第 {attempt} 次失败: {e}")
13
                    if attempt == max_times:
14
                        raise
15
                    time.sleep(delay)
16
        return wrapper
17
    return decorator
18

19
@retry(max_times=3, delay=2)
20
def fetch_data(url):
21
    # 网络请求逻辑...
22
    pass

1
class CallCounter:
2
    def __init__(self, func):
3
        functools.update_wrapper(self, func)
4
        self.func = func
5
        self.count = 0
6

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

12
@CallCounter
13
def process():
14
    pass
15

16
process()  # process 已被调用 1 次
17
process()  # process 已被调用 2 次

1
class User:
2
    """用户类"""
3
    # 类属性：所有实例共享
4
    platform = "MyApp"
5

6
    def __init__(self, name: str, email: str):
7
        # 实例属性：每个实例独立
8
        self.name = name
9
        self.email = email
10
        self._login_count = 0       # 约定私有（单下划线）
11
        self.__password_hash = ""   # 名称改写（双下划线）
12

13
    def login(self):
14
        """普通方法：操作实例状态"""
15
        self._login_count += 1
16
        return f"{self.name} 登录成功（第 {self._login_count} 次）"
17

18
    @property
19
    def login_count(self):
20
        """属性装饰器：像属性一样访问，但有控制逻辑"""
21
        return self._login_count
22

23
    @classmethod
24
    def from_dict(cls, data: dict):
25
        """类方法：备用构造函数"""
26
        return cls(data["name"], data["email"])
27

28
    @staticmethod
29
    def validate_email(email: str) -> bool:
30
        """静态方法：纯工具函数"""
31
        return "@" in email and "." in email

1
class BankAccount:
2
    def __init__(self, balance: float):
3
        self.__balance = balance  # 双下划线保护
4

5
    @property
6
    def balance(self) -> float:
7
        """只读属性"""
8
        return self.__balance
9

10
    def deposit(self, amount: float):
11
        if amount <= 0:
12
            raise ValueError("存款金额必须为正数")
13
        self.__balance += amount
14

15
    def withdraw(self, amount: float):
16
        if amount > self.__balance:
17
            raise ValueError("余额不足")
18
        self.__balance -= amount

1
class Animal:
2
    def __init__(self, name: str):
3
        self.name = name
4

5
    def speak(self) -> str:
6
        raise NotImplementedError("子类必须实现 speak 方法")
7

8
class Dog(Animal):
9
    def speak(self) -> str:
10
        return f"{self.name}: 汪汪！"
11

12
class Cat(Animal):
13
    def speak(self) -> str:
14
        return f"{self.name}: 喵~"
15

16
# 多态：同一接口，不同行为
17
animals = [Dog("旺财"), Cat("咪咪")]
18
for animal in animals:
19
    print(animal.speak())

1
class A:
2
    def greet(self):
3
        return "A"
4

5
class B(A):
6
    def greet(self):
7
        return "B"
8

9
class C(A):
10
    def greet(self):
11
        return "C"
12

13
class D(B, C):
14
    pass
15

16
d = D()
17
print(d.greet())       # "B" — 按 MRO 顺序
18
print(D.__mro__)       # (D, B, C, A, object)

1
class Student(User):
2
    def __init__(self, name: str, email: str, grade: int):
3
        super().__init__(name, email)  # 调用父类构造
4
        self.grade = grade
5

6
    def login(self):
7
        result = super().login()  # 调用父类方法
8
        return f"{result}（学生用户）"

1
class FileLogger:
2
    def write(self, msg):
3
        with open("app.log", "a") as f:
4
            f.write(msg + "\n")
5

6
class ConsoleLogger:
7
    def write(self, msg):
8
        print(f"[LOG] {msg}")
9

10
def log_message(logger, msg):
11
    """不关心 logger 的类型，只要有 write 方法就行"""
12
    logger.write(msg)
13

14
# 两种 logger 都能用，这就是鸭子类型
15
log_message(FileLogger(), "保存到文件")
16
log_message(ConsoleLogger(), "打印到控制台")

1
try:
2
    result = 10 / int(input("输入除数: "))
3
except ValueError:
4
    print("请输入有效的数字")
5
except ZeroDivisionError:
6
    print("除数不能为零")
7
except Exception as e:
8
    print(f"未预期的错误: {e}")
9
else:
10
    # 只在 try 块没有异常时执行
11
    print(f"结果: {result}")
12
finally:
13
    # 无论如何都会执行（资源清理）
14
    print("计算结束")

1
class AppError(Exception):
2
    """应用基础异常"""
3
    pass
4

5
class ValidationError(AppError):
6
    """数据验证异常"""
7
    def __init__(self, field: str, message: str):
8
        self.field = field
9
        self.message = message
10
        super().__init__(f"{field}: {message}")
11

12
class NotFoundError(AppError):
13
    """资源未找到"""
14
    pass
15

16
# 使用
17
def create_user(name: str, age: int):
18
    if not name:
19
        raise ValidationError("name", "用户名不能为空")
20
    if age < 0 or age > 150:
21
        raise ValidationError("age", "年龄必须在 0-150 之间")

1
# 1. 抛出新异常
2
raise ValueError("无效的输入")
3

4
# 2. 重新抛出当前异常（保留原始堆栈）
5
try:
6
    risky_operation()
7
except Exception:
8
    logging.error("操作失败")
9
    raise  # 不带参数，原样抛出
10

11
# 3. 异常链（Python 3）
12
try:
13
    data = json.loads(raw)
14
except json.JSONDecodeError as e:
15
    raise ValidationError("data", "JSON 格式错误") from e