python-fundamentals-313

快速参考

功能	版本	语法
自由线程	3.13t	python3.13t script.py
JIT 编译器	3.13	PYTHON_JIT=1 python3.13 script.py
模式匹配	3.10+	match x: case {...}:
海象运算符	3.8+	if (n := len(x)) > 10:
类型参数	3.12+	def first[T](items: list[T]) -> T:
类型别名	3.12+	type Point = tuple[float, float]

结构	代码	用例
异常组	ExceptionGroup("msg", [e1, e2])	多个错误
except*	except* ValueError as eg:	处理异常组
@dataclass(slots=True)	内存高效	大量对象
StrEnum	class Status(StrEnum):	字符串枚举，3.11+

何时使用此技能

适用于 Python 3.13+ 基础知识：

• 学习 Python 3.13 的新特性（自由线程、JIT）
• 使用现代模式匹配语法
• 编写带类型注解的泛型函数
• 创建数据类和枚举
• 了解 Python 命名约定

相关技能：

• 有关类型提示：参见 python-type-hints
• 有关异步：参见 python-asyncio
• 有关常见错误：参见 python-gotchas

---

Python 3.13+ 基础知识

概述

Python 3.13（于 2024 年 10 月发布）带来了显著的性能改进，包括实验性的自由线程（无 GIL）模式、JIT 编译器、更完善的错误消息以及改进后的 REPL。

Python 3.13 新特性

自由线程模式（实验性）

# Python 3.13t - Free-threaded build (GIL disabled)
# Use python3.13t or python3.13t.exe

import threading
import time

def cpu_bound_task(n):
    """CPU-intensive calculation that benefits from true parallelism"""
    total = 0
    for i in range(n):
        total += i * i
    return total

# With free-threading, these actually run in parallel
threads = []
for _ in range(4):
    t = threading.Thread(target=cpu_bound_task, args=(10_000_000,))
    threads.append(t)
    t.start()

for t in threads:
    t.join()

要点：

• 需要单独的可执行文件：python3.13t
• 使用 --disable-gil 选项构建
• 最适合 CPU 密集型多线程工作负载
• 科学计算和数据分析受益最大

JIT 编译器（实验性）

# Enable JIT with environment variable or flag
# PYTHON_JIT=1 python3.13 script.py

# JIT provides 5-15% speedups, up to 30% for computation-heavy tasks
def fibonacci(n: int) -> int:
    """JIT-optimized computation"""
    if n <= 1:
        return n
    a, b = 0, 1
    for _ in range(n - 1):
        a, b = b, a + b
    return b

# Hot loops benefit most from JIT compilation
result = fibonacci(10000)

改进的交互式 REPL

# New REPL features (automatic in Python 3.13):
# - Multiline editing with history preservation
# - Colored prompts and tracebacks (default)
# - F1: Interactive help browsing
# - F2: History browsing (skips output)
# - F3: Paste mode for larger code blocks
# - Direct commands: help, exit, quit (no parentheses needed)

更完善的错误消息

# Python 3.13 provides:
# - Colored tracebacks by default
# - Suggests correct keyword if incorrect one passed
# - Warns when script name shadows stdlib module

# Example: If you name a file "random.py"
# Python now shows: "Note: File '/path/random.py' shadows the 'random' module"

现代 Python 语法

模式匹配（3.10+）

def process_command(command: dict) -> str:
    match command:
        case {"action": "create", "name": str(name)}:
            return f"Creating {name}"
        case {"action": "delete", "id": int(id_)}:
            return f"Deleting item {id_}"
        case {"action": "update", "id": int(id_), "data": dict(data)}:
            return f"Updating {id_} with {data}"
        case {"action": action}:
            return f"Unknown action: {action}"
        case _:
            return "Invalid command format"

