Python Development Patterns

Python开发模式

Idiomatic Python patterns and best practices for building robust, efficient, and maintainable applications.

编写健壮、高效且可维护的Python应用的惯用写法与最佳实践。

When to Activate

适用场景

Writing new Python code
Reviewing Python code
Refactoring existing Python code
Designing Python packages/modules

编写新的Python代码
评审Python代码
重构现有Python代码
设计Python包/模块

Core Principles

核心原则

1. Readability Counts

1. 可读性至上

Python prioritizes readability. Code should be obvious and easy to understand.

python

undefined

Python优先考虑可读性。代码应清晰易懂。

python

undefined

Good: Clear and readable

def get_active_users(users: list[User]) -> list[User]: """Return only active users from the provided list.""" return [user for user in users if user.is_active]

Bad: Clever but confusing

def get_active_users(u): return [x for x in u if x.a]

undefined

def get_active_users(u): return [x for x in u if x.a]

undefined

2. Explicit is Better Than Implicit

2. 显式优于隐式

Avoid magic; be clear about what your code does.

python

undefined

避免魔法操作；明确代码的功能。

python

undefined

Good: Explicit configuration

import logging

logging.basicConfig( level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s' )

import logging

logging.basicConfig( level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s' )

Bad: Hidden side effects

import some_module some_module.setup() # What does this do?

undefined

import some_module some_module.setup() # What does this do?

undefined

3. EAFP - Easier to Ask Forgiveness Than Permission

3. EAFP - 求恕优于求许

Python prefers exception handling over checking conditions.

python

undefined

Python更倾向于使用异常处理而非条件检查。

python

undefined

Good: EAFP style

def get_value(dictionary: dict, key: str) -> Any: try: return dictionary[key] except KeyError: return default_value

Bad: LBYL (Look Before You Leap) style

def get_value(dictionary: dict, key: str) -> Any: if key in dictionary: return dictionary[key] else: return default_value

undefined

def get_value(dictionary: dict, key: str) -> Any: if key in dictionary: return dictionary[key] else: return default_value

undefined

Type Hints

类型提示

Basic Type Annotations

基础类型注解

python

from typing import Optional, List, Dict, Any

def process_user(
    user_id: str,
    data: Dict[str, Any],
    active: bool = True
) -> Optional[User]:
    """Process a user and return the updated User or None."""
    if not active:
        return None
    return User(user_id, data)

python

from typing import Optional, List, Dict, Any

def process_user(
    user_id: str,
    data: Dict[str, Any],
    active: bool = True
) -> Optional[User]:
    """Process a user and return the updated User or None."""
    if not active:
        return None
    return User(user_id, data)

Modern Type Hints (Python 3.9+)

现代类型提示（Python 3.9+）

python

undefined

python

undefined

Python 3.9+ - Use built-in types

def process_items(items: list[str]) -> dict[str, int]: return {item: len(item) for item in items}

Python 3.8 and earlier - Use typing module

from typing import List, Dict

def process_items(items: List[str]) -> Dict[str, int]: return {item: len(item) for item in items}

undefined

from typing import List, Dict

def process_items(items: List[str]) -> Dict[str, int]: return {item: len(item) for item in items}

undefined

Type Aliases and TypeVar

类型别名与TypeVar

python

from typing import TypeVar, Union

python

from typing import TypeVar, Union

Type alias for complex types

JSON = Union[dict[str, Any], list[Any], str, int, float, bool, None]

def parse_json(data: str) -> JSON: return json.loads(data)

JSON = Union[dict[str, Any], list[Any], str, int, float, bool, None]

def parse_json(data: str) -> JSON: return json.loads(data)

Generic types

T = TypeVar('T')

def first(items: list[T]) -> T | None: """Return the first item or None if list is empty.""" return items[0] if items else None

undefined

T = TypeVar('T')

def first(items: list[T]) -> T | None: """Return the first item or None if list is empty.""" return items[0] if items else None

undefined

Protocol-Based Duck Typing

基于协议的鸭子类型

python

from typing import Protocol

class Renderable(Protocol):
    def render(self) -> str:
        """Render the object to a string."""

def render_all(items: list[Renderable]) -> str:
    """Render all items that implement the Renderable protocol."""
    return "\n".join(item.render() for item in items)

python

from typing import Protocol

class Renderable(Protocol):
    def render(self) -> str:
        """Render the object to a string."""

def render_all(items: list[Renderable]) -> str:
    """Render all items that implement the Renderable protocol."""
    return "\n".join(item.render() for item in items)

Error Handling Patterns

错误处理模式

Specific Exception Handling

特定异常处理

python

undefined

python

undefined

Good: Catch specific exceptions

def load_config(path: str) -> Config: try: with open(path) as f: return Config.from_json(f.read()) except FileNotFoundError as e: raise ConfigError(f"Config file not found: {path}") from e except json.JSONDecodeError as e: raise ConfigError(f"Invalid JSON in config: {path}") from e

Bad: Bare except

def load_config(path: str) -> Config: try: with open(path) as f: return Config.from_json(f.read()) except: return None # Silent failure!

undefined

def load_config(path: str) -> Config: try: with open(path) as f: return Config.from_json(f.read()) except: return None # Silent failure!

undefined

Exception Chaining

异常链

python

def process_data(data: str) -> Result:
    try:
        parsed = json.loads(data)
    except json.JSONDecodeError as e:
        # Chain exceptions to preserve the traceback
        raise ValueError(f"Failed to parse data: {data}") from e

python

def process_data(data: str) -> Result:
    try:
        parsed = json.loads(data)
    except json.JSONDecodeError as e:
        # Chain exceptions to preserve the traceback
        raise ValueError(f"Failed to parse data: {data}") from e

Custom Exception Hierarchy

自定义异常层级

python

class AppError(Exception):
    """Base exception for all application errors."""
    pass

class ValidationError(AppError):
    """Raised when input validation fails."""
    pass

class NotFoundError(AppError):
    """Raised when a requested resource is not found."""
    pass

python

class AppError(Exception):
    """Base exception for all application errors."""
    pass

class ValidationError(AppError):
    """Raised when input validation fails."""
    pass

class NotFoundError(AppError):
    """Raised when a requested resource is not found."""
    pass

Usage

def get_user(user_id: str) -> User: user = db.find_user(user_id) if not user: raise NotFoundError(f"User not found: {user_id}") return user

undefined

def get_user(user_id: str) -> User: user = db.find_user(user_id) if not user: raise NotFoundError(f"User not found: {user_id}") return user

undefined

Context Managers

上下文管理器

Resource Management

资源管理

python

undefined

python

undefined

Good: Using context managers

def process_file(path: str) -> str: with open(path, 'r') as f: return f.read()

Bad: Manual resource management

def process_file(path: str) -> str: f = open(path, 'r') try: return f.read() finally: f.close()

undefined

def process_file(path: str) -> str: f = open(path, 'r') try: return f.read() finally: f.close()

undefined

Custom Context Managers

自定义上下文管理器

python

from contextlib import contextmanager

@contextmanager
def timer(name: str):
    """Context manager to time a block of code."""
    start = time.perf_counter()
    yield
    elapsed = time.perf_counter() - start
    print(f"{name} took {elapsed:.4f} seconds")

python

from contextlib import contextmanager

@contextmanager
def timer(name: str):
    """Context manager to time a block of code."""
    start = time.perf_counter()
    yield
    elapsed = time.perf_counter() - start
    print(f"{name} took {elapsed:.4f} seconds")

Usage

with timer("data processing"): process_large_dataset()

undefined

with timer("data processing"): process_large_dataset()

undefined

Context Manager Classes

上下文管理器类

python

class DatabaseTransaction:
    def __init__(self, connection):
        self.connection = connection

    def __enter__(self):
        self.connection.begin_transaction()
        return self

    def __exit__(self, exc_type, exc_val, exc_tb):
        if exc_type is None:
            self.connection.commit()
        else:
            self.connection.rollback()
        return False  # Don't suppress exceptions

python

class DatabaseTransaction:
    def __init__(self, connection):
        self.connection = connection

    def __enter__(self):
        self.connection.begin_transaction()
        return self

    def __exit__(self, exc_type, exc_val, exc_tb):
        if exc_type is None:
            self.connection.commit()
        else:
            self.connection.rollback()
        return False  # Don't suppress exceptions

Usage

with DatabaseTransaction(conn): user = conn.create_user(user_data) conn.create_profile(user.id, profile_data)

undefined

with DatabaseTransaction(conn): user = conn.create_user(user_data) conn.create_profile(user.id, profile_data)

undefined

Comprehensions and Generators

推导式与生成器

List Comprehensions

列表推导式

python

undefined

python

undefined

Good: List comprehension for simple transformations

names = [user.name for user in users if user.is_active]

Bad: Manual loop

names = [] for user in users: if user.is_active: names.append(user.name)

Complex comprehensions should be expanded

Bad: Too complex

result = [x * 2 for x in items if x > 0 if x % 2 == 0]

Good: Use a generator function

def filter_and_transform(items: Iterable[int]) -> list[int]: result = [] for x in items: if x > 0 and x % 2 == 0: result.append(x * 2) return result

undefined

def filter_and_transform(items: Iterable[int]) -> list[int]: result = [] for x in items: if x > 0 and x % 2 == 0: result.append(x * 2) return result

undefined

Generator Expressions

生成器表达式

python

undefined

python

undefined

Good: Generator for lazy evaluation

total = sum(x * x for x in range(1_000_000))

Bad: Creates large intermediate list

total = sum([x * x for x in range(1_000_000)])

undefined

total = sum([x * x for x in range(1_000_000)])

undefined

Generator Functions

生成器函数

python

def read_large_file(path: str) -> Iterator[str]:
    """Read a large file line by line."""
    with open(path) as f:
        for line in f:
            yield line.strip()

python

def read_large_file(path: str) -> Iterator[str]:
    """Read a large file line by line."""
    with open(path) as f:
        for line in f:
            yield line.strip()

Usage

for line in read_large_file("huge.txt"): process(line)

undefined

for line in read_large_file("huge.txt"): process(line)

undefined

Data Classes and Named Tuples

数据类与具名元组

Data Classes

数据类

python

from dataclasses import dataclass, field
from datetime import datetime

@dataclass
class User:
    """User entity with automatic __init__, __repr__, and __eq__."""
    id: str
    name: str
    email: str
    created_at: datetime = field(default_factory=datetime.now)
    is_active: bool = True

python

from dataclasses import dataclass, field
from datetime import datetime

@dataclass
class User:
    """User entity with automatic __init__, __repr__, and __eq__."""
    id: str
    name: str
    email: str
    created_at: datetime = field(default_factory=datetime.now)
    is_active: bool = True

Usage

user = User( id="123", name="Alice", email="alice@example.com" )

undefined

user = User( id="123", name="Alice", email="alice@example.com" )

undefined

Data Classes with Validation

带验证的 Data Classes

python

@dataclass
class User:
    email: str
    age: int

    def __post_init__(self):
        # Validate email format
        if "@" not in self.email:
            raise ValueError(f"Invalid email: {self.email}")
        # Validate age range
        if self.age < 0 or self.age > 150:
            raise ValueError(f"Invalid age: {self.age}")

python

@dataclass
class User:
    email: str
    age: int

    def __post_init__(self):
        # Validate email format
        if "@" not in self.email:
            raise ValueError(f"Invalid email: {self.email}")
        # Validate age range
        if self.age < 0 or self.age > 150:
            raise ValueError(f"Invalid age: {self.age}")

Named Tuples

具名元组

python

from typing import NamedTuple

class Point(NamedTuple):
    """Immutable 2D point."""
    x: float
    y: float

    def distance(self, other: 'Point') -> float:
        return ((self.x - other.x) ** 2 + (self.y - other.y) ** 2) ** 0.5

python

from typing import NamedTuple

class Point(NamedTuple):
    """Immutable 2D point."""
    x: float
    y: float

    def distance(self, other: 'Point') -> float:
        return ((self.x - other.x) ** 2 + (self.y - other.y) ** 2) ** 0.5

Usage

p1 = Point(0, 0) p2 = Point(3, 4) print(p1.distance(p2)) # 5.0

undefined

p1 = Point(0, 0) p2 = Point(3, 4) print(p1.distance(p2)) # 5.0

undefined

Decorators

装饰器

Function Decorators

函数装饰器

python

import functools
import time

def timer(func: Callable) -> Callable:
    """Decorator to time function execution."""
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        start = time.perf_counter()
        result = func(*args, **kwargs)
        elapsed = time.perf_counter() - start
        print(f"{func.__name__} took {elapsed:.4f}s")
        return result
    return wrapper

@timer
def slow_function():
    time.sleep(1)

python

import functools
import time

def timer(func: Callable) -> Callable:
    """Decorator to time function execution."""
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        start = time.perf_counter()
        result = func(*args, **kwargs)
        elapsed = time.perf_counter() - start
        print(f"{func.__name__} took {elapsed:.4f}s")
        return result
    return wrapper

@timer
def slow_function():
    time.sleep(1)

slow_function() prints: slow_function took 1.0012s

undefined

undefined

Parameterized Decorators

参数化装饰器

python

def repeat(times: int):
    """Decorator to repeat a function multiple times."""
    def decorator(func: Callable) -> Callable:
        @functools.wraps(func)
        def wrapper(*args, **kwargs):
            results = []
            for _ in range(times):
                results.append(func(*args, **kwargs))
            return results
        return wrapper
    return decorator

@repeat(times=3)
def greet(name: str) -> str:
    return f"Hello, {name}!"

python

def repeat(times: int):
    """Decorator to repeat a function multiple times."""
    def decorator(func: Callable) -> Callable:
        @functools.wraps(func)
        def wrapper(*args, **kwargs):
            results = []
            for _ in range(times):
                results.append(func(*args, **kwargs))
            return results
        return wrapper
    return decorator

@repeat(times=3)
def greet(name: str) -> str:
    return f"Hello, {name}!"

greet("Alice") returns ["Hello, Alice!", "Hello, Alice!", "Hello, Alice!"]

undefined

undefined

Class-Based Decorators

基于类的装饰器

python

class CountCalls:
    """Decorator that counts how many times a function is called."""
    def __init__(self, func: Callable):
        functools.update_wrapper(self, func)
        self.func = func
        self.count = 0

    def __call__(self, *args, **kwargs):
        self.count += 1
        print(f"{self.func.__name__} has been called {self.count} times")
        return self.func(*args, **kwargs)

@CountCalls
def process():
    pass

python

class CountCalls:
    """Decorator that counts how many times a function is called."""
    def __init__(self, func: Callable):
        functools.update_wrapper(self, func)
        self.func = func
        self.count = 0

    def __call__(self, *args, **kwargs):
        self.count += 1
        print(f"{self.func.__name__} has been called {self.count} times")
        return self.func(*args, **kwargs)

@CountCalls
def process():
    pass

Each call to process() prints the call count

undefined

undefined

Concurrency Patterns

并发模式

Threading for I/O-Bound Tasks

I/O密集型任务的多线程

python

import concurrent.futures
import threading

def fetch_url(url: str) -> str:
    """Fetch a URL (I/O-bound operation)."""
    import urllib.request
    with urllib.request.urlopen(url) as response:
        return response.read().decode()

def fetch_all_urls(urls: list[str]) -> dict[str, str]:
    """Fetch multiple URLs concurrently using threads."""
    with concurrent.futures.ThreadPoolExecutor(max_workers=10) as executor:
        future_to_url = {executor.submit(fetch_url, url): url for url in urls}
        results = {}
        for future in concurrent.futures.as_completed(future_to_url):
            url = future_to_url[future]
            try:
                results[url] = future.result()
            except Exception as e:
                results[url] = f"Error: {e}"
    return results

python

import concurrent.futures
import threading

def fetch_url(url: str) -> str:
    """Fetch a URL (I/O-bound operation)."""
    import urllib.request
    with urllib.request.urlopen(url) as response:
        return response.read().decode()

def fetch_all_urls(urls: list[str]) -> dict[str, str]:
    """Fetch multiple URLs concurrently using threads."""
    with concurrent.futures.ThreadPoolExecutor(max_workers=10) as executor:
        future_to_url = {executor.submit(fetch_url, url): url for url in urls}
        results = {}
        for future in concurrent.futures.as_completed(future_to_url):
            url = future_to_url[future]
            try:
                results[url] = future.result()
            except Exception as e:
                results[url] = f"Error: {e}"
    return results

Multiprocessing for CPU-Bound Tasks

CPU密集型任务的多进程

python

def process_data(data: list[int]) -> int:
    """CPU-intensive computation."""
    return sum(x ** 2 for x in data)

def process_all(datasets: list[list[int]]) -> list[int]:
    """Process multiple datasets using multiple processes."""
    with concurrent.futures.ProcessPoolExecutor() as executor:
        results = list(executor.map(process_data, datasets))
    return results

python

def process_data(data: list[int]) -> int:
    """CPU-intensive computation."""
    return sum(x ** 2 for x in data)

def process_all(datasets: list[list[int]]) -> list[int]:
    """Process multiple datasets using multiple processes."""
    with concurrent.futures.ProcessPoolExecutor() as executor:
        results = list(executor.map(process_data, datasets))
    return results

Async/Await for Concurrent I/O

异步I/O的Async/Await

python

import asyncio

async def fetch_async(url: str) -> str:
    """Fetch a URL asynchronously."""
    import aiohttp
    async with aiohttp.ClientSession() as session:
        async with session.get(url) as response:
            return await response.text()

async def fetch_all(urls: list[str]) -> dict[str, str]:
    """Fetch multiple URLs concurrently."""
    tasks = [fetch_async(url) for url in urls]
    results = await asyncio.gather(*tasks, return_exceptions=True)
    return dict(zip(urls, results))

python

import asyncio

async def fetch_async(url: str) -> str:
    """Fetch a URL asynchronously."""
    import aiohttp
    async with aiohttp.ClientSession() as session:
        async with session.get(url) as response:
            return await response.text()

async def fetch_all(urls: list[str]) -> dict[str, str]:
    """Fetch multiple URLs concurrently."""
    tasks = [fetch_async(url) for url in urls]
    results = await asyncio.gather(*tasks, return_exceptions=True)
    return dict(zip(urls, results))

Package Organization

包组织结构

Standard Project Layout

标准项目布局

myproject/
├── src/
│   └── mypackage/
│       ├── __init__.py
│       ├── main.py
│       ├── api/
│       │   ├── __init__.py
│       │   └── routes.py
│       ├── models/
│       │   ├── __init__.py
│       │   └── user.py
│       └── utils/
│           ├── __init__.py
│           └── helpers.py
├── tests/
│   ├── __init__.py
│   ├── conftest.py
│   ├── test_api.py
│   └── test_models.py
├── pyproject.toml
├── README.md
└── .gitignore

myproject/
├── src/
│   └── mypackage/
│       ├── __init__.py
│       ├── main.py
│       ├── api/
│       │   ├── __init__.py
│       │   └── routes.py
│       ├── models/
│       │   ├── __init__.py
│       │   └── user.py
│       └── utils/
│           ├── __init__.py
│           └── helpers.py
├── tests/
│   ├── __init__.py
│   ├── conftest.py
│   ├── test_api.py
│   └── test_models.py
├── pyproject.toml
├── README.md
└── .gitignore

Import Conventions

导入约定

python

undefined

python

undefined

Good: Import order - stdlib, third-party, local

import os import sys from pathlib import Path

import requests from fastapi import FastAPI

from mypackage.models import User from mypackage.utils import format_name

import os import sys from pathlib import Path

import requests from fastapi import FastAPI

from mypackage.models import User from mypackage.utils import format_name

Good: Use isort for automatic import sorting

pip install isort

undefined

undefined

init.py for Package Exports

用于包导出的init.py

python

undefined

python

undefined

mypackage/init.py

"""mypackage - A sample Python package."""

version = "1.0.0"

"""mypackage - A sample Python package."""

version = "1.0.0"

Export main classes/functions at package level

from mypackage.models import User, Post from mypackage.utils import format_name

all = ["User", "Post", "format_name"]

undefined

from mypackage.models import User, Post from mypackage.utils import format_name

all = ["User", "Post", "format_name"]

undefined

Memory and Performance

内存与性能

Using slots for Memory Efficiency

使用slots提升内存效率

python

undefined

python

undefined

Bad: Regular class uses dict (more memory)

class Point: def init(self, x: float, y: float): self.x = x self.y = y

Good: slots reduces memory usage

class Point: slots = ['x', 'y']

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

undefined

class Point: slots = ['x', 'y']

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

undefined

Generator for Large Data

处理大数据的生成器

python

undefined

python

undefined

Bad: Returns full list in memory

def read_lines(path: str) -> list[str]: with open(path) as f: return [line.strip() for line in f]

Good: Yields lines one at a time

def read_lines(path: str) -> Iterator[str]: with open(path) as f: for line in f: yield line.strip()

undefined

def read_lines(path: str) -> Iterator[str]: with open(path) as f: for line in f: yield line.strip()

undefined

Avoid String Concatenation in Loops

避免循环中的字符串拼接

python

undefined

python

undefined

Bad: O(n²) due to string immutability

result = "" for item in items: result += str(item)

Good: O(n) using join

result = "".join(str(item) for item in items)

Good: Using StringIO for building

from io import StringIO

buffer = StringIO() for item in items: buffer.write(str(item)) result = buffer.getvalue()

undefined

from io import StringIO

buffer = StringIO() for item in items: buffer.write(str(item)) result = buffer.getvalue()

undefined

Python Tooling Integration

Python工具集成

Essential Commands

核心命令

bash

undefined

bash

undefined

Code formatting

black . isort .

Linting

ruff check . pylint mypackage/

Type checking

mypy .

Testing

pytest --cov=mypackage --cov-report=html

Security scanning

bandit -r .

Dependency management

pip-audit safety check

undefined

pip-audit safety check

undefined

pyproject.toml Configuration

pyproject.toml配置

toml

[project]
name = "mypackage"
version = "1.0.0"
requires-python = ">=3.9"
dependencies = [
    "requests>=2.31.0",
    "pydantic>=2.0.0",
]

[project.optional-dependencies]
dev = [
    "pytest>=7.4.0",
    "pytest-cov>=4.1.0",
    "black>=23.0.0",
    "ruff>=0.1.0",
    "mypy>=1.5.0",
]

[tool.black]
line-length = 88
target-version = ['py39']

[tool.ruff]
line-length = 88
select = ["E", "F", "I", "N", "W"]

[tool.mypy]
python_version = "3.9"
warn_return_any = true
warn_unused_configs = true
disallow_untyped_defs = true

[tool.pytest.ini_options]
testpaths = ["tests"]
addopts = "--cov=mypackage --cov-report=term-missing"

toml

[project]
name = "mypackage"
version = "1.0.0"
requires-python = ">=3.9"
dependencies = [
    "requests>=2.31.0",
    "pydantic>=2.0.0",
]

[project.optional-dependencies]
dev = [
    "pytest>=7.4.0",
    "pytest-cov>=4.1.0",
    "black>=23.0.0",
    "ruff>=0.1.0",
    "mypy>=1.5.0",
]

[tool.black]
line-length = 88
target-version = ['py39']

[tool.ruff]
line-length = 88
select = ["E", "F", "I", "N", "W"]

[tool.mypy]
python_version = "3.9"
warn_return_any = true
warn_unused_configs = true
disallow_untyped_defs = true

[tool.pytest.ini_options]
testpaths = ["tests"]
addopts = "--cov=mypackage --cov-report=term-missing"

Quick Reference: Python Idioms

速查：Python惯用写法

Idiom	Description
EAFP	Easier to Ask Forgiveness than Permission
Context managers	Use `with` for resource management
List comprehensions	For simple transformations
Generators	For lazy evaluation and large datasets
Type hints	Annotate function signatures
Dataclasses	For data containers with auto-generated methods
`__slots__`	For memory optimization
f-strings	For string formatting (Python 3.6+)
`pathlib.Path`	For path operations (Python 3.4+)
`enumerate`	For index-element pairs in loops

惯用写法	描述
EAFP	求恕优于求许（优先使用异常处理而非条件检查）
上下文管理器	使用 `with` 进行资源管理
列表推导式	用于简单转换
生成器	用于惰性求值与大数据集
类型提示	标注函数签名
数据类	用于自带自动生成方法的数据容器
`__slots__`	用于内存优化
f-strings	用于字符串格式化（Python 3.6+）
`pathlib.Path`	用于路径操作（Python 3.4+）
`enumerate`	用于循环中获取索引-元素对

Anti-Patterns to Avoid

需避免的反模式

python

undefined

python

undefined

Bad: Mutable default arguments

def append_to(item, items=[]): items.append(item) return items

Good: Use None and create new list

def append_to(item, items=None): if items is None: items = [] items.append(item) return items

Bad: Checking type with type()

if type(obj) == list: process(obj)

Good: Use isinstance

if isinstance(obj, list): process(obj)

Bad: Comparing to None with ==

if value == None: process()

Good: Use is

if value is None: process()

Bad: from module import *

from os.path import *

Good: Explicit imports

from os.path import join, exists

Bad: Bare except

try: risky_operation() except: pass

Good: Specific exception

try: risky_operation() except SpecificError as e: logger.error(f"Operation failed: {e}")


__Remember__: Python code should be readable, explicit, and follow the principle of least surprise. When in doubt, prioritize clarity over cleverness.

try: risky_operation() except SpecificError as e: logger.error(f"Operation failed: {e}")


__请记住__：Python代码应具备可读性、显式性，且遵循最小意外原则。如有疑问，优先选择清晰性而非技巧性。

python-patterns

Original

Translation

Python Development Patterns

Python开发模式

When to Activate

适用场景

Core Principles

核心原则

1. Readability Counts

1. 可读性至上

Good: Clear and readable

Good: Clear and readable

Bad: Clever but confusing

Bad: Clever but confusing

2. Explicit is Better Than Implicit

2. 显式优于隐式

Good: Explicit configuration

Good: Explicit configuration

Bad: Hidden side effects

Bad: Hidden side effects

3. EAFP - Easier to Ask Forgiveness Than Permission

3. EAFP - 求恕优于求许

Good: EAFP style

Good: EAFP style

Bad: LBYL (Look Before You Leap) style

Bad: LBYL (Look Before You Leap) style

Type Hints

类型提示

Basic Type Annotations

基础类型注解

Modern Type Hints (Python 3.9+)

现代类型提示（Python 3.9+）

Python 3.9+ - Use built-in types

Python 3.9+ - Use built-in types

Python 3.8 and earlier - Use typing module

Python 3.8 and earlier - Use typing module

Type Aliases and TypeVar

类型别名与TypeVar

Type alias for complex types

Type alias for complex types

Generic types

Generic types

Protocol-Based Duck Typing

基于协议的鸭子类型

Error Handling Patterns

错误处理模式

Specific Exception Handling

特定异常处理

Good: Catch specific exceptions

Good: Catch specific exceptions

Bad: Bare except

Bad: Bare except

Exception Chaining

异常链

Custom Exception Hierarchy

自定义异常层级

Usage

Usage

Context Managers

上下文管理器

Resource Management

资源管理

Good: Using context managers

Good: Using context managers

Bad: Manual resource management

Bad: Manual resource management

Custom Context Managers

自定义上下文管理器

Usage

Usage

Context Manager Classes

上下文管理器类

Usage

Usage

Comprehensions and Generators

推导式与生成器

List Comprehensions

列表推导式

Good: List comprehension for simple transformations

用于包导出的init.py