Python

# Python：此未标注示例在运行时抛出类型错误；补充类型标注后可提前静态检查
def add(a, b):
    return a + b

result = add(1, "2")  # 运行时才会报错 TypeError!

// Java：编译时就报错
static int add(int a, int b) { return a + b; }
int result = add(1, "2");  // 编译错误: 类型不匹配

import asyncio
import time

async def io_task(name, delay):
    """模拟 I/O 操作（如网络请求、文件读取）"""
    print(f"[{time.strftime('%X')}] {name} 开始，将等待 {delay} 秒")
    await asyncio.sleep(delay)  # 模拟等待，主动让出控制权给事件循环
    print(f"[{time.strftime('%X')}] {name} 完成")
    return name

async def main():
    # 创建三个独立任务，它们将并发运行
    tasks = [
        io_task("任务A", 2),
        io_task("任务B", 1),
        io_task("任务C", 3)
    ]
    start = time.time()
    results = await asyncio.gather(*tasks)  # 收集所有任务的结果
    print(f"总耗时 {time.time()-start:.2f} 秒，结果：{results}")

# 启动事件循环，运行主协程
asyncio.run(main())

[14:30:01] 任务A 开始，将等待 2 秒
[14:30:01] 任务B 开始，将等待 1 秒
[14:30:01] 任务C 开始，将等待 3 秒
[14:30:02] 任务B 完成
[14:30:03] 任务A 完成
[14:30:04] 任务C 完成
总耗时 3.00 秒，结果：['任务A', '任务B', '任务C']

import asyncio
import aiohttp

async def fetch_http():
    # aiohttp 利用 asyncio 的传输层（Transport）建立 TCP 连接
    async with aiohttp.ClientSession() as session:
        # 这一行 await 触发了 asyncio 的事件循环
        # 当网络数据包没回来时，asyncio 会让 CPU 去执行别的 Task
        async with session.get('https://httpbin.org/get') as resp:
            # 读取响应体（也是 I/O 操作，同样由 asyncio 调度）
            return await resp.text()

async def main():
    # 依然是用 asyncio 的 gather 并发调度 3 个 HTTP 请求
    results = await asyncio.gather(fetch_http(), fetch_http(), fetch_http())
    print(len(results))

asyncio.run(main())

from concurrent.futures import ThreadPoolExecutor
import requests

def io_task(url):
    with requests.get(url, timeout=10) as response:
        return response.status_code

urls = ["https://example.com", "https://httpbin.org/get"]

with ThreadPoolExecutor(max_workers=5) as executor:
    results = list(executor.map(io_task, urls))
    print(results)

from multiprocessing import Process
import os

def task(name):
    print(f"进程 {name} 的 PID: {os.getpid()}")

if __name__ == "__main__":   # 多进程入口保护，跨平台使用时应保留
    p1 = Process(target=task, args=("A",))
    p2 = Process(target=task, args=("B",))
    p1.start()
    p2.start()
    p1.join()
    p2.join()

import asyncio
from concurrent.futures import ProcessPoolExecutor

def cpu_heavy(n: int) -> int:
    # 模拟 CPU 密集型计算，例如大量数学运算
    total = 0
    for i in range(n):
        total += i ** 2
    return total

async def io_work():
    # 模拟大量 I/O 操作，比如网络请求、数据库查询
    await asyncio.sleep(0.1)
    return "io result"

async def main():
    # 创建进程池（建议复用，不要每次都创建）
    with ProcessPoolExecutor(max_workers=2) as pool:
        loop = asyncio.get_running_loop()

        # 同时启动 I/O 任务和 CPU 任务
        io_tasks = [io_work() for _ in range(100)]
        cpu_task = loop.run_in_executor(pool, cpu_heavy, 10_000_000)

        # 并发执行：I/O 任务会正常交错进行，不会因为 CPU 任务而阻塞
        results = await asyncio.gather(cpu_task, *io_tasks)

        cpu_result = results[0]
        print(f"CPU 结果: {cpu_result}")

if __name__ == "__main__":
    asyncio.run(main())

v = "7"
int(v)      # 7
float(v)    # 7.0
bool(v)     # True：非空字符串为真，bool("False") 也为 True
str(v)      # "7"
temperature: str = str(7.5)

score = 70
if score >= 80:
    print("big")
elif score > 65:
    print("mid")
else:
    print("small")

for num in [1, 2, 3, 4, 5]:
    print(num)