# With guards
def categorize_value(value):
    match value:
        case int(n) if n < 0:
            return "negative"
        case int(n) if n == 0:
            return "zero"
        case int(n) if n > 0:
            return "positive"
        case float(f) if f.is_integer():
            return "float-integer"
        case str(s) if len(s) > 10:
            return "long-string"
        case _:
            return "other"

海象运算符（:=）

# Assignment expressions
if (n := len(data)) > 10:
    print(f"Processing {n} items")

# In comprehensions
filtered = [y for x in data if (y := transform(x)) is not None]

# In while loops
while (line := file.readline()):
    process(line)

# Avoid in simple cases - prefer explicit assignment
# Bad: if (x := get_value()) > 0: use(x)
# Good: x = get_value(); if x > 0: use(x)

F 字符串（在 3.12+ 中增强）

# Basic f-strings
name = "World"
print(f"Hello, {name}!")

# Expressions
items = [1, 2, 3]
print(f"Sum: {sum(items)}")

# Format specifiers
value = 123.456789
print(f"{value:.2f}")      # 123.46
print(f"{value:>10.2f}")   # '    123.46'
print(f"{value:_}")        # 123.456789 (underscore separator)

# Debug format (3.8+)
x = 42
print(f"{x=}")             # x=42
print(f"{x=:>5}")          # x=   42

# Nested quotes (3.12+)
data = {"key": "value"}
print(f"Value: {data["key"]}")  # Now allowed!

# Multiline f-strings (3.12+)
result = f"""
    Name: {user.name}
    Email: {user.email}
    Status: {"Active" if user.active else "Inactive"}
"""

类型参数语法（3.12+）

# New generic syntax - no need for TypeVar
def first[T](items: list[T]) -> T:
    return items[0]

# Generic classes
class Stack[T]:
    def __init__(self) -> None:
        self._items: list[T] = []

    def push(self, item: T) -> None:
        self._items.append(item)

    def pop(self) -> T:
        return self._items.pop()

# Type aliases (3.12+)
type Point = tuple[float, float]
type Vector[T] = list[T]

# Multiple type parameters
def merge[K, V](d1: dict[K, V], d2: dict[K, V]) -> dict[K, V]:
    return {**d1, **d2}

# Bounded type parameters
from collections.abc import Comparable

def max_value[T: Comparable](items: list[T]) -> T:
    return max(items)

内存与性能

内存优化

# __slots__ for memory efficiency
class Point:
    __slots__ = ('x', 'y')

    def __init__(self, x: float, y: float):
        self.x = x
        self.y = y

# Generator expressions (lazy evaluation)
# Bad: sum([x * x for x in range(1000000)])  # Creates full list
# Good: sum(x * x for x in range(1000000))   # Generator

# Use itertools for memory efficiency
from itertools import islice, chain, filterfalse

def chunked(iterable, n):
    """Yield successive n-sized chunks."""
    it = iter(iterable)
    while chunk := list(islice(it, n)):
        yield chunk

Python 3.13 内存改进

# 7% smaller memory footprint vs 3.12
# Docstrings have leading indentation stripped
# Modified mimalloc allocator (default if platform supports)

# Check memory usage
import sys

obj = {"key": "value"}
print(sys.getsizeof(obj))

# For deep size calculation
def get_size(obj, seen=None):
    """Recursively calculate object size."""
    size = sys.getsizeof(obj)
    if seen is None:
        seen = set()
    obj_id = id(obj)
    if obj_id in seen:
        return 0
    seen.add(obj_id)
    if isinstance(obj, dict):
        size += sum(get_size(k, seen) + get_size(v, seen) for k, v in obj.items())
    elif hasattr(obj, '__iter__') and not isinstance(obj, (str, bytes)):
        size += sum(get_size(i, seen) for i in obj)
    return size

异常处理

异常组（3.11+）

# Raise multiple exceptions
def validate_data(data: dict):
    errors = []
    if not data.get("name"):
        errors.append(ValueError("name is required"))
    if not data.get("email"):
        errors.append(ValueError("email is required"))
    if not data.get("age") or data["age"] < 0:
        errors.append(ValueError("age must be positive"))

    if errors:
        raise ExceptionGroup("Validation failed", errors)

