What’s New In Python 3.12

def max_value[T](values: Iterable[T]) -> T:
    ...

type Point = tuple[float, float]

print(f"{"hello" + " " + "world"}")

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

print(f"Sum is: {
    add(
        10,
        20
    )
}")

import sys
import os.path

# 定义调试器工具ID
DEBUGGER_ID = sys.monitoring.DEBUGGER_ID

# 初始化跟踪，开启PY_START事件（函数执行开始）
def init_tracing():
    sys.monitoring.use_tool_id(DEBUGGER_ID, "pep669_based_debugger")
    sys.monitoring.set_events(DEBUGGER_ID, sys.monitoring.events.PY_START)

# PY_START事件的回调函数，打印调用的函数名和行号
def pep_669_py_start_trace(code, instruction_offset):
    frame = sys._getframe(1)
    print("calling {} in {} at line {}".format(
        code.co_name,
        os.path.basename(code.co_filename),
        frame.f_lineno)
    )

# 注册PY_START回调
sys.monitoring.register_callback(DEBUGGER_ID, sys.monitoring.events.PY_START, pep_669_py_start_trace)

def f():
    pass

def g():
    f()

def h():
    g()

if __name__ == '__main__':
    init_tracing()
    h()

import contextlib
import inspect

class MyBuffer:
    def __init__(self, data: bytes):
        self.data = bytearray(data)
        self.view = None

    def __buffer__(self, flags: int) -> memoryview:
        if flags != inspect.BufferFlags.FULL_RO:
            raise TypeError("Only BufferFlags.FULL_RO supported")
        if self.view is not None:
            raise RuntimeError("Buffer already held")
        self.view = memoryview(self.data)
        return self.view

    def __release_buffer__(self, view: memoryview) -> None:
        assert self.view is view
        self.view.release()
        self.view = None

    def extend(self, b: bytes) -> None:
        if self.view is not None:
            raise RuntimeError("Cannot extend held buffer")
        self.data.extend(b)

buffer = MyBuffer(b"capybara")

with memoryview(buffer) as view:
    view[0] = ord("C")

with contextlib.suppress(RuntimeError):
    buffer.extend(b"!")

with memoryview(buffer) as view:
    assert view.tobytes() == b"Capybara!"

from typing import override

class Base:
    def foo(self) -> int:
        return 1

class Derived(Base):
    @override
    def foo(self) -> int:
        return 2

import asyncio
import time

async def quick_coro():
    print("开始协程")
    await asyncio.sleep(0.1)  # 模拟异步等待
    print("协程结束")
    return 42

async def main():
    loop = asyncio.get_running_loop()

    # 设置事件循环工厂为 eager_task_factory
    loop.set_task_factory(asyncio.eager_task_factory)

    print("=== 使用 eager_task_factory 创建任务 ===")
    task = loop.create_task(quick_coro())
    print("任务创建后立刻执行至第一个 await")
    result = await task
    print(f"任务完成，结果: {result}")

    # 恢复默认工厂以便对比
    loop.set_task_factory(None)

    print("\n=== 使用默认 create_task ===")
    task2 = asyncio.create_task(quick_coro())
    print("任务创建后不会立即执行")
    result2 = await task2
    print(f"任务完成，结果: {result2}")

asyncio.run(main())