for i in range(3):
    print(i)

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

for i, fruit in enumerate(fruits):
    print(i, fruit)
# 输出:
# 0 apple
# 1 banana
# 2 cherry

x > 2 and y == 1
x > 3 or y < 5
not(x > 10 and y > 5)

try:
    print(sum([1,2,3]))
except TypeError:
    print("Error")
finally:
    print("Done")

def calculate_minutes(seconds: int) -> float:
    minutes: float = seconds / 60
    return minutes

add_two = lambda x:  x+2
add_two(5)

# *args：把多余的位置参数 → 打包成元组
def foo(*args):
    print(type(args), args)

foo(1, 2, 3)        # <class 'tuple'> (1, 2, 3)
foo("a", "b")       # <class 'tuple'> ('a', 'b')

# **kwargs：把多余的关键字参数 → 打包成字典
def bar(**kwargs):
    print(type(kwargs), kwargs)

bar(x=1, y=2)       # <class 'dict'> {'x': 1, 'y': 2}
bar(name="Tom")     # <class 'dict'> {'name': 'Tom'}

# *元组 → 展开成位置参数
def add(a, b, c):
    return a + b + c

nums = (1, 2, 3)
add(*nums)           # 等同于 add(1, 2, 3) → 6

# **字典 → 展开成关键字参数
def greet(name, age):
    print(f"{name}, {age}岁")

info = {"name": "小明", "age": 20}
greet(**info)        # 等同于 greet(name="小明", age=20)

# 1. 定义装饰器函数
def my_decorator(func):
    def wrapper():
        print("在原函数之前做点事")
        func()
        print("在原函数之后做点事")
    return wrapper

# 2. 定义原函数
def greet():
    print("你好")

# 3. 手动应用装饰器（这就是 @ 语法糖做的事）
greet = my_decorator(greet)

# 4. 调用
greet()

在原函数之前做点事
你好
在原函数之后做点事

from functools import wraps

def log_decorator(func):
    @wraps(func)  # 保留原函数的名称、文档等元信息
    def wrapper(*args, **kwargs):   # 接收任意参数
        print(f"调用 {func.__name__}，参数：{args}, {kwargs}")
        result = func(*args, **kwargs)
        print(f"返回值：{result}")
        return result
    return wrapper

@log_decorator
def add(a, b):
    return a + b

add(3, 5)

调用 add，参数：(3, 5), {}
返回值：8

class CountCalls:
    def __init__(self, func):
        self.func = func
        self.count = 0

    def __call__(self, *args, **kwargs):
        self.count += 1
        print(f"第 {self.count} 次调用")
        return self.func(*args, **kwargs)

@CountCalls
def hello():
    print("Hello")

hello()
hello()

第 1 次调用
Hello
第 2 次调用
Hello

class MyExampleClass:
    static_field = "static field"
    _static_field = "protected static field"
    __static_field = "private static field"

    def __init__(self, name):
        self.public_field = MyExampleClass.static_field + name
        self.protected_field = MyExampleClass._static_field
        self.__private_field = MyExampleClass.__static_field

    def public_method(self):
        return
    def _protected_method(self):
        return
    def __private_method(self):
        return

    @staticmethod
    def public_static_method(x: int, y: int) -> int:
        return x + y

if __name__ == "__main__":
    obj = MyExampleClass("hi")
    MyExampleClass.public_static_method(1,2)

class MyList:
    def __init__(self, items):
        self._items = items

    def __len__(self):
        print("调用了 __len__")
        return len(self._items)

    def __str__(self):
        print("调用了 __str__")
        return f"MyList({self._items})"

    def __getitem__(self, index):
        return self._items[index]

ml = MyList([1, 2, 3, 4, 5])

# 内置函数 len() 触发 __len__
print(len(ml))          # 输出：调用了 __len__ \n 5

# 内置函数 str() 触发 __str__
print(str(ml))          # 输出：调用了 __str__ \n MyList([1, 2, 3, 4, 5])

# 内置函数 print() 也会触发 __str__
print(ml)               # 同上

# 内置函数 iter() 触发 __iter__（这里没有定义，但 __getitem__ 可作为回退）
for item in ml:
    print(item, end=' ')  # 输出：1 2 3 4 5

class Point:
    def __init__(self, x: int, y: int):
        self.x = x
        self.y = y

    def __repr__(self):
        return f"Point(x={self.x}, y={self.y})"

    def __eq__(self, other):
        if not isinstance(other, Point):
            return False
        return self.x == other.x and self.y == other.y