# Handle with except*
try:
    validate_data({})
except* ValueError as eg:
    for error in eg.exceptions:
        print(f"Validation error: {error}")

# Catch specific exception types
try:
    risky_operation()
except* TypeError as eg:
    handle_type_errors(eg.exceptions)
except* ValueError as eg:
    handle_value_errors(eg.exceptions)

为异常添加备注（3.11+）

try:
    process_data(data)
except ValueError as e:
    e.add_note(f"Processing data: {data[:100]}...")
    e.add_note(f"Timestamp: {datetime.now()}")
    raise

# Notes appear in traceback after exception message

最佳实践

命名约定

# Variables and functions: snake_case
user_name = "john"
def calculate_total(items):
    pass

# Classes: PascalCase
class UserAccount:
    pass

# Constants: SCREAMING_SNAKE_CASE
MAX_CONNECTIONS = 100
DEFAULT_TIMEOUT = 30

# Private: single underscore prefix
class MyClass:
    def __init__(self):
        self._internal_value = 42  # Convention: "private"

    def __private_method(self):  # Name mangling
        pass

# Dunder methods: double underscore
def __init__(self):
    pass

上下文管理器

from contextlib import contextmanager, asynccontextmanager
from typing import Iterator, AsyncIterator

# Class-based context manager
class DatabaseConnection:
    def __init__(self, url: str):
        self.url = url
        self.connection = None

    def __enter__(self):
        self.connection = connect(self.url)
        return self.connection

    def __exit__(self, exc_type, exc_val, exc_tb):
        if self.connection:
            self.connection.close()
        return False  # Don't suppress exceptions

# Generator-based context manager
@contextmanager
def temporary_directory() -> Iterator[str]:
    import tempfile
    import shutil

    path = tempfile.mkdtemp()
    try:
        yield path
    finally:
        shutil.rmtree(path)

# Async context manager
@asynccontextmanager
async def async_session() -> AsyncIterator[Session]:
    session = await create_session()
    try:
        yield session
    finally:
        await session.close()

数据类

from dataclasses import dataclass, field
from typing import Optional

@dataclass
class User:
    name: str
    email: str
    age: int = 0
    tags: list[str] = field(default_factory=list)
    id: Optional[int] = field(default=None, repr=False)

# Frozen (immutable)
@dataclass(frozen=True)
class Point:
    x: float
    y: float

# With slots (memory efficient, 3.10+)
@dataclass(slots=True)
class OptimizedData:
    value: int
    label: str

# Post-init processing
@dataclass
class Rectangle:
    width: float
    height: float
    area: float = field(init=False)

    def __post_init__(self):
        self.area = self.width * self.height

# Comparison and ordering
@dataclass(order=True)
class Priority:
    priority: int
    name: str = field(compare=False)

枚举

from enum import Enum, auto, StrEnum, IntEnum

class Status(Enum):
    PENDING = "pending"
    ACTIVE = "active"
    COMPLETED = "completed"
    CANCELLED = "cancelled"

# With auto values
class Color(Enum):
    RED = auto()
    GREEN = auto()
    BLUE = auto()

# String enum (3.11+)
class HttpMethod(StrEnum):
    GET = auto()
    POST = auto()
    PUT = auto()
    DELETE = auto()

# Integer enum
class Priority(IntEnum):
    LOW = 1
    MEDIUM = 2
    HIGH = 3
    CRITICAL = 4

# Usage
status = Status.ACTIVE
print(status.value)  # "active"
print(status.name)   # "ACTIVE"

# Pattern matching with enums
match status:
    case Status.PENDING:
        print("Waiting...")
    case Status.ACTIVE:
        print("Processing...")
    case Status.COMPLETED | Status.CANCELLED:
        print("Done")