Python 高级用法

class Counter:
    def __init__(self, n):
        self.i = 0
        self.n = n
    def __iter__(self):
        return self
    def __next__(self):
        if self.i < self.n:
            self.i += 1
            return self.i
        raise StopIteration

def gen():
    for i in range(10):
        yield i

def wrapper():
    yield from range(5)

def log(fn):
    def wrapper(*a, **kw):
        print(f"call: {fn.__name__}")
        return fn(*a, **kw)
    return wrapper

def prefix(p):
    def deco(fn):
        def wrapper(*a, **kw):
            print(p)
            return fn(*a, **kw)
        return wrapper
    return deco

class Deco:
    def __init__(self, fn):
        self.fn = fn
    def __call__(self, *a, **kw):
        return self.fn(*a, **kw)

class Timer:
    def __enter__(self):
        self.start = time.time()
    def __exit__(self, *exc):
        print(time.time() - self.start)

from contextlib import suppress

with suppress(KeyError):
    {}["x"]

from contextlib import contextmanager
@contextmanager
def open_file(path):
    f = open(path)
    try:
        yield f
    finally:
        f.close()

def make_adder(x):
    def adder(y):
        return x + y
    return adder

def apply(fn, x):
    return fn(x)

class Meta(type):
    def __new__(cls, name, bases, attrs):
        attrs["tag"] = "from metaclass"
        return super().__new__(cls, name, bases, attrs)

class Field:
    def __get__(self, inst, owner):
        return inst.__dict__["value"]
    def __set__(self, inst, val):
        inst.__dict__["value"] = val

class Model:
    value = Field()

async def worker():
    await asyncio.sleep(1)
    return 42

await asyncio.gather(func1(), func2())

from typing import List, Dict, Optional, Callable

class User(TypedDict):
    name: str
    age: int

class A:
    def __len__(self): ...
    def __repr__(self): ...
    def __getitem__(self, item): ...
    def __eq__(self, other): ...

def __getitem__(self, key):
    if isinstance(key, slice):
        ...

func = lambda x: x * 2

from functools import partial
add2 = partial(add, 2)

import heapq

@lru_cache
def fib(n): ...