from dataclasses import dataclass

@dataclass
class Point:
    x: int
    y: int

class Person:
    def __init__(self, name):
        self.name = name

    @classmethod
    def from_dict(cls, data):
        return cls(data["name"])  # cls 会随调用的类变化，适合替代构造方法

person = Person.from_dict({"name": "小明"})
print(person.name)  # 小明

class Circle:
    def __init__(self, radius):
        self.radius = radius  # 初始化也经过 setter 校验

    @property
    def radius(self):
        """只读属性"""
        return self._radius

    @radius.setter
    def radius(self, value):
        """可写属性，带有验证"""
        if value < 0:
            raise ValueError("半径不能为负")
        self._radius = value

    @property
    def area(self):
        """只读计算属性"""
        return 3.14 * self._radius ** 2

c = Circle(5)
print(c.radius)   # 5 —— 不需要写 c.radius()
c.radius = 10     # 使用 setter
print(c.area)     # 314.0 —— 像访问属性一样获得计算结果

from abc import ABC, abstractmethod
class Shape(ABC):
    @abstractmethod
    def area(self):
        pass

    def description(self):    # 普通方法，子类直接继承
        return "这是一个形状"

class Person:
    def __init__(self, name):
        self.name = name

    def print_info(self):
        print(self.name)

class Teacher(Person):
    def __init__(self, name, subject):
        super().__init__(name)
        self.subject = subject

Teacher("小明", "Python").print_info()  # 小明

separator.join(iterable)

# 1. 空分隔符：直接拼接
parts = ["Hello", "World"]
s = "".join(parts)
print(s)  # HelloWorld

my_list = [1,2]

my_list.append(3) # add 现在是[1,2,3]

my_list.remove(2) # remove 现在是[1,3]

item = my_list[1] # get
del my_list[1] # 现在是[1]

my_list = [1,2]
mapped_list = list(map(lambda x: x + 1, my_list)) # map 现在是[2,3]

my_list = [1, 2, 3, 4, 5]
filtered_list = list(filter(lambda x: x%2 != 0, my_list)) # filter 现在是[1, 3, 5]

square = lambda x: x**2
numbers = [1, 2, 3]
result = map(square, numbers)
result_list = list(result)

myFn = lambda x: x > 2
numbers = [1, 2, 3, 4, 5]
result = filter(myFn, numbers)
result_list = list(result)

from pathlib import Path

hits = [Path("README.md"), Path("missing.txt")]
hits.sort(key=lambda p: p.stat().st_mtime if p.exists() else float("-inf"), reverse=True)

# Create a set
my_set = {1, 2}
print(f"Initial set: {my_set}")  # Output: {1, 2}

# Get a value from a set - you cannot directly access elements by index
value = 1
if value in my_set:
    print(f"{value} is in the set")  # Output: 1 is in the set
else:
    print(f"{value} is not in the set")

# Add an item to a set
my_set.add(3)
print(f"Set after adding 3: {my_set}")  # Output: {1, 2, 3}

# Update an item in a set (remove 2 and add 4) - does not support updating
my_set.remove(2)
my_set.add(4)
print(f"Set after updating 2 to 4: {my_set}")  # Output: {1, 3, 4}

# Remove an item from a set，元素不存在抛出 KeyError 异常
my_set.remove(3)
print(f"Set after removing 3: {my_set}")  # Output: {1, 4}

# Discard an item (4) from a set，元素不存在什么都不做
my_set.discard(4)
print(f"Set after discarding 4: {my_set}")  # Output: {1}

set1 = {'Jenny', 26, 'Parker', 'Parker', 10.5}  # use {}, not []
print(set1)  # prints {10.5, 26, 'Jenny', 'Parker'} # 自动去重，输出顺序不保证

# 1. Create a dictionary and assign 2 values [x: 1, y: 2] in one line
my_dict = {'x': 1, 'y': 2}

# 2. Add an item to a dictionary
my_dict['z'] = 3
# my_dict is now {'x': 1, 'y': 2, 'z': 3}

# 3. Get an item from a dictionary
value = my_dict['x']
# value is 1

# 4. Remove an item from a dictionary
del my_dict['y']
# my_dict is now {'x': 1, 'z': 3}

# 5. Get all the keys from a dictionary
keys = list(my_dict.keys())
# keys is ['x', 'z']

# 6. Get all the values from a dictionary
values = list(my_dict.values())
# values is [1, 3]

# 7. map
new_dict = {k: v + 1 for k, v in my_dict.items()} # 字典推导式
new_dict = dict(map(lambda item: (item[0], item[1] + 1), my_dict.items())) # Lambda map function on a dictionary
# new_dict is {'x': 2, 'z': 4}

# 8. Lambda filter function on a dictionary (return entries that are odd numbers)
filtered_dict = {k: v for k, v in my_dict.items() if v % 2 != 0}
# filtered_dict is {'x': 1, 'z': 3}

with open("test.txt", "r") as f:
    content = f.read()
# 离开 with 块后，文件自动关闭

class ManagedFile:
    def __init__(self, filename):
        self.filename = filename

    def __enter__(self):
        self.file = open(self.filename, "r")
        return self.file

    def __exit__(self, exc_type, exc_val, exc_tb):
        self.file.close()
        if exc_type:
            print(f"发生异常: {exc_val}")
        return False   # 返回 False 会向外传播异常

with ManagedFile("test.txt") as f:
    print(f.read())

async with 异步上下文管理器 as 变量:
    # 在上下文中使用变量
    await 做一些事()

import aiohttp
import asyncio

async def fetch():
    async with aiohttp.ClientSession() as session:   # 自动调用 session.__aenter__()
        async with session.get('https://example.com') as resp:  # 自动调用 resp.__aenter__()
            html = await resp.text()
            print(html)
    # 先退出内层 resp，再退出外层 session

asyncio.run(fetch())

import asyncio
from contextlib import AsyncExitStack, asynccontextmanager

@asynccontextmanager
async def open_connection(name):
    print(f"Opening {name}")
    await asyncio.sleep(0.1)   # 模拟异步连接
    conn = {"conn": name}
    try:
        yield conn
    finally:
        await close_connection(conn)

async def close_connection(conn):
    print(f"Closing {conn['conn']}")
    await asyncio.sleep(0.05)  # 模拟异步关闭

class MyAsyncResource:
    async def __aenter__(self):
        print("Entering MyAsyncResource")
        return self
    async def __aexit__(self, exc_type, exc_val, exc_tb):
        print("Exiting MyAsyncResource")
        # 可以处理异常，返回 True 表示异常已处理

async def main():
    async with AsyncExitStack() as stack:
        # 动态添加第一个资源
        conn1 = await stack.enter_async_context(open_connection("db1"))
        # 动态添加第二个资源
        conn2 = await stack.enter_async_context(open_connection("db2"))
        # 添加自定义的异步上下文管理器
        my_res = await stack.enter_async_context(MyAsyncResource())

        # 所有资源都准备好，可以同时使用
        print(f"Using {conn1} and {conn2} and {my_res}")
        # 假如你还需要同步资源，可以用 stack.enter_context(open_sync_file())

    # 离开 async with 块时，会按照 LIFO 顺序自动调用每个资源的 __aexit__
    # 输出: Exiting MyAsyncResource, Closing db2, Closing db1

asyncio.run(main())

import math

# --- 常量和基本运算 ---
math.pi          # 3.141592653589793
math.e           # 2.718281828459045
math.tau         # 6.283185307179586 (2π)
math.inf         # 正无穷
math.nan         # 非数字

math.ceil(3.2)   # 4   — 向上取整
math.floor(3.9)  # 3   — 向下取整
math.trunc(-3.9) # -3  — 截断小数部分（向零取整）
math.fabs(-5)    # 5.0 — 绝对值（返回 float）

# --- 幂、对数、平方根 ---
math.sqrt(16)    # 4.0
math.pow(2, 10)  # 1024.0
math.exp(1)      # e^1 ≈ 2.718
math.log(100, 10)# log₁₀(100) = 2.0
math.log2(8)     # 3.0
math.log10(1000) # 3.0

# --- 三角函数（参数为弧度）---
math.sin(math.pi / 2)   # 1.0
math.cos(0)             # 1.0
math.tan(math.pi / 4)   # 1.0
math.degrees(math.pi)   # 180.0  — 弧度转角度
math.radians(180)       # 3.14159...   — 角度转弧度

# --- 组合数学 ---
math.comb(5, 2)    # 10  — C(5,2)
math.perm(5, 2)    # 20  — P(5,2)
math.factorial(5)  # 120
math.gcd(12, 18)   # 6   — 最大公约数
math.lcm(12, 18)   # 36  — 最小公倍数（3.9+）

import cmath

z = 1 + 2j
cmath.phase(z)      # 1.107... — 辐角（相位角）
cmath.polar(z)      # (2.236, 1.107) — (模, 辐角)
cmath.rect(2, cmath.pi/4)  # 约 (1.414+1.414j) — 极坐标转直角坐标
cmath.sqrt(-1)      # 1j — 复数平方根
cmath.exp(1j * cmath.pi)  # 约 (-1+0j)，浮点计算可能残留极小虚部 — 欧拉公式 e^(iπ) = -1

import random

random.random()           # [0.0, 1.0) 的随机浮点数
random.uniform(10, 20)    # [10, 20] 的随机浮点数
random.randint(1, 100)    # [1, 100] 的随机整数
random.randrange(0, 100, 5)  # 从 [0, 100) 步长为 5 中随机挑一个

# --- 序列操作 ---
items = [1, 2, 3, 4, 5]
random.choice(items)           # 随机挑一个
random.choices(items, k=3)     # 随机挑 3 个（可重复）
random.sample(items, k=3)      # 随机挑 3 个（不重复）
random.shuffle(items)          # 原地打乱

# --- 可复现 ---
random.seed(42)  # 在随机操作前设置；同一实现/版本和调用顺序下用于复现

import time

t = time.time()           # 当前 Unix 时间戳（秒，浮点数）
time.sleep(1.5)           # 休眠 1.5 秒

# --- 性能计时 ---
start = time.perf_counter()
# ... 需要计时的操作 ...
elapsed = time.perf_counter() - start  # 高精度计时，不受系统时间调整影响

# --- 时间字符串 ---
time.ctime()              # 如 'Tue Jul 14 20:00:00 2026'
time.strftime("%Y-%m-%d %H:%M:%S")     # 格式化当前时间
time.strptime("2026-07-14", "%Y-%m-%d")# 解析时间字符串 → struct_time

from datetime import datetime, date, timedelta, timezone

# --- 基本操作 ---
now = datetime.now()                        # 当前本地时间
today = date.today()                        # 当前日期
dt = datetime(2026, 7, 14, 15, 30, 0)      # 手动构造

# --- 格式化与解析 ---
dt.strftime("%Y-%m-%d %H:%M:%S")            # 格式化输出
datetime.strptime("2026-07-14", "%Y-%m-%d") # 字符串解析

# --- timedelta：时间差 ---
delta = timedelta(days=7, hours=3)
future = now + delta                        # 7天3小时后
past = now - timedelta(weeks=2)             # 2周前
diff = future - now                         # timedelta(days=7, hours=3)

# --- 时区（Python 3.9+）---
import zoneinfo
tz_shanghai = zoneinfo.ZoneInfo("Asia/Shanghai")
tz_ny = zoneinfo.ZoneInfo("America/New_York")
now_cn = datetime.now(tz_shanghai)
now_us = datetime.now(tz_ny)

# --- Unix 时间戳转换 ---
ts = now.timestamp()                  # datetime → 时间戳
dt_from_ts = datetime.fromtimestamp(ts)  # 时间戳 → datetime

from collections import Counter, defaultdict, deque, OrderedDict, namedtuple

# --- Counter：计数器 ---
words = ["a", "b", "a", "c", "b", "a"]
c = Counter(words)
# Counter({'a': 3, 'b': 2, 'c': 1})
c.most_common(2)       # [('a', 3), ('b', 2)] — 出现最多的前2个
c["a"]                 # 3
c["z"]                 # 0 — 不存在的键返回 0，不抛 KeyError

# --- defaultdict：带默认值的字典 ---
dd = defaultdict(list)          # 访问不存在的 key 时自动创建空列表
dd["fruits"].append("apple")    # 不需要先判断 key 是否存在
dd = defaultdict(int)           # 默认值 0，天然适合计数
dd["count"] += 1

# --- deque：双端队列（两端插入删除 O(1)）---
dq = deque([1, 2, 3])
dq.append(4)         # 右边加 → [1, 2, 3, 4]
dq.appendleft(0)     # 左边加 → [0, 1, 2, 3, 4]
dq.pop()             # 4
dq.popleft()         # 0
dq.rotate(1)         # 循环右移 1 位

# --- namedtuple：带名字的元组 ---
Point = namedtuple("Point", ["x", "y"])
p = Point(10, 20)
p.x                   # 10 — 用属性访问
p.y                   # 20
p._replace(x=99)      # Point(x=99, y=20) — 返回新对象（不可变）

# --- OrderedDict：有序字典（3.7+ 普通 dict 也有序，但 OrderedDict 支持 reorder）---
od = OrderedDict([("a", 1), ("b", 2)])
od.move_to_end("a")   # 把 "a" 移到末尾
od.popitem(last=False)# ("b", 2) — 从开头弹出

from pathlib import Path

# --- 路径构建与属性 ---
p = Path("/home/user/project/file.txt")
p.name          # "file.txt"
p.stem          # "file"
p.suffix        # ".txt"
p.parent        # Path("/home/user/project")
p.parts         # ("/", "home", "user", "project", "file.txt")
p.anchor        # "/"（Windows 上为 "C:\\"）

# --- 路径变换 ---
p.with_suffix(".md")              # Path("/home/user/project/file.md")
p.with_name("config.json")        # Path("/home/user/project/config.json")
p.with_stem("data")               # Path("/home/user/project/data.txt")
Path("~/data").expanduser()       # 展开 ~ 为用户主目录
Path("a/../b").resolve()          # 解析为绝对路径，消除 . 和 ..

# --- 文件读写（省去 open/close）---
content = Path("file.txt").read_text(encoding="utf-8")
Path("output.txt").write_text("Hello", encoding="utf-8")
binary = Path("img.png").read_bytes()
Path("copy.png").write_bytes(binary)

# --- 目录操作 ---
Path("a/b/c").mkdir(parents=True, exist_ok=True)  # 递归创建目录
list(Path(".").iterdir())             # 列出当前目录所有条目

# --- 文件查找 ---
list(Path("src").glob("*.py"))        # 匹配 src/ 下所有 .py
list(Path("src").rglob("*.py"))       # 递归匹配 src/ 及其子目录下所有 .py

# --- 判断与信息 ---
p.exists()        # 路径是否存在
p.is_file()       # 是否是文件
p.is_dir()        # 是否是目录
p.is_symlink()    # 是否是符号链接
p.stat()          # 文件元信息（大小、修改时间等）

# 传统方式
with open("file.txt", "r", encoding="utf-8") as f:
    data = f.read()

# Path 方式（更简洁）
data = Path("file.txt").read_text(encoding="utf-8")

p.parent.mkdir(parents=True, exist_ok=True)

import platform

platform.system()         # 'Darwin' | 'Linux' | 'Windows'
platform.release()        # 系统版本号，如 '24.0.0' (macOS Sequoia)
platform.machine()        # CPU 架构，如 'arm64' | 'x86_64'
platform.python_version() # Python 版本
platform.node()           # 主机名

import re

# --- 核心函数 ---
re.search(r"\d+", "abc123def")        # 搜索第一个匹配，返回 Match 或 None
re.match(r"\d+", "123abc")            # 从字符串开头匹配
re.findall(r"\d+", "a1b2c3")         # 返回所有匹配的列表: ['1', '2', '3']
re.sub(r"\d+", "X", "a1b2")          # 替换: 'aXbX'
re.split(r"\s+", "a  b\tc")          # 按空白分割: ['a', 'b', 'c']

# --- Match 对象 ---
m = re.search(r"(\d{3})-(\d{4})", "Tel: 010-1234")
if m:
    m.group()     # "010-1234" — 完整匹配
    m.group(1)    # "010"      — 第一个捕获组
    m.group(2)    # "1234"     — 第二个捕获组
    m.start()     # 5          — 匹配起始位置

# --- precompile：循环中复用，跳过重复编译开销 ---
pattern = re.compile(r"\d+")           # 编译一次
pattern.findall("a1b2c3")              # 之后多次调用，复用模式

# --- 常用模式速查 ---
r"\d"        # Unicode 十进制数字；re.ASCII 下等同 [0-9]
r"\w"        # Unicode 字母数字及下划线；re.ASCII 下等同 [a-zA-Z0-9_]
r"\s"        # 空白字符
r"."         # 任意字符（除换行）
r"^Hello"    # 以 Hello 开头
r"end$"      # 以 end 结尾
r"a+"        # 一个或多个 a
r"a*"        # 零个或多个 a
r"a{2,4}"    # 2-4 个 a
r"[abc]"     # a、b 或 c
r"[^abc]"    # 非 a、b、c
r"(ab)+"     # 捕获组：一个或多个 "ab"