แแ แแ แฌแแแก แแแแแแแแ แแแแก แจแแแแแ, แแแแแฅแแแงแแแ Python 3.11 แแ แแแ แแแแ แแแแก แแแแก แแแแจแแแแแแแแแ แแแแแจแแแแ. แแฎแแแ แคแแแแแแแก แแฎแแ แแแญแแ แ แฌแแแแฌแแแแแฎแแแแ แ แแฅแแแแ, แ แแก แจแแแแแแแช แแแแแ แกแแแฌแแแแฌแแ-แแแฎแแแแ แ, แแแฌแงแแแแแแแแก แแฆแแแกแแคแฎแแ แแแแ แแแแแกแฌแแ แแแแ.
แแแแแแ แแฃแแแ, แแแแฌแงแ Python 3.12 แคแแแแแแแก แแแคแ แขแแกแขแแ แแแ (แแแแแแแแ แแแแก แแฎแแแ แแ แแคแแแแก แจแแกแแแแแแกแแ, แแฎแแ แคแแแแแแแ แแฃแจแแแแ แแฌแงแแแ แฌแแแ แคแแแแแแแก แแแแแจแแแแแแแ แฎแฃแแ แแแแ แแแ แ แแ แแฆแฌแแแก แแแคแ แขแแกแขแแ แแแแก แแขแแแก แจแแแแแแ แแแแแจแแแแแกแแแแก. ). Python 3.12 แคแแแแแแ แแฅแแแแ แแแคแ แแแแแจแแแแแจแ แจแแแแ แแแแก แแแแแแแแแแแจแ, แ แแแแแก แแ แแกแแช แแแแแแขแแแ แแฎแแแ แคแฃแแฅแชแแแแ แแ แแแแแกแฌแแ แแแแ แจแแชแแแแแแ. แแแแก แจแแแแแ แแแขแ แแแ แกแแแแแก แขแแกแขแแ แแแ แแแฎแแแแ แกแแแ แแแแก แแแแแแแแแแแจแ, แ แแแแแก แแแแแแแแแแแจแแช แแแแ แซแแแแแ แแฎแแแ แคแฃแแฅแชแแแแแก แแแแแขแแแ แแ แแแแแ แงแฃแ แแแฆแแแ แแแแแแแแ แจแแชแแแแแแแก แแแแแกแฌแแ แแแแก. แแแแแจแแแแแแแ แแแแ แแ แ แแแแก แแแแแแแแแแแจแ แคแแแแแแ แแฅแแแแ แแแแแแแกแฃแคแแแแแก แแแแแแแแขแแก แแขแแแแ, แกแแแแช แแแแฎแแ แชแแแแแแแ แกแแแแแแ แกแขแแแแแแแแชแแ.
Python 3.11-แแก แแฎแแแ แแแแแขแแแแแ แแแแชแแแก:
- แแแแจแแแแแแแแแ แกแแแฃแจแแ แแแแแแแ แแฃแจแแแแแก แแแขแแแแแแชแแแกแแแแก. แแฎแแแ แคแแแแแแ แแแแชแแแก แชแแแแแแแแแก, แ แแแแแแแช แแแแแแจแแ แแแฃแแแ แคแฃแแฅแชแแแแแก แแแ แแแแก แแฉแฅแแ แแแแกแแแ แแ แแแแแแ แแแแแแแแแแกแแแ, แกแขแแแแแ แขแฃแแ แแแแ แแชแแแแแก แกแฌแ แแคแ แแแขแแ แแ แแขแแขแแ แแแแก แแแแแงแแแแแแกแแแ (x+x, x*x, xx, a[i], a[i] = z, f(arg) C(arg), o.method(), o.attr = z, *seq), แแกแแแ Cinder แแ HotPy แแ แแแฅแขแแแแก แแแแ แแแแแแแแแฃแแ แแแขแแแแแแชแแ. แแแขแแแ แแแแก แขแแแแ แแแแแแแแแแฃแแแ แแแแแก แจแแกแ แฃแแแแแก แกแแฉแฅแแ แ 10-60%-แแ. แกแแจแฃแแแแ, pyperformance แขแแกแขแแก แแแแแแแฅแขแแ แจแแกแ แฃแแแแ แแแแแแ แแ 25%-แแ.
แแแแขแแแแแแก แฅแแจแแ แแแแก แแแฅแแแแแแ แจแแแชแแแแ, แ แแแแช 10-15%-แแ แจแแแแชแแ แ แแแ แฏแแแแแก แแแจแแแแแก แแ แ. แแแแแแแ แแ แแแแขแแแแแแ แแแแแฅแขแแแ แแฎแแ แกแขแแขแแแฃแ แแ แแ แแก แแแแแฌแแแแแฃแแ แแแ แฏแแแแแแก แแแแ , แ แแแแช แจแแกแแซแแแแแแ แแแฎแแแ แแฆแแแคแฎแแ แ แฅแแจแแแแ แแแแฆแแแฃแแ แแแแขแแแแแแก แแแแฆแแแแก แแขแแแแแ แแ แแแแแฅแขแแแแก แแแแแฅแชแแแ แแแแแ แแแแแแแฃแ แแแฎแกแแแ แแแแจแ แแแกแแแแแกแแแแแ.
- แกแแแแแแแแกแขแแแ แจแแขแงแแแแแแแแแจแ แแแ แแก แแแแแแก แฉแแแแแแแกแแก, แแฎแแ แฃแแแ แจแแกแแซแแแแแแแ แแแคแแ แแแชแแแก แฉแแแแแแ แแแแแแฅแแแก แจแแกแแฎแแ, แ แแแแช แแแแแแฌแแแ แจแแชแแแแ (แแแ แ แแฎแแแแ แฎแแแ แแงแ แแแแแจแแฃแแ, แฎแแแแก แ แแแแแแ แแแฌแแแแ แแแแแแฌแแแ แจแแชแแแแ). แแแคแแ แแแแแฃแแ แแแแแแก แแแคแแ แแแชแแแก แแแฆแแแ แแกแแแ แจแแกแแซแแแแแแแ API-แก แแแจแแแแแแ แแ แแแแแงแแแแแฃแแ แแฅแแแก แชแแแแแฃแแ แแแแขแแฅแแแแก แแแกแขแ แฃแฅแชแแแแแก แแแแแกแแฎแฃแแแแแก แแแแแแ แกแแฌแงแแก แแแแจแ แแแแแ แแขแฃแ แแแแแชแแแแ codeobject.co_positions() แแแแแแแก แแ C API แคแฃแแฅแชแแแก PyCode_Addr2Location() แแแแแงแแแแแแ. แชแแแแแแแ แแแแ แแ แแแแแแแแแก แแ แแแแแแแแแก แแแแแ แแแแก แฌแงแแแแแ แแแฅแกแแแแแแก แแแแแฅแขแแแแแ, แคแฃแแฅแชแแแแแก แแ แแแแแฏแแ แแแ แแแแแซแแฎแแแแ แแ แ แแฃแแ แแ แแแแแขแแแฃแแ แแแแแแแแฅแแแแแแแ. แแแแแ (แฃแแแแแกแแแแแ แแแ แ แแแแ): แคแแแแ "calculation.py", แฎแแแ 54, แจแแแแแ = (x / y / z) * (a / b / c) ~~~~~~^~~ ZeroDivisionError: แแแงแแคแ แแฃแแแ
- แแแแแขแแแฃแแแ แแฎแแ แแแญแแ แ แแแแแแแแแแกแแแแก แฏแแฃแคแแแแกแแแแก, แ แแช แแ แแแ แแแแก แแซแแแแก แจแแกแแซแแแแแแแแก แจแแฅแแแแก แแ แแแแแฃแจแแแแก แ แแแแแแแแ แแแแกแฎแแแแแแฃแแ แแแแแแแแแแกแ แแ แแแ แแฃแแแ. แแ แแแแแ แแแแแแแแแแกแแก แแแกแแฏแแฃแคแแแแแ แแ แแแ แแ แแแ แแกแแแแฆแแแแแแ, แจแแแแแแแแแแแฃแแแ แแแแแแแแแแกแแก แแฎแแแ แขแแแแแ ExceptionGroup แแ BaseExceptionGroup แแ แแแแแขแแแฃแแแ แแแแแฎแแขแแ "แแแ แแ*" แฏแแฃแคแแก แชแแแแแฃแแ แแแแแแแแแแกแแแแก แฎแแแแแกแแกแแแแแ.
- Add_note() แแแแแแ แแแแแแขแ BaseException แแแแกแก, แ แแแแแแช แกแแจแฃแแแแแแก แแแซแแแแ แแแฃแ แแแ แขแแฅแกแขแฃแ แ แจแแแแจแแแ แแแแแแแแแแกแก, แแแแแแแแแ, แแแแแแขแแ แแแแขแแฅแกแขแฃแ แ แแแคแแ แแแชแแ, แ แแแแแแช แแ แแ แแก แฎแแแแแกแแฌแแแแแ, แ แแแแกแแช แแแแแแแแแแกแ แแ แแก แฉแแงแ แแแ.
- แแแแแแขแ แกแแแชแแแแฃแ แ Self-แแก แขแแแ แแแแแแแแ แ แแแ แซแ แแแแกแแก แฌแแ แแแกแแแแแแแ. Self แจแแแซแแแแ แแแแแงแแแแแฃแ แแฅแแแก แแแแแแแแแก แแแแขแแชแแแกแแแแก, แ แแแแแแแช แแแ แฃแแแแแ แแแกแ แแแแกแแก แแแแแแแแก แฃแคแ แ แแแ แขแแแ แแแแ, แแแแ แ TypeVar-แแก แแแแแงแแแแแแ. แแแแกแ MyLock: def __enter__(self) -> Self: self.lock() return self
- แแแแแขแแแฃแแแ แกแแแชแแแแฃแ แ LiteralString แขแแแ, แ แแแแแแช แจแแแซแแแแ แจแแแชแแแแแก แแฎแแแแ แกแขแ แแฅแแแแแก, แ แแแแแแแช แแแแกแแแแแแ LiteralString แขแแแแแ (แแแ., แจแแจแแแแ แแ LiteralString แกแขแ แแฅแแแแแ, แแแแ แแ แแ แ แแแแแแแแฃแ แ แแ แแแแแแแแ แแแฃแแ str แกแขแ แแฅแแแแแ). LiteralString แขแแแแก แจแแแซแแแแ แแแแแงแแแแแฃแ แแฅแแแก แกแแแแแแแแ แแ แแฃแแแแขแแแแก แคแฃแแฅแชแแแแแ แแแแแชแแแแก แจแแแฆแฃแแแแกแแแแก, แกแขแ แแฅแแแแแแก แแแฌแแแแแแก แแแแแแแแฃแ แ แฉแแแแชแแแแแแกแแแแก, แ แแแแแแจแแช แจแแแซแแแแ แแแแแแฌแแแแก แแแฃแชแแแแแแ, แแแแแแแแแ, SQL แแแแฎแแแแแแแกแแแแก แกแขแ แแฅแแแแแแก แแ shell แแ แซแแแแแแแแก แแแแแ แแ แแแแกแแก. def run_query(sql: LiteralString) -> ... ... def caller( arbitrary_string: str, query_string: LiteralString, table_name: LiteralString, ) -> None: run_query("SELECT * FROM Students") # ok run_query(literal_string) # ok run_query( "SELECT * FROM" + literal_string) # ok run_query(arbitrary_string) # แจแแชแแแแ run_query( # Error f"SELECT * FROM Students WHERE name = {arbitrary_string}" )
- แแแแแขแแแฃแแแ TypeVarTuple แขแแแ, แ แแแแแแช แแซแแแแ แชแแแแแ แแแแแ แแแแแแก แแแแแงแแแแแแก แกแแจแฃแแแแแแก, TypeVar-แแกแแแ แแแแกแฎแแแแแแแ, แ แแแแแแช แแแแชแแแก แแ แ แแ แ แขแแแก, แแ แแแแ แขแแแแแแก แแแแแแแแฃแ แ แแแแแแแแแก.
- แกแขแแแแแ แขแฃแแ แแแแแแแแแแ แแแแชแแแก tomllib แแแแฃแแก TOML แคแแ แแแขแแก แแแแแแแแก แคแฃแแฅแชแแแแแ.
- แกแแญแแ แ แแ แแ แแกแแแแแแแแฃแแ แแแแแแแก แแแกแแแแแแแ แจแแกแแซแแแแแแแ แแแ แแคแแแ แแแฅแกแแแแแแแแก แชแแแแแฃแแ แแแแแแแขแแแแก แแแแแจแแแ (TypedDict) Required แแ NotRequired แแขแแแแขแแแแ (แแแแฃแแแกแฎแแแแแ, แงแแแแ แแแแแชแฎแแแแแฃแแ แแแแ แกแแญแแ แแ, แแฃ แฏแแแฃแ แ แแแ แแแแขแ แ แแ แแ แแก แแแงแแแแแฃแแ False-แแ). class Movie(TypedDict): แกแแแแฃแ แ: str. แฌแแแ: NotRequired[int] m1: แคแแแแ = {"แกแแแแฃแ แ": "แจแแแ แแแแขแแ แ", "แฌแแแ": 2018} # OK m2: แคแแแแ = {"แกแแแแฃแ แ": "แแแ แกแแแแแแฃแ แ แแแแแ" } # OK (แฌแแแก แแแแ แแ แแกแแแแแแแแฃแแแ) m3: Movie = {โyearโ: 2022} # แจแแชแแแแ, แกแแญแแ แ แกแแแแฃแ แแก แแแแ แแ แแ แแก แจแแแกแแแฃแแ)
- TaskGroup แแแแกแ แแแแแแขแ asyncio แแแแฃแแก แแกแแแฅแ แแแฃแแ แแแแขแแฅแกแขแฃแ แ แแแแแฏแแ แแก แแแแฎแแ แชแแแแแแแ, แ แแแแแแช แแแแแแแ แแแแแแแแแก แฏแแฃแคแแก แแแกแ แฃแแแแแก. แฏแแฃแคแจแ แแแแชแแแแแแก แแแแแขแแแ แฎแแแแ create_task() แแแแแแแก แแแแแงแแแแแแ. async def main(): แแกแแแฅแ แแแแแแชแแ asyncio.TaskGroup()-แแแ, แ แแแแ แช tg: task1 = tg.create_task(some_coro(...)) task2 = tg.create_task(another_coro(...)) print("แแ แแแ แแแแชแแแ แแฎแแ แแแกแ แฃแแแ .")
- แแแแแขแแแฃแแแ @dataclass_transform แแแแแ แแขแแ แ แแแแกแแแแกแแแแก, แแแแแแแแแกแ แแ แคแฃแแฅแชแแแแแกแแแแก, แ แแแแกแแช แแแแแแแแฃแแแ, แกแขแแขแแแฃแ แ แขแแแแก แจแแแแฌแแแแแก แกแแกแขแแแ แแฅแชแแแ แแแแแฅแขแก แแกแ, แแแแฅแแก แแงแแแแแก @dataclasses.dataclass แแแแแ แแขแแ แก. แฅแแแแแ แแแชแแแฃแ แแแแแแแแจแ CustomerModel แแแแกแ, แขแแแแแแก แจแแแแฌแแแแแกแแก, แแแแฃแจแแแแแแ แแแแกแแก แแกแแแแกแแ @dataclasses.dataclass แแแแแ แแขแแ แแ, แ.แ. แ แแแแ แช __init__ แแแแแแแก แแฅแแแ, แ แแแแแแช แแฆแแแก id แแ name แชแแแแแแแก. @dataclass_transform() class ModelBase: โฆ class CustomerModel(ModelBase): id: int แกแแฎแแแ: str
- แ แแแฃแแแ แฃแ แแแแแแแแฅแแแแแแจแ แแแแแขแแแฃแแแ แแขแแแฃแ แ แแแฏแแฃแคแแแแก ((?>...)) แแ แกแแแฃแแ แแแแก แ แแแแแแแแแแแก (*+, ++, ?+, {m,n}+) แแแแแงแแแแแแก แจแแกแแซแแแแแแแ.
- แแแแแขแแแฃแแแ "-P" แแ แซแแแแแแก แฎแแแแก แแแ แแแแขแ แแ PYTHONSAFEPATH แแแ แแแแก แชแแแแแ, แ แแแ แแแแแ แแแ แแแขแแแชแแฃแ แแ แกแแฎแแคแแแ แคแแแแแก แแแแแแแแแก แแแขแแแแขแฃแ แ แแแแแแ แแแ sys.path-แแ.
- Windows แแแแขแคแแ แแแกแแแแก py.exe แแ แแแ แแแ แแแแจแแแแแแแแแ แแแฃแแฏแแแแกแแ แแ แแแแแแขแ แแฎแแ แแแญแแ แ โ-V:โ แกแแแขแแฅแกแแกแแแแก. / " แแแแแขแแแแ "- . "
- C API-แจแ แแแแ แ แแแแ แ แแแ แแแแฅแแแแแ แ แแแฃแแแ แฃแ แแ แกแขแแขแแแฃแ แจแแแ แคแฃแแฅแชแแแแแ.
- uu, cgi, pipes, crypt, aifc, chunk, msilib, telnetlib, audioop, nis, sndhdr, imghdr, nntplib, spwd, xdrlib, cgitb, mailcap, ossaudiodev แแ sunau แแแแฃแแแแ แแแซแแแแแแฃแแแ แแ แฌแแแจแแแแ แแแแฃแแแแแแแ. 3.13 แแแแแจแแแแ. แฌแแจแแแแแ PyUnicode_Encode* แคแฃแแฅแชแแแแ.
แฌแงแแ แ: opennet.ru