I. Python Typing (类型注解)#

1
# Basic types
2
name: str = "Alice"
3
age: int = 30
4
height: float = 1.75
5
is_student: bool = True
6

7
# Without initial value
8
address: str  # Just type annotation, no value yet
9
address = "123 Main St"  # Later assignment

1
def greet(name: str) -> str:
2
    return f"Hello, {name}!"
3

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

7
def process_data(data: list) -> None:  # None means returns nothing
8
    print(f"Processing {len(data)} items")

1
from typing import List, Tuple, Set, Dict
2

3
# List of strings
4
names: List[str] = ["Alice", "Bob", "Charlie"]
5

6
# Tuple of int and str (fixed length, mixed types)
7
person: Tuple[int, str, bool] = (1, "Alice", True)
8

9
# Set of integers
10
unique_ids: Set[int] = {101, 102, 103}
11

12
# Dictionary with string keys and int values
13
scores: Dict[str, int] = {"Alice": 95, "Bob": 87}

1
from typing import List, Dict, Tuple
2

3
# List of dictionaries
4
users: List[Dict[str, str]] = [
5
    {"name": "Alice", "email": "alice@example.com"},
6
    {"name": "Bob", "email": "bob@example.com"}
7
]
8

9
# Complex nesting
10
matrix: List[List[int]] = [[1, 2, 3], [4, 5, 6]]
11

12
# Tuple with list inside
13
data: Tuple[int, List[str], bool] = (1, ["a", "b", "c"], True)

1
from typing import Optional
2

3
def find_user(user_id: int) -> Optional[str]:
4
    # Returns name or None if not found
5
    users = {1: "Alice", 2: "Bob"}
6
    return users.get(user_id)  # May return None
7

8
# Optional[str] means either str or None
9
result: Optional[str] = find_user(1)  # "Alice"
10
result2: Optional[str] = find_user(99)  # None

1
from typing import Union
2

3
# Function accepts int OR float
4
def square(value: Union[int, float]) -> Union[int, float]:
5
    return value * value
6

7
# Modern syntax (Python 3.10+)
8
def square2(value: int | float) -> int | float:
9
    return value * value
10

11
# Multiple types
12
def process_id(id_value: int | str) -> str:
13
    return f"ID: {id_value}"

1
from typing import Any
2

3
# Use sparingly - defeats type checking!
4
def debug_print(value: Any) -> None:
5
    print(f"Value: {value}, Type: {type(value)}")

1
from typing import TypeVar, List
2

3
T = TypeVar('T')  # Generic type variable
4

5
def first_element(items: List[T]) -> T:
6
    """Returns first element, type preserved"""
7
    return items[0]
8

9
# Works with any list type
10
num = first_element([1, 2, 3])        # num is int
11
text = first_element(["a", "b", "c"]) # text is str
12

13
# Multiple type variables
14
K = TypeVar('K')
15
V = TypeVar('V')
16

17
def get_value(dict: Dict[K, V], key: K, default: V) -> V:
18
    return dict.get(key, default)

1
from typing import Literal
2

3
def set_status(status: Literal["active", "inactive", "pending"]) -> None:
4
    print(f"Status set to {status}")
5

6
set_status("active")   # OK
7
set_status("active")    # OK
8
# set_status("unknown") # Type checker would complain
9

10
# Multiple literal values
11
def move(direction: Literal["north", "south", "east", "west"]) -> None:
12
    pass

1
from typing import Final
2

3
MAX_SIZE: Final[int] = 100
4
PI: Final[float] = 3.14159
5

6
# Type checker would warn against reassignment
7
# MAX_SIZE = 200  # Error!

1
from typing import Dict, List, Optional, Union, TypedDict
2
import json
3

4
class User(TypedDict):
5
    id: int
6
    name: str
7
    email: str
8
    is_active: bool
9

10
class APIResponse(TypedDict):
11
    status: Literal["success", "error"]
12
    data: Optional[List[User]]
13
    message: Optional[str]
14

15
def parse_api_response(json_str: str) -> APIResponse:
16
    data = json.loads(json_str)
17
    return {
18
        "status": data["status"],
19
        "data": data.get("users"),
20
        "message": data.get("message")
21
    }

1
from typing import List, Callable, TypeVar
2

3
T = TypeVar('T')
4
U = TypeVar('U')
5

6
def pipeline(
7
    data: List[T],
8
    *transforms: Callable[[T], U]
9
) -> List[U]:
10
    """Apply multiple transforms to data"""
11
    result: List[U] = []
12
    for item in data:
13
        current = item
14
        for transform in transforms:
15
            current = transform(current)  # type: ignore
16
        result.append(current)  # type: ignore
17
    return result
18

19
# Usage
20
numbers = [1, 2, 3, 4]
21
result = pipeline(
22
    numbers,
23
    lambda x: x * 2,
24
    lambda x: str(x)
25
)  # result is List[str]

1
from typing import Dict, Any, Optional
2
from dataclasses import dataclass
3

4
@dataclass
5
class DatabaseConfig:
6
    host: str
7
    port: int = 5432
8
    username: str
9
    password: str
10
    database: str
11

12
@dataclass
13
class AppConfig:
14
    debug: bool = False
15
    database: DatabaseConfig
16
    allowed_hosts: List[str]
17
    secret_key: Optional[str] = None
18

19
def load_config(config_dict: Dict[str, Any]) -> AppConfig:
20
    db_config = DatabaseConfig(**config_dict["database"])
21
    return AppConfig(
22
        debug=config_dict.get("debug", False),
23
        database=db_config,
24
        allowed_hosts=config_dict["allowed_hosts"],
25
        secret_key=config_dict.get("secret_key")
26
    )

1
# 1. Use type hints for public APIs
2
def calculate_total(prices: List[float]) -> float:
3
    return sum(prices)
4

5
# 2. Use Optional for values that can be None
6
def find_by_id(id: int) -> Optional[User]:
7
    pass
8

9
# 3. Use type aliases for complex types
10
JSON = Dict[str, Any]
11

12
# 4. Use Literal for limited options
13
def set_mode(mode: Literal["read", "write", "append"]) -> None:
14
    pass

1
# 1. Don't overuse Any (defeats purpose)
2
def process(data: Any) -> Any:  # Better to be specific
3

4
# 2. Don't ignore type errors without reason
5
result = func()  # type: ignore  # Add comment explaining why
6

7
# 3. Don't use type hints for everything in simple scripts
8
# For small scripts, they can be overkill