Python常用函数与语法大全

# 字典推导 + 计数 (◕‿◕)
text = "abracadabra"
char_count = {char: text.count(char) for char in set(text)}
# 更高效用 collections.Counter

# 匹配字面量、变量、结构 (ﾉ◕ヮ◕)ﾉ
def process(command):
    match command.split():
        case ["quit"]:
            print("退出")
        case ["move", x, y] if int(x) > 0:  # 守卫（Guard）
            print(f"正向移动 {x}, {y}")
        case ["move", x, y]:
            print(f"移动 {x}, {y}")
        case [action, *rest]:  # 解包剩余部分
            print(f"未知动作: {action}, 参数: {rest}")
        case _:  # 通配符
            print("无效命令")

# 匹配类实例
class Point:
    __match_args__ = ("x", "y")
    def __init__(self, x, y): self.x = x; self.y = y

def where_is(point):
    match point:
        case Point(0, 0): print("原点")
        case Point(x, 0): print(f"X轴 {x}")
        case Point(0, y): print(f"Y轴 {y}")
        case Point(x, y) if x == y: print(f"对角线 {x}")
        case _: print("其他位置")

# 组合大法 (｡◕‿◕｡)
def complex_func(a, b, /, c, d, *args, e, f=10, **kwargs):
    # a, b 必须位置；c, d 位置或关键字；args 可变位置；e 必须关键字；f 默认关键字；kwargs 可变关键字
    pass

def outer():
    count = 0
    def inner():
        nonlocal count  # 必须声明，否则视为局部变量
        count += 1
        return count
    return inner

counter = outer()
print(counter())  # 1
print(counter())  # 2

# 无限序列生成器 (｀・ω・´)
def fibonacci():
    a, b = 0, 1
    while True:
        yield a
        a, b = b, a + b

fib = fibonacci()
[next(fib) for _ in range(10)]  # [0,1,1,2,3,5,8,13,21,34]

# yield from 扁平化嵌套
def flatten(nested):
    for sub in nested:
        yield from sub  # 递归展开
print(list(flatten([[1,2], [3, [4,5]]])))  # 注意：只展一层，需递归处理多层级

# 单例模式与 __new__ (｡♥‿♥｡)
class Singleton:
    _instance = None
    def __new__(cls, *args, **kwargs):
        if cls._instance is None:
            cls._instance = super().__new__(cls)
        return cls._instance

# 上下文管理器手动实现
class ManagedFile:
    def __init__(self, name, mode):
        self.name = name; self.mode = mode
    def __enter__(self):
        self.file = open(self.name, self.mode)
        return self.file
    def __exit__(self, exc_type, exc_val, exc_tb):
        if self.file:
            self.file.close()
        if exc_type:
            print(f"异常被捕获: {exc_val}")
        return True  # 吞掉异常（慎用）

from dataclasses import dataclass, field
from typing import List

@dataclass(order=True)  # 支持排序
class InventoryItem:
    name: str
    price: float = field(repr=True, compare=True)
    quantity: int = field(default=0, compare=False)
    tags: List[str] = field(default_factory=list)  # 避免可变默认值！

    def total_cost(self) -> float:
        return self.price * self.quantity
# 自动生成 __init__, __repr__, __eq__, __hash__ 等

class CustomAPIError(Exception):
    """自定义 API 错误基类"""
    def __init__(self, message, status_code=None):
        super().__init__(message)
        self.status_code = status_code

try:
    raise ConnectionError("连接超时")
except ConnectionError as e:
    # 链式异常，保留原始上下文  (╯°□°)╯
    raise CustomAPIError("请求失败") from e

# 使用 seek 和 tell 操作指针 (｀・ω・´)
with open('data.bin', 'rb+') as f:
    f.write(b'\x00\x01\x02')
    f.seek(1)          # 移动到索引1
    data = f.read(1)   # b'\x01'
    print(f.tell())    # 当前指针位置 -> 2

from contextlib import ExitStack

with ExitStack() as stack:
    files = [stack.enter_context(open(f'file_{i}.txt', 'w')) for i in range(3)]
    for f in files:
        f.write("批量管理 ✨")

from typing import Protocol, runtime_checkable

# 鸭子类型 + 静态检查 (｡◕‿◕｡)
@runtime_checkable
class Drawable(Protocol):
    def draw(self) -> None: ...

def render(obj: Drawable):
    obj.draw()
# 只要实现了 draw 方法的类，即使不继承，也能通过类型检查

import asyncio

async def fetch_data(delay, name):
    print(f"开始 {name} (｀・ω・´)")
    await asyncio.sleep(delay)  # 模拟IO
    print(f"完成 {name}")
    return f"结果 {name}"

async def main():
    # 并发执行
    results = await asyncio.gather(
        fetch_data(2, "A"),
        fetch_data(1, "B"),
        fetch_data(3, "C")
    )
    print(results)  # ['结果 A', '结果 B', '结果 C']

# asyncio.run(main())

import timeit

# 测试列表推导 vs 循环
print(timeit.timeit('[x**2 for x in range(1000)]', number=10000))
print(timeit.timeit('for i in range(1000): lst.append(i**2)', setup='lst=[]', number=10000))

class WithoutSlots:
    def __init__(self, name, age): self.name=name; self.age=age

class WithSlots:
    __slots__ = ('name', 'age')  # 禁止动态添加属性，大幅减少内存使用
    def __init__(self, name, age): self.name=name; self.age=age

# ❌ 慢：每次 += 创建新对象
s = ""
for i in range(1000):
    s += str(i)

# ✅ 快
''.join(map(str, range(1000)))