Vad är nytt i Python 3.14

Redigerare:

Hugo van Kemenade

I den här artikeln beskrivs de nya funktionerna i Python 3.14 jämfört med 3.13.

För fullständig information, se changelog.

Se även

PEP 745 – Python 3.14 lanseringsschema

Anteckning

Prerelease-användare bör vara medvetna om att detta dokument för närvarande är i utkastform. Det kommer att uppdateras väsentligt när Python 3.14 rör sig mot release, så det är värt att kolla tillbaka även efter att ha läst tidigare versioner.

Sammanfattning – release highlights

Python 3.14 kommer att vara den senaste stabila utgåvan av programmeringsspråket Python, med en blandning av ändringar i språket, implementeringen och standardbiblioteket.

De största förändringarna i implementationen är mallsträngar (PEP 750), uppskjuten utvärdering av annotationer (PEP 649) och en ny typ av tolk som använder tail-anrop.

Biblioteksändringarna inkluderar tillägg av en ny annotationlib-modul för introspektion och omslag av anteckningar (PEP 749), en ny compression.zstd-modul för Zstandard-stöd (PEP 784), plus syntaxmarkering i REPL, samt de vanliga avskrivningarna och borttagningarna och förbättringar av användarvänlighet och korrekthet.

Inkompatibla förändringar

På andra plattformar än macOS och Windows ändras standard startmetod för multiprocessing och ProcessPoolExecutor från fork till forkserver.

Se (1) och (2) för mer information.

Om du stöter på NameError eller pickling-fel som kommer ut från multiprocessing eller concurrent.futures, se forkserver restrictions.

Tolken undviker vissa referensräkningsmodifieringar internt när det är säkert att göra det. Detta kan leda till olika värden som returneras från sys.getrefcount() och Py_REFCNT() jämfört med tidigare versioner av Python. Se below för mer information.

Nya funktioner

PEP 779: Fri trådad Python stöds officiellt

Den fritt trådade versionen av Python stöds nu och är inte längre experimentell. Detta är början på fas II där Python med fri tråd stöds officiellt men fortfarande är valfritt.

Vi är övertygade om att projektet är på rätt väg, och vi uppskattar det fortsatta engagemanget från alla som arbetar för att göra free-threading redo för bredare användning i Python-gemenskapen.

Med dessa rekommendationer och godkännandet av denna PEP bör vi som Python-utvecklargemenskap i stor utsträckning annonsera att free-threading är ett Python-byggalternativ som stöds nu och i framtiden, och att det inte kommer att tas bort utan ett korrekt avvecklingsschema.

Alla beslut om att övergå till fas III, med free-threading som standard eller enda Python-byggnad, är fortfarande obeslutna och beroende av många faktorer både inom CPython själv och gemenskapen. Detta beslut är för framtiden.

Se även

PEP 779 och dess acceptans.

PEP 734: Flera tolkar i stdlib

CPython runtime stöder körning av flera kopior av Python i samma process samtidigt och har gjort det i över 20 år. Var och en av dessa separata kopior kallas en ”tolk”. Funktionen har dock endast varit tillgänglig via C-API.

Den begränsningen har tagits bort i version 3.14 med den nya modulen concurrent.interpreters.

Det finns åtminstone två viktiga skäl till varför det är värt att överväga att använda flera tolkar:

  • de stöder en ny (för Python), människovänlig samtidighetsmodell

  • äkta parallellism med flera kärnor

För vissa användningsfall möjliggör samtidighet i programvara effektivitet och kan förenkla programvaran på en hög nivå. Samtidigt är implementering och underhåll av allt utom den enklaste samtidigheten ofta en kamp för den mänskliga hjärnan. Det gäller särskilt vanliga trådar (t.ex. threading), där allt minne delas mellan alla trådar.

Med flera isolerade tolkar kan du dra nytta av en klass av samtidighetsmodeller, som CSP eller aktormodellen, som har haft framgång i andra programmeringsspråk, som Smalltalk, Erlang, Haskell och Go. Tänk på flera tolkar som trådar men med opt-in-delning.

När det gäller parallellism med flera kärnor: från och med 3.12-utgåvan är tolkarna nu tillräckligt isolerade från varandra för att kunna användas parallellt. (Se PEP 684.) Detta öppnar upp för en mängd olika CPU-intensiva användningsområden för Python som begränsades av GIL.

Att använda flera tolkar liknar på många sätt multiprocessing, eftersom de båda tillhandahåller isolerade logiska ”processer” som kan köras parallellt, utan någon delning som standard. Men när flera tolkar används kommer en applikation att använda färre systemresurser och fungera mer effektivt (eftersom den stannar inom samma process). Tänk på multipla tolkar som att de har processernas isolering med trådarnas effektivitet.

Även om funktionen har funnits i årtionden har multipla tolkar inte använts i någon större utsträckning, på grund av låg medvetenhet och avsaknaden av en stdlib-modul. Följaktligen har de för närvarande flera anmärkningsvärda begränsningar, som kommer att förbättras avsevärt nu när funktionen äntligen blir mainstream.

Nuvarande begränsningar:

  • start av varje tolk har inte optimerats ännu

  • varje tolk använder mer minne än nödvändigt (vi kommer härnäst att arbeta med omfattande intern delning mellan tolkar)

  • det finns inte många alternativ * ännu* för att verkligen dela objekt eller andra data mellan tolkar (annat än memoryview)

  • många tilläggsmoduler på PyPI är ännu inte kompatibla med flera tolkar (stdlib-tilläggsmoduler är kompatibla)

  • metoden att skriva applikationer som använder flera isolerade tolkar är mestadels obekant för Python-användare, än så länge

Effekten av dessa begränsningar beror på framtida CPython-förbättringar, hur tolkar används och vad gemenskapen löser genom PyPI-paket. Beroende på användningsfallet kanske begränsningarna inte har så stor inverkan, så prova det!

Dessutom kommer framtida CPython-utgåvor att minska eller eliminera overhead och tillhandahålla verktyg som är mindre lämpliga på PyPI. Under tiden kan de flesta av begränsningarna också hanteras genom tilläggsmoduler, vilket innebär att PyPI-paket kan fylla alla luckor för 3.14, och till och med tillbaka till 3.12 där tolkar äntligen isolerades ordentligt och slutade dela GIL. På samma sätt förväntar vi oss att långsamt se bibliotek på PyPI för högnivåabstraktioner ovanpå tolkarna.

När det gäller tilläggsmoduler pågår arbete med att uppdatera vissa PyPI-projekt, liksom verktyg som Cython, pybind11, nanobind och PyO3. Stegen för att isolera en tilläggsmodul finns på Isolering av tilläggsmoduler. Att isolera en modul har en hel del överlappning med vad som krävs för att stödja free-threading, så det pågående arbetet i gemenskapen inom det området kommer att bidra till att påskynda stödet för flera tolkar.

Även tillagd i 3.14: concurrent.futures.InterpreterPoolExecutor.

Se även

PEP 734.

PEP 750: Strängar för mallar

Template string literals (t-strängar) är en generalisering av f-strängar, med ett t i stället för prefixet f. Istället för att utvärdera till str, utvärderar t-strängar till en ny string.templatelib.Template-typ:

från string.templatelib import Template

namn = "Värld"
mall: Mall = t"Hej {name}"

Mallen kan sedan kombineras med funktioner som använder mallens struktur för att producera en str eller ett strängliknande resultat. Till exempel för att rensa indata:

evil = "<script>alert('evil')</script>"
template = t"<p>{evil}</p>"
assert html(template) == "<p>&lt;script&gt;alert('evil')&lt;/script&gt;</p>"

Ett annat exempel är generering av HTML-attribut från data:

attributes = {"src": "shrubbery.jpg", "alt": "looks nice"}
template = t"<img {attributes}>"
assert html(template) == '<img src="shrubbery.jpg" alt="looks nice" />'

Jämfört med att använda en f-sträng har funktionen html tillgång till mallattribut som innehåller originalinformationen: statiska strängar, interpoleringar och värden från det ursprungliga omfånget. Till skillnad från befintliga templating-metoder bygger t-strängar på den välkända f-strängens syntax och regler. Mallsystem drar således nytta av Python-verktyg eftersom de ligger mycket närmare Python-språket, syntax, scoping med mera.

Att skriva mallhanterare är enkelt:

from string.templatelib import Template, Interpolation

def lower_upper(template: Template) -> str:
    """Render static parts lowercased and interpolations uppercased."""
    parts: list[str] = []
    for item in template:
        if isinstance(item, Interpolation):
            parts.append(str(item.value).upper())
        else:
            parts.append(item.lower())
    return "".join(parts)

name = "world"
assert lower_upper(t"HELLO {name}") == "hello WORLD"

Med detta på plats kan utvecklare skriva mallsystem för att rensa SQL, göra säkra shell-operationer, förbättra loggning, hantera moderna idéer inom webbutveckling (HTML, CSS och så vidare) och implementera lätta, anpassade affärs-DSL:er.

(Bidrag från Jim Baker, Guido van Rossum, Paul Everitt, Koudai Aono, Lysandros Nikolaou, Dave Peck, Adam Turner, Jelle Zijlstra, Bénédikt Tran och Pablo Galindo Salgado i gh-132661.)

Se även

PEP 750.

PEP 768: Säkert gränssnitt för extern felsökare för CPython

PEP 768 introducerar ett noll-överhead felsökningsgränssnitt som gör det möjligt för felsökare och profilerare att på ett säkert sätt ansluta till Python-processer som körs. Detta är en betydande förbättring av Pythons felsökningsfunktioner som gör det möjligt för felsökare att avstå från osäkra alternativ. Se below för hur denna funktion utnyttjas för att implementera den nya pdb-modulens fjärrkopplingsfunktioner.

Det nya gränssnittet ger säkra exekveringspunkter för att bifoga debugger-kod utan att ändra tolkens normala exekveringsväg eller lägga till runtime overhead. Detta gör det möjligt för verktyg att inspektera och interagera med Python-applikationer i realtid utan att stoppa eller starta om dem - en viktig funktion för system med hög tillgänglighet och produktionsmiljöer.

För enkelhetens skull implementerar CPython detta gränssnitt genom sys-modulen med en sys.remote_exec()-funktion:

sys.remote_exec(pid, script_path)

Denna funktion gör det möjligt att skicka Python-kod som ska exekveras i en målprocess vid nästa säkra exekveringspunkt. Verktygsförfattare kan dock också implementera protokollet direkt enligt beskrivningen i PEP, som beskriver de underliggande mekanismer som används för att på ett säkert sätt ansluta till pågående processer.

Här är ett enkelt exempel som inspekterar objekttyper i en pågående Python-process:

import os
import sys
import tempfile

# Create a temporary script
with tempfile.NamedTemporaryFile(mode='w', suffix='.py', delete=False) as f:
    script_path = f.name
    f.write(f"import my_debugger; my_debugger.connect({os.getpid()})")
try:
    # Execute in process with PID 1234
    print("Behold! An offering:")
    sys.remote_exec(1234, script_path)
finally:
    os.unlink(script_path)

Felsökningsgränssnittet har utformats med tanke på säkerheten och innehåller flera mekanismer för att kontrollera åtkomsten:

En viktig detalj i implementeringen är att gränssnittet använder sig av tolkens befintliga utvärderingsloop och säkra punkter, vilket gör att det inte blir något overhead under normal exekvering samtidigt som det ger externa processer ett tillförlitligt sätt att samordna felsökningsoperationer.

(Bidrag från Pablo Galindo Salgado, Matt Wozniski och Ivona Stojanovic i gh-131591.)

Se även

PEP 768.

PEP 784: Lägga till Zstandard i standardbiblioteket

Det nya paketet compression innehåller modulerna compression.lzma, compression.bz2, compression.gzip och compression.zlib som åter exporterar modulerna lzma, bz2, gzip respektive zlib. De nya importnamnen under compression är de kanoniska namnen för import av dessa komprimeringsmoduler framöver. De befintliga modulnamnen har dock inte tagits bort. Eventuell föråldring eller borttagning av de befintliga komprimeringsmodulerna kommer att ske tidigast fem år efter utgivningen av 3.14.

Den nya compression.zstd-modulen tillhandahåller API:er för komprimering och dekomprimering för Zstandard-formatet via bindningar till Metas zstd-bibliotek. Zstandard är ett allmänt antaget, mycket effektivt och snabbt komprimeringsformat. Utöver de API:er som introducerades i compression.zstd, har stöd för att läsa och skriva komprimerade Zstandard-arkiv lagts till i modulerna tarfile, zipfile och shutil.

Här är ett exempel på hur du använder den nya modulen för att komprimera data:

from compression import zstd
import math

data = str(math.pi).encode() * 20

compressed = zstd.compress(data)

ratio = len(compressed) / len(data)
print(f"Achieved compression ratio of {ratio}")

Som synes liknar API:et API:erna för modulerna lzma och bz2.

(Bidrag från Emma Harper Smith, Adam Turner, Gregory P. Smith, Tomas Roun, Victor Stinner och Rogdham i gh-132983.)

Se även

PEP 784.

Fjärrkoppling till en Python-process som körs med PDB

Modulen pdb stöder nu fjärrkoppling till en Python-process som körs med hjälp av det nya kommandoradsalternativet -p PID:

python -m pdb -p 1234

Detta kommer att ansluta till Python-processen med det angivna PID och låta dig felsöka den interaktivt. Observera att på grund av hur Python-tolken fungerar kommer anslutning till en fjärrprocess som är blockerad i ett systemanrop eller väntar på I/O endast att fungera när nästa bytecode-instruktion körs eller när processen får en signal.

Den här funktionen använder PEP 768 och funktionen sys.remote_exec() för att ansluta till fjärrprocessen och skicka PDB-kommandon till den.

(Bidrag från Matt Wozniski och Pablo Galindo i gh-131591.)

Se även

PEP 768.

PEP 758 - Tillåt except- och except*-uttryck utan parenteser

Uttrycken except och except* tillåter nu att parenteser utelämnas när det finns flera undantagstyper och as-klausulen inte används. Till exempel är följande uttryck nu giltiga:

försök:
    connect_to_server()
except TimeoutError, ConnectionRefusedError:
    print("Nätverksproblem har uppstått.")

 # Detsamma gäller för except* (för undantagsgrupper):

try:
    connect_to_server()
except* TimeoutError, ConnectionRefusedError:
    print("Nätverksproblem har uppstått.")

Se PEP 758 för mer information.

(Bidrag från Pablo Galindo och Brett Cannon i gh-131831.)

Se även

PEP 758.

PEP 649 och 749: Uppskjuten utvärdering av annoteringar

annotations på funktioner, klasser och moduler utvärderas inte längre ivrigt. Istället lagras anteckningar i speciella annotate functions och utvärderas endast när det är nödvändigt (förutom om from __future__ import annotations används). Detta specificeras i PEP 649 och PEP 749.

Denna förändring är utformad för att göra annotationer i Python mer performanta och mer användbara under de flesta omständigheter. Körtidskostnaden för att definiera annotationer minimeras, men det är fortfarande möjligt att introspektera annotationer vid körtid. Det är inte längre nödvändigt att innesluta annotationer i strängar om de innehåller framåtriktade referenser.

Den nya modulen annotationlib tillhandahåller verktyg för att inspektera uppskjutna annoteringar. Anteckningar kan utvärderas i formatet VALUE (som utvärderar anteckningar till runtime-värden, liknande beteendet i tidigare Python-versioner), i formatet FORWARDREF (som ersätter odefinierade namn med speciella markörer) och i formatet STRING (som returnerar anteckningar som strängar).

Detta exempel visar hur dessa format fungerar:

>>> from annotationlib import get_annotations, Format
>>> def func(arg: Undefined):
...     pass
>>> get_annotations(func, format=Format.VALUE)
Traceback (most recent call last):
  ...
NameError: name 'Undefined' is not defined
>>> get_annotations(func, format=Format.FORWARDREF)
{'arg': ForwardRef('Undefined', owner=<function func at 0x...>)}
>>> get_annotations(func, format=Format.STRING)
{'arg': 'Undefined'}

Konsekvenser för annoterad kod

Om du definierar annotationer i din kod (till exempel för användning med en statisk typkontroll), påverkar denna ändring förmodligen inte dig: du kan fortsätta att skriva annotationer på samma sätt som du gjorde med tidigare versioner av Python.

Du kommer sannolikt att kunna ta bort citerade strängar i annotationer, som ofta används för framåtriktade referenser. På samma sätt, om du använder from __future__ import annotations för att undvika att behöva skriva strängar i annotationer, kan du mycket väl ta bort den importen när du bara stöder Python 3.14 och nyare. Men om du förlitar dig på tredjepartsbibliotek som läser annotationer kan dessa bibliotek behöva ändras för att stödja annotationer utan citat innan de fungerar som förväntat.

Konsekvenser för läsare av __annotationer__

Om din kod läser attributet __annotations__ på objekt, kanske du vill göra ändringar för att stödja kod som förlitar sig på uppskjuten utvärdering av annoteringar. Du kanske till exempel vill använda annotationlib.get_annotations() med formatet FORWARDREF, som modulen dataclasses nu gör.

Det externa paketet typing_extensions tillhandahåller partiella bakåtporter av en del av funktionaliteten i modulen annotationlib, såsom enum Format och funktionen get_annotations(). Dessa kan användas för att skriva versionsöverskridande kod som drar nytta av det nya beteendet i Python 3.14.

from __future__ import annotations

I Python 3.7 introducerade PEP 563 direktivet from __future__ import annotations, som förvandlar alla annotationer till strängar. Detta direktiv anses nu vara föråldrat och det förväntas tas bort i en framtida version av Python. Detta borttagande kommer dock inte att ske förrän efter Python 3.13, den sista versionen av Python utan uppskjuten utvärdering av annotationer, når slutet av sin livslängd 2029. I Python 3.14 är beteendet för kod som använder from __future__ import annotations oförändrat.

(Bidrag från Jelle Zijlstra i gh-119180; PEP 649 skrevs av Larry Hastings.)

Se även

PEP 649 och PEP 749.

Förbättrade felmeddelanden

  • Tolken ger nu användbara förslag när den upptäcker stavfel i Python-nyckelord. När ett ord som är mycket likt ett Python-nyckelord påträffas kommer tolken att föreslå det korrekta nyckelordet i felmeddelandet. Den här funktionen hjälper programmerare att snabbt identifiera och åtgärda vanliga skrivfel. Ett exempel:

    >>> whille True:
...     pass
Traceback (most recent call last):
  File "<stdin>", line 1
    whille True:
    ^^^^^^
SyntaxError: invalid syntax. Did you mean 'while'?

>>> asynch def fetch_data():
...     pass
Traceback (most recent call last):
  File "<stdin>", line 1
    asynch def fetch_data():
    ^^^^^^
SyntaxError: invalid syntax. Did you mean 'async'?

>>> async def foo():
...     awaid fetch_data()
Traceback (most recent call last):
  File "<stdin>", line 2
    awaid fetch_data()
    ^^^^^
SyntaxError: invalid syntax. Did you mean 'await'?

>>> raisee ValueError("Error")
Traceback (most recent call last):
  File "<stdin>", line 1
    raisee ValueError("Error")
    ^^^^^^
SyntaxError: invalid syntax. Did you mean 'raise'?

    Funktionen fokuserar på de vanligaste fallen, men vissa variationer av felstavningar kan fortfarande resultera i vanliga syntaxfel. (Bidrag från Pablo Galindo i gh-132449.)

  • När en uppackningsuppgift misslyckas på grund av felaktigt antal variabler, visar felmeddelandet det mottagna antalet värden i fler fall än tidigare. (Bidrag från Tushar Sadhwani i gh-122239.)

    >>> x, y, z = 1, 2, 3, 4
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
    x, y, z = 1, 2, 3, 4
    ^^^^^^^
ValueError: too many values to unpack (expected 3, got 4)

  • elif-satser som följer ett else-block har nu ett specifikt felmeddelande. (Bidrag från Steele Farnsworth i gh-129902.)

    >>> if who == "me":
...     print("It's me!")
... else:
...     print("It's not me!")
... elif who is None:
...     print("Who is it?")
File "<stdin>", line 5
  elif who is None:
  ^^^^
SyntaxError: 'elif' block follows an 'else' block

  • Om ett uttalande (pass, del, return, yield, raise, break, continue, assert, import, from) skickas till Villkorliga uttryck efter else, eller om ett av pass, break, eller continue skickas före if, så markerar felmeddelandet var expression krävs. (Bidrag från Sergey Miryanov i gh-129515.)

    >>> x = 1 if True else pass
Traceback (most recent call last):
  File "<string>", line 1
    x = 1 if True else pass
                       ^^^^
SyntaxError: expected expression after 'else', but statement is given

>>> x = continue if True else break
Traceback (most recent call last):
  File "<string>", line 1
    x = continue if True else break
        ^^^^^^^^
SyntaxError: expected expression before 'if', but statement is given

  • När felaktigt stängda strängar upptäcks, antyder felmeddelandet att strängen kan vara avsedd att vara en del av strängen. (Bidrag från Pablo Galindo i gh-88535.)

    >>> "The interesting object "The important object" is very important"
Traceback (most recent call last):
SyntaxError: invalid syntax. Is this intended to be part of the string?

  • När strängar har inkompatibla prefix visar felmeddelandet nu vilka prefix som är inkompatibla. (Bidrag från Nikita Sobolev i gh-133197.)

    >>> ub'abc'
  File "<python-input-0>", line 1
    ub'abc'
    ^^
SyntaxError: 'u' and 'b' prefixes are incompatible

  • Förbättrade felmeddelanden vid användning av as med inkompatibla mål i:

    • Importera: import ... as ...

    • Från import: from ... import ... as ...

    • Undantag hanterare: undantag ... som ...

    • Fall som stämmer överens med mönster: fall ... som ...

    (Bidrag från Nikita Sobolev i gh-123539, gh-123562, och gh-123440.)

    >>> import ast as arr[0]
  File "<python-input-1>", line 1
    import ast as arr[0]
                  ^^^^^^
SyntaxError: cannot use subscript as import target

  • Förbättrat felmeddelande när man försöker lägga till en instans av en ohashable typ till en dict eller set. (Bidrag från CF Bolz-Tereick och Victor Stinner i gh-132828.)

    >>> s = set()
>>> s.add({'pages': 12, 'grade': 'A'})
Traceback (most recent call last):
  File "<python-input-1>", line 1, in <module>
    s.add({'pages': 12, 'grade': 'A'})
    ~~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
TypeError: cannot use 'dict' as a set element (unhashable type: 'dict')
>>> d = {}
>>> l = [1, 2, 3]
>>> d[l] = 12
Traceback (most recent call last):
  File "<python-input-4>", line 1, in <module>
    d[l] = 12
    ~^^^
TypeError: cannot use 'list' as a dict key (unhashable type: 'list')

PEP 741: Python-konfiguration C API

Lägg till en PyInitConfig C API för att konfigurera Python-initialiseringen utan att förlita sig på C-strukturer och möjligheten att göra ABI-kompatibla ändringar i framtiden.

Slutför PEP 587 PyConfig C API genom att lägga till PyInitConfig_AddModule() som kan användas för att lägga till en inbyggd tilläggsmodul; en funktion som tidigare kallades ”inittab”.

Lägg till funktionerna PyConfig_Get() och PyConfig_Set() för att hämta och ställa in den aktuella körtidskonfigurationen.

PEP 587 ”Python Initialization Configuration” förenade alla sätt att konfigurera Python-initialiseringen. Denna PEP förenar även konfigurationen av Python-förinitialiseringen och Python-initialiseringen i ett enda API. Dessutom ger denna PEP endast ett enda val för att bädda in Python, istället för att ha två val ”Python” och ”Isolated” (PEP 587), för att förenkla API:et ytterligare.

Den lägre nivån PEP 587 PyConfig API förblir tillgänglig för användningsfall med en avsiktligt högre kopplingsnivå till CPython-implementeringsdetaljer (t.ex. emulering av den fullständiga funktionaliteten i CPythons CLI, inklusive dess konfigurationsmekanismer).

(Bidrag från Victor Stinner i gh-107954.)

Se även

PEP 741.

Asyncios möjligheter till introspektion

Lagt till ett nytt kommandoradsgränssnitt för att inspektera Python-processer som körs med hjälp av asynkrona uppgifter, tillgängligt via:

python -m asyncio ps PID

Detta verktyg inspekterar det angivna process-ID:t (PID) och visar information om asyncio-uppgifter som körs för närvarande. Det ger ut en uppgiftstabell: en platt lista över alla uppgifter, deras namn, deras coroutine-stackar och vilka uppgifter som väntar på dem.

python -m asyncio pstree PID

Det här verktyget hämtar samma information, men visar ett visuellt asynkront anropsträd som visar coroutine-relationer i ett hierarkiskt format. Det här kommandot är särskilt användbart för felsökning av asynkrona program som körs länge eller har fastnat. Det kan hjälpa utvecklare att snabbt identifiera var ett program är blockerat, vilka uppgifter som väntar och hur coroutines är sammanlänkade.

Till exempel med denna kod:

import asyncio

async def play(track):
    await asyncio.sleep(5)
    print(f"🎵 Finished: {track}")

async def album(name, tracks):
    async with asyncio.TaskGroup() as tg:
        for track in tracks:
            tg.create_task(play(track), name=track)

async def main():
    async with asyncio.TaskGroup() as tg:
        tg.create_task(
          album("Sundowning", ["TNDNBTG", "Levitate"]), name="Sundowning")
        tg.create_task(
          album("TMBTE", ["DYWTYLM", "Aqua Regia"]), name="TMBTE")

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

Om du kör det nya verktyget på den pågående processen får du en tabell som ser ut så här:

python -m asyncio ps 12345

tid uppgift id uppgift namn coroutine stack awaiter kedja awaiter namn awaiter id
------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
1935500 0x7fc930c18050 Uppgift-1 TaskGroup._aexit -> TaskGroup.__aexit__ -> main 0x0
1935500 0x7fc930c18230 Solnedgång TaskGroup._aexit -> TaskGroup.__aexit__ -> album TaskGroup._aexit -> TaskGroup.__aexit__ -> main Task-1 0x7fc930c18050
1935500 0x7fc93173fa50 TMBTE TaskGroup._aexit -> TaskGroup.__aexit__ -> album TaskGroup._aexit -> TaskGroup.__aexit__ -> huvuduppgift-1 0x7fc930c18050
1935500 0x7fc93173fdf0 TNDNBTG sleep -> play TaskGroup._aexit -> TaskGroup.__aexit__ -> albumet Sundowning 0x7fc930c18230
1935500 0x7fc930d32510 Levitate sömn -> spela TaskGroup._aexit -> TaskGroup.__aexit__ -> albumet Sundowning 0x7fc930c18230
1935500 0x7fc930d32890 DYWTYLM sömn -> spela upp TaskGroup._aexit -> TaskGroup.__aexit__ -> albumet TMBTE 0x7fc93173fa50
1935500 0x7fc93161ec30 Aqua Regia sömn -> spela upp TaskGroup._aexit -> TaskGroup.__aexit__ -> album TMBTE 0x7fc93173fa50

eller ett träd som det här:

python -m asyncio pstree 12345

└── (T) Uppgift-1
    └── huvud exempel.py:13
        └── TaskGroup.__aexit__ Lib/asyncio/taskgroups.py:72
            └── TaskGroup._aexit Lib/asyncio/taskgroups.py:121
                ├── (T) Solnedgång
                │ └── album example.py:8
                │ └─── TaskGroup.__aexit__ Lib/asyncio/taskgroups.py:72
                │ └─── TaskGroup._aexit Lib/asyncio/taskgroups.py:121
                │ ├── (T) TNDNBTG
                │ │ └── spela exempel.py:4
                │ │ └── sleep Lib/asyncio/tasks.py:702
                │ └── (T) Levitate
                │ └── spela exempel.py:4
                │ └── sova Lib/asyncio/tasks.py:702
                └── (T) TMBTE
                    └── album exempel.py:8
                        └── TaskGroup.__aexit__ Lib/asyncio/taskgroups.py:72
                            └── TaskGroup._aexit Lib/asyncio/taskgroups.py:121
                                ├── (T) DYWTYLM
                                │ └── spela exempel.py:4
                                │ └── sleep Lib/asyncio/tasks.py:702
                                └── (T) Aqua Regia
                                    └── spela exempel.py:4
                                        └── sova Lib/asyncio/tasks.py:702

Om en cykel upptäcks i async await-grafen (vilket kan tyda på ett programmeringsproblem), ger verktyget ett felmeddelande och listar de cykelvägar som förhindrar trädkonstruktion:

python -m asyncio pstree 12345

FEL: await-graph innehåller cykler - kan inte skriva ut ett träd!

cykel: Uppgift-2 → Uppgift-3 → Uppgift-2

(Bidrag från Pablo Galindo, Łukasz Langa, Yury Selivanov och Marta Gomez Macias i gh-91048.)

En ny typ av tolk

En ny typ av tolk har lagts till i CPython. Den använder tail calls mellan små C-funktioner som implementerar enskilda Python-opkoder, snarare än en stor C case-sats. För vissa nyare kompilatorer ger denna tolk betydligt bättre prestanda. Preliminära siffror på våra maskiner tyder på upp till 30% faster Python-kod, och ett geometriskt medelvärde på 3-5% faster på pyperformance beroende på plattform och arkitektur. Baslinjen är Python 3.14 byggd med Clang 19 utan denna nya tolk.

Denna tolk fungerar för närvarande endast med Clang 19 och nyare på x86-64- och AArch64-arkitekturer. Vi förväntar oss dock att en framtida version av GCC kommer att stödja detta också.

Denna funktion är opt-in för tillfället. Vi rekommenderar starkt att du aktiverar profilstyrd optimering med den nya tolken eftersom det är den enda konfigurationen vi har testat och kan validera dess förbättrade prestanda. För ytterligare information om hur man bygger Python, se --with-tail-call-interp.

Anteckning

Detta ska inte förväxlas med tail call optimization av Python-funktioner, som för närvarande inte är implementerat i CPython.

Denna nya tolktyp är en intern implementeringsdetalj av CPython-tolken. Den ändrar inte Python-programmens synliga beteende alls. Det kan förbättra deras prestanda, men ändrar inget annat.

Observera

Detta avsnitt rapporterade tidigare en 9-15% geometrisk medelhastighetsökning. Denna siffra har sedan dess försiktigt reviderats ned till 3-5%. Även om vi förväntar oss att prestandaresultaten ska vara bättre än vad vi rapporterar, är våra uppskattningar mer konservativa på grund av en kompilatorbugg som finns i Clang/LLVM 19, som gör att den normala tolken blir långsammare. Vi var inte medvetna om denna bugg, vilket resulterade i felaktiga resultat. Vi ber uppriktigt om ursäkt för att vi kommunicerade resultat som endast var korrekta för LLVM v19.1.x och v20.1.0. Under tiden har buggen åtgärdats i LLVM v20.1.1 och för den kommande v21.1, men den kommer inte att åtgärdas för LLVM v19.1.x och v20.1.0. Därför kan alla benchmarks med dessa versioner av LLVM ge felaktiga siffror. (Tack till Nelson Elhage för att han uppmärksammade detta)

(Bidrag från Ken Jin i gh-128563, med idéer om hur man implementerar detta i CPython av Mark Shannon, Garrett Gu, Haoran Xu och Josh Haberman.)

Frittrådat läge

Free-threaded mode (PEP 703), som ursprungligen lades till i 3.13, har förbättrats avsevärt. Implementationen som beskrivs i PEP 703 har slutförts, inklusive ändringar i C API, och tillfälliga lösningar i tolken har ersatts med mer permanenta lösningar. Den specialiserade adaptiva tolken (PEP 659) är nu aktiverad i fritt trådat läge, vilket tillsammans med många andra optimeringar kraftigt förbättrar dess prestanda. Prestandaförlusten för enkeltrådad kod i fritt trådat läge är nu ungefär 5-10%, beroende på plattform och vilken C-kompilator som används.

Detta arbete har utförts av många bidragsgivare: Sam Gross, Matt Page, Neil Schemenauer, Thomas Wouters, Donghee Na, Kirill Podoprigora, Ken Jin, Itamar Oren, Brett Simmers, Dino Viehland, Nathan Goldbaum, Ralf Gommers, Lysandros Nikolaou, Kumar Aditya, Edgar Margffoy och många andra.

Några av dessa medarbetare är anställda av Meta, som har fortsatt att tillhandahålla betydande tekniska resurser för att stödja detta projekt.

Från och med 3.14 måste preprocessorvariabeln Py_GIL_DISABLED nu anges av build backend vid kompilering av tilläggsmoduler för den fritt trådade versionen av CPython på Windows, eftersom den inte längre bestäms automatiskt av C-kompilatorn. För en tolk som körs kan den inställning som användes vid kompileringstillfället hittas med sysconfig.get_config_var().

En ny flagga har lagts till, context_aware_warnings. Denna flagga är som standard inställd på true för den trådfria versionen och false för den GIL-aktiverade versionen. Om flaggan är true använder warnings.catch_warnings-kontextmanagern en kontextvariabel för varningsfilter. Detta gör att kontextmanagern beter sig förutsägbart när den används med flera trådar eller asynkrona uppgifter.

En ny flagga har lagts till, thread_inherit_context. Denna flagga är som standard true för free-threaded build och false för GIL-enabled build. Om flaggan är true kommer trådar som skapas med threading.Thread att starta med en kopia av Context() för den som anropar start(). Viktigast av allt är att detta gör att varningsfiltreringskontexten som upprättas av catch_warnings ”ärvs” av trådar (eller asyncio-uppgifter) som startas inom den kontexten. Det påverkar även andra moduler som använder kontextvariabler, t.ex. kontexthanteraren decimal.

Syntaxmarkering i PyREPL

Standardskalet interactive markerar nu Python-syntax när du skriver. Denna funktion är aktiverad som standard om inte PYTHON_BASIC_REPL är inställd eller om inga miljövariabler som inaktiverar färg används. Se Styrning av färg för detaljer.

Standardfärgtemat för syntaxmarkering strävar efter god kontrast och använder uteslutande 4-bitars VGA-standard ANSI-färgkoder för maximal kompatibilitet. Temat kan anpassas med hjälp av ett experimentellt API _colorize.set_theme(). Detta kan anropas interaktivt, såväl som i skriptet PYTHONSTARTUP.

(Bidrag från Łukasz Langa i gh-131507.)

Binära utgåvor för den experimentella just-in-time-kompilatorn

De officiella binärversionerna för macOS och Windows innehåller nu en experimentell JIT-kompilator (just-in-time). Även om den inte rekommenderas för produktionsanvändning kan den testas genom att ställa in PYTHON_JIT=1 som en miljövariabel. Nedströms källkodskonstruktioner och redistributörer kan använda konfigurationsalternativet --enable-experimental-jit=yes-off för liknande beteende.

JIT befinner sig i ett tidigt skede och är fortfarande under aktiv utveckling. Därför kan den typiska prestandapåverkan av att aktivera den variera från 10% s% lägre till 20% f% högre, beroende på arbetsbelastning. För att underlätta testning och utvärdering har en uppsättning introspektionsfunktioner tillhandahållits i namnrymden sys._jit. sys._jit.is_available() kan användas för att avgöra om den aktuella körbara filen stöder JIT-kompilering, medan sys._jit.is_enabled() kan användas för att avgöra om JIT-kompilering har aktiverats för den aktuella processen.

För närvarande är den viktigaste saknade funktionaliteten att inbyggda debuggers och profilerare som gdb och perf inte kan spola tillbaka genom JIT-ramar (Python-debuggers och profilerare, som pdb eller profile, fortsätter att fungera utan modifiering). Frittrådade builds stöder inte JIT-kompilering.

Rapportera alla buggar eller större prestandaförbättringar som du stöter på!

Se även

PEP 744

Kontroll av samtidiga säkra varningar

Kontextbehandlaren warnings.catch_warnings kommer nu valfritt att använda en kontextvariabel för varningsfilter. Detta aktiveras genom att ställa in flaggan context_aware_warnings, antingen med kommandoradsalternativet -X eller en miljövariabel. Detta ger förutsägbar kontroll över varningar när catch_warnings används i kombination med flera trådar eller asynkrona uppgifter. Flaggan är som standard inställd på true för den trådfria versionen och false för den GIL-aktiverade versionen.

(Bidrag från Neil Schemenauer och Kumar Aditya i gh-130010.)

Inkrementell skräpplockning

Cykelns sopsamlare är nu inkrementell. Det innebär att den maximala paustiden minskar med en storleksordning eller mer för större högar.

Det finns nu bara två generationer: unga och gamla. När gc.collect() inte anropas direkt, anropas GC lite mer sällan. När den anropas samlar den in den unga generationen och ett inkrement av den gamla generationen, istället för att samla in en eller flera generationer.

Beteendet för gc.collect() ändras något:

  • gc.collect(1): Utför en ökning av skräpinsamlingen, istället för att samla in generation 1.

  • Andra anrop till gc.collect() är oförändrade.

(Bidrag från Mark Shannon i gh-108362.)

Stöd för plattform

Andra språkliga ändringar

  • Standardskalet interactive har nu stöd för automatisk importkomplettering. Detta innebär att om du skriver import foo och trycker på <tab> kommer moduler som börjar med foo att föreslås. På samma sätt, om du skriver from foo import b kommer undermoduler till foo som börjar med b att föreslås. Observera att autokomplettering av modulattribut för närvarande inte stöds. (Bidrag från Tomas Roun i gh-69605.)

  • Den inbyggda map() har nu en valfri strict-flagga för endast nyckelord som zip() för att kontrollera att alla iterabler är lika långa. (Bidrag från Wannes Boeykens i gh-119793.)

  • Felaktig användning av await och asynkrona förståelser upptäcks nu även om koden har optimerats bort med kommandoradsalternativet -O. Till exempel, python -O -c 'assert await 1' producerar nu en SyntaxError. (Bidrag från Jelle Zijlstra i gh-121637.)

  • Skrivningar till __debug__ upptäcks nu även om koden har optimerats bort med kommandoradsalternativet -O. Till exempel, python -O -c 'assert (__debug__ := 1)' producerar nu en SyntaxError. (Bidrag från Irit Katriel i gh-122245.)

  • Lägg till klassmetoderna float.from_number() och complex.from_number() för att konvertera ett tal till float respektive complex. De ger upphov till ett fel om argumentet är en sträng. (Bidrag från Serhiy Storchaka i gh-84978.)

  • Implementera aritmetiska regler för blandade lägen som kombinerar reella och komplexa tal enligt C-standarderna sedan C99. (Bidrag från Sergey B Kirpichev i gh-69639.)

  • Alla Windows-kodsidor stöds nu som ”cpXXX”-codecs i Windows. (Bidrag från Serhiy Storchaka i gh-123803.)

  • super-objekt är nu pickleable och copyable. (Bidrag från Serhiy Storchaka i gh-125767.)

  • Typen memoryview har nu stöd för prenumeration, vilket gör den till en generic type. (Bidrag från Brian Schubert i gh-126012.)

  • Stöd för understrykning och kommatecken som tusentalsavgränsare i bråkdelen för presentationstyper med flyttal i den nya stilen för strängformatering (med format() eller f-strängar). (Bidrag från Sergey B Kirpichev i gh-87790.)

  • Metoderna bytes.fromhex() och bytearray.fromhex() accepterar nu ASCII bytes och bytesliknande objekt. (Bidrag från Daniel Pope i gh-129349.)

  • Stöd för \z som synonym för \Z i regular expressions. Det tolkas otvetydigt i många andra motorer för reguljära uttryck, till skillnad från \Z, som har ett subtilt annorlunda beteende. (Bidrag från Serhiy Storchaka i gh-133306.)

  • \B i regular expression matchar nu den tomma inmatningssträngen. Nu är det alltid motsatsen till \b. (Bidrag från Serhiy Storchaka i gh-124130.)

  • iOS- och macOS-appar kan nu konfigureras att omdirigera innehåll från stdout och stderr till systemloggen. (Bidrag från Russell Keith-Magee i gh-127592.)

  • IOS-testbädden kan nu strömma testutdata medan testet körs. Testbädden kan också användas för att köra testsviten för andra projekt än CPython själv. (Bidrag från Russell Keith-Magee i gh-127592.)

  • Tre-argument pow() försöker nu anropa __rpow__() om det behövs. Tidigare anropades det bara i två-argument pow() och den binära potensoperatorn. (Bidrag från Serhiy Storchaka i gh-130104.)

  • Lägg till en inbyggd implementering för HMAC (RFC 2104) med hjälp av formellt verifierad kod från projektet HACL*. Denna implementation används som en reservlösning när OpenSSL-implementationen av HMAC inte är tillgänglig. (Bidrag från Bénédikt Tran i gh-99108.)

  • Flaggan för importtid kan nu spåra moduler som redan är inlästa (”cached”), via det nya -X importtime=2. När en sådan modul importeras kommer tiderna self och cumulative att ersättas av strängen cached. Värden över 2 för -X importtime är nu reserverade för framtida användning. (Bidrag från Noah Kim och Adam Turner i gh-118655.)

  • Vid underklassning från en ren C-typ ersätts inte längre C-platserna för den nya typen med en omsluten version när klassen skapas om de inte uttryckligen åsidosätts i underklassen. (Bidrag från Tomasz Pytel i gh-132329.)

  • Kommandoradsalternativet -c avtäcker nu automatiskt sitt kodargument före exekvering. Beteendet för automatisk dedentering speglar textwrap.dedent(). (Bidrag från Jon Crall och Steven Sun i gh-103998.)

  • Förbättra felmeddelandet när ett objekt som stöder protokollet för synkron kontexthantering anges med async with istället för with. Och vice versa med det asynkrona kontexthanterarprotokollet. (Bidrag från Bénédikt Tran i gh-128398.)

  • -J är inte längre en reserverad flagga för Jython, och har nu ingen speciell betydelse. (Bidrag från Adam Turner i gh-133336.)

  • Den inbyggda funktionen int() delegerar inte längre till __trunc__(). Klasser som vill stödja konvertering till int() måste implementera antingen __int__() eller __index__(). (Bidrag från Mark Dickinson i gh-119743.)

  • Användning av NotImplemented i ett booleskt sammanhang kommer nu att generera ett TypeError. Detta har genererat ett DeprecationWarning sedan Python 3.9. (Bidrag från Jelle Zijlstra i gh-118767.)

PEP 765: Förbjud return/break/continue som avslutar ett finally-block

Kompilatorn avger ett SyntaxWarning när ett return, break eller continue-uttryck förekommer där det avslutar ett finally-block. Denna ändring specificeras i PEP 765.

Nya moduler

Förbättrade moduler

argparse

  • Standardvärdet för programnamn för argparse.ArgumentParser återspeglar nu det sätt på vilket Python-tolken instruerades att hitta modulkoden __main__. (Bidrag från Serhiy Storchaka och Alyssa Coghlan i gh-66436.)

  • Införde den valfria parametern suggest_on_error till argparse.ArgumentParser, vilket möjliggör förslag på argumentval och namn på subparser om användaren skriver fel. (Bidrag från Savannah Ostrowski i gh-124456.)

  • Aktivera färg för hjälptext, som kan inaktiveras med den valfria color-parametern till argparse.ArgumentParser. Detta kan också kontrolleras med miljövariabler. (Bidrag från Hugo van Kemenade i gh-130645.)

ast

  • Lägg till ast.compare() för att jämföra två AST:er. (Bidrag från Batuhan Taskaya och Jeremy Hylton i gh-60191.)

  • Lägg till stöd för copy.replace() för AST-noder. (Bidrag från Bénédikt Tran i gh-121141.)

  • Docstrings tas nu bort från en optimerad AST i optimeringsnivå 2. (Bidrag från Irit Katriel i gh-123958.)

  • Utmatningen repr() för AST-noder innehåller nu mer information. (Bidrag från Tomas Roun i gh-116022.)

  • ast.parse(), när den anropas med en AST som indata, verifierar nu alltid att rotnodstypen är lämplig. (Bidrag från Irit Katriel i gh-130139.)

  • Lägg till nya alternativ --feature-version, --optimize, --show-empty till kommandoradsgränssnittet. (Bidrag från Semyon Moroz i gh-133367.)

asyncio

  • Funktionen och metoderna med namnet create_task() tar nu en godtycklig lista med nyckelordsargument. Alla nyckelordsargument skickas till task-konstruktören eller den anpassade uppgiftsfabriken. (Se set_task_factory() för detaljer.) Nyckelordsargumenten name och context är inte längre speciella; namnet ska nu anges med hjälp av nyckelordsargumentet name i fabriken, och context kan vara None.

    Detta påverkar följande funktioner och metoder: asyncio.create_task(), asyncio.loop.create_task(), asyncio.TaskGroup.create_task(). (Bidrag från Thomas Grainger i gh-128307.)

  • Det finns två nya verktygsfunktioner för att introspektera och skriva ut ett programs anropskurva: capture_call_graph() och print_call_graph(). (Bidrag från Yury Selivanov, Pablo Galindo Salgado och Łukasz Langa i gh-91048.)

kalender

concurrent.futures

  • Lägg till InterpreterPoolExecutor, som exponerar ”undertolkare” (flera Python-tolkare i samma process) till Python-kod. Detta är separat från det föreslagna API:et i PEP 734. (Bidrag från Eric Snow i gh-124548.)

configparser

kontextvarianter

ctyper

curses

datatid

decimal

difflib

  • Jämförelsesidor med markerade ändringar som genereras av klassen difflib.HtmlDiff stöder nu mörkt läge. (Bidrag från Jiahao Li i gh-129939.)

dis

errno

felhanterare

fnmatch

fraktioner

functools

getopt

  • Lägg till stöd för alternativ med valfria argument. (Bidrag från Serhiy Storchaka i gh-126374.)

  • Lägg till stöd för att returnera blandade alternativ och icke-optionsargument i ordning. (Bidrag från Serhiy Storchaka i gh-126390.)

passera

  • Stöd för återkoppling från tangentbordet med getpass.getpass() via det valfria argumentet echo_char som endast är tillgängligt för nyckelord. Platshållartecken visas när ett tecken skrivs in och tas bort när ett tecken raderas. (Bidrag från Semyon Moroz i gh-77065.)

graflib

heapq

hmac

  • Lägg till en inbyggd implementering för HMAC (RFC 2104) med hjälp av formellt verifierad kod från projektet HACL*. (Bidrag från Bénédikt Tran i gh-99108.)

http

  • Kataloglistor och felsidor som genereras av modulen http.server tillåter webbläsaren att använda sitt standard mörka läge. (Bidrag från Yorik Hansen i gh-123430.)

  • Modulen http.server stöder nu servering över HTTPS med hjälp av klassen http.server.HTTPSServer. Denna funktionalitet exponeras av kommandoradsgränssnittet (python -m http.server) genom följande alternativ:

    • --tls-cert <path>: Sökväg till TLS-certifikatfilen.

    • --tls-key <path>: Valfri sökväg till filen med den privata nyckeln.

    • --tls-password-file <path>: Valfri sökväg till lösenordsfilen för den privata nyckeln.

    (Bidrag från Semyon Moroz i gh-85162.)

imaplib

inspektera

io

json

  • Lägg till anteckningar för JSON-serialiseringsfel som gör det möjligt att identifiera källan till felet. (Bidrag från Serhiy Storchaka i gh-122163.)

  • Aktivera modulen json så att den fungerar som ett skript med hjälp av -m: python -m json. Se dokumentationen JSON command-line interface. (Bidrag från Trey Hunner i gh-122873.)

  • Som standard är utdata från kommandoradsgränssnittet JSON markerade i färg. Detta kan kontrolleras med miljövariabler. (Bidrag från Tomas Roun i gh-131952.)

linecache

loggning.hanterare

matematik

  • Mer detaljerade felmeddelanden för domänfel har lagts till i modulen. (Bidrag från Charlie Zhao och Sergey B Kirpichev i gh-101410.)

mimetyper

  • Dokumentera kommandoraden för mimetypes. Den avslutas nu med 1 vid misslyckande istället för 0 och 2 vid felaktiga kommandoradsparametrar istället för 1. Dessutom skrivs fel ut till stderr istället för stdout och deras text har stramats upp. (Bidrag från Oleg Iarygin och Hugo van Kemenade i gh-93096.)

  • Lägg till MS- och RFC 8081 MIME-typer för teckensnitt:

    • Inbäddad OpenType: applikation/vnd.ms-fontobject

    • OpenType Layout (OTF) font/otf

    • TrueType: font/ttf

    • WOFF 1.0 font/woff

    • WOFF 2.0 font/woff2

    (Bidrag från Sahil Prajapati och Hugo van Kemenade i gh-84852.)

  • Lägg till RFC 9559 MIME-typer för Matroska audiovisuella databehållarstrukturer, innehållande:

    • ljud utan video: audio/matroska (.mka)

    • video: video/matroska (.mkv)

    • stereoskopisk video: video/matroska-3d (.mk3d)

    (Bidrag från Hugo van Kemenade i gh-89416.)

  • Lägg till MIME-typer för bilder med RFC:er:

    • RFC 1494: CCITT Grupp 3 (.g3)

    • RFC 3362: Faksimile i realtid, T.38 (.t38)

    • RFC 3745: JPEG 2000 (.jp2), förlängning (.jpx) och sammansatt (.jpm)

    • RFC 3950: Tag Image File Format Fax eXtended, TIFF-FX (.tfx)

    • RFC 4047: Flexibelt bildtransportsystem (.fits)

    • RFC 7903: Enhanced Metafile (.emf) och Windows Metafile (.wmf)

    (Bidrag från Hugo van Kemenade i gh-85957.)

  • Fler ändringar av MIME-typer:

    • RFC 2361: Ändra typ för .avi till video/vnd.avi och för .wav till audio/vnd.wave

    • RFC 4337: Lägg till MPEG-4 audio/mp4 (.m4a)

    • RFC 5334: Lägg till Ogg-media (.oga, .ogg och .ogx)

    • RFC 6713: Lägg till gzip application/gzip (.gz)

    • RFC 9639: Lägg till FLAC audio/flac (.flac)

    • Lägg till 7z application/x-7z-compressed (.7z)

    • Lägg till Android-paketet application/vnd.android.package-archive (.apk) när det inte är strikt

    • Lägg till deb application/x-debian-package (.deb)

    • Lägg till glTF-binär model/gltf-binary (.glb)

    • Lägg till glTF JSON/ASCII model/gltf+json (.gltf)

    • Lägg till M4V video/x-m4v (.m4v)

    • Lägg till PHP application/x-httpd-php (.php)

    • Lägg till RAR application/vnd.rar (.rar)

    • Lägg till RPM application/x-rpm (.rpm)

    • Lägg till STL modell/stl (.stl)

    • Lägg till Windows Media Video video/x-ms-wmv (.wmv)

    • De facto: Lägg till WebM audio/webm (.weba)

    • ECMA-376: Lägg till typerna .docx, .pptx och .xlsx

    • OASIS: Lägg till OpenDocument-typerna .odg, .odp, .ods och .odt

    • W3C: Lägg till EPUB application/epub+zip (.epub)

    (Bidrag från Hugo van Kemenade i gh-129965.)

  • Lägg till RFC 9512 application/yaml MIME-typ för YAML-filer (.yaml och .yml). (Bidrag från Sasha ”Nelie” Chernykh och Hugo van Kemenade i gh-132056.)

multiprocessing

operator

  • Två nya funktioner operator.is_none() och operator.is_not_none() har lagts till, så att operator.is_none(obj) är ekvivalent med obj är None och operator.is_not_none(obj) är ekvivalent med obj är inte None. (Bidrag från Raymond Hettinger och Nico Mexis i gh-115808.)

os

os.sökväg

sökväg

  • Lägg till metoder i pathlib.Path för att rekursivt kopiera eller flytta filer och kataloger:

    • copy() kopierar ett fil- eller katalogträd till en destination.

    • copy_into() kopierar in en destinationskatalog.

    • move() flyttar ett fil- eller katalogträd till en destination.

    • move_into() flyttar in i en destinationskatalog.

    (Bidrag från Barney Gale i gh-73991.)

  • Lägg till attributet pathlib.Path.info, som lagrar ett objekt som implementerar protokollet pathlib.types.PathInfo (också nytt). Objektet stöder frågor om filtyp och intern cachelagring av stat()-resultat. Path-objekt som genereras av iterdir() initialiseras med filtypsinformation som hämtas genom att skanna den överordnade katalogen. (Bidrag från Barney Gale i gh-125413.)

pdb

  • Hårdkodade brytpunkter (breakpoint() och pdb.set_trace()) återanvänder nu den senaste Pdb-instansen som anropar set_trace(), istället för att skapa en ny varje gång. Som ett resultat bevaras alla instansspecifika data som display och commands över hårdkodade brytpunkter. (Bidrag från Tian Gao i gh-121450.)

  • Lägg till ett nytt argument mode till pdb.Pdb. Inaktivera kommandot restart när pdb är i inline-läge. (Bidrag från Tian Gao i gh-123757.)

  • En bekräftelseprompt kommer att visas när användaren försöker avsluta pdb i inline-läge. y, Y, <Enter> eller EOF kommer att bekräfta avslutningen och anropa sys.exit(), istället för att ge upphov till bdb.BdbQuit. (Bidrag från Tian Gao i gh-124704.)

  • Inline breakpoints som breakpoint() eller pdb.set_trace() kommer alltid att stoppa programmet vid anropande frame och ignorerar skip-mönstret (om det finns något). (Bidrag från Tian Gao i gh-130493.)

  • <tab> i början av raden i pdb flerradig inmatning kommer att fylla i en 4-space indragning nu, istället för att infoga en t karaktär. (Bidrag från Tian Gao i gh-130471.)

  • Auto-indrag införs i pdb flerradig inmatning. Den kommer antingen att behålla indraget på den sista raden eller infoga ett indrag på 4 mellanrum när den upptäcker ett nytt kodblock. (Bidrag från Tian Gao i gh-133350.)

  • $_asynctask läggs till för att komma åt den aktuella asyncio-uppgiften om tillämpligt. (Bidrag från Tian Gao i gh-124367.)

  • pdb.set_trace_async() läggs till för att stödja felsökning av asyncio coroutines. await statements stöds med denna funktion. (Bidrag från Tian Gao i gh-132576.)

  • Källkod som visas i pdb kommer att syntaxmarkeras. Denna funktion kan kontrolleras med samma metoder som PyREPL, utöver det nyligen tillagda colorize-argumentet i pdb.Pdb. (Bidrag från Tian Gao och Łukasz Langa i gh-133355.)

gurka

  • Ställ in standardprotokollversionen på pickle-modulen till 5. För mer information, se pickle protocols.

  • Lägg till anteckningar för pickle-serialiseringsfel som gör det möjligt att identifiera källan till felet. (Bidrag från Serhiy Storchaka i gh-122213.)

plattform

pydoc

  • Annotationer i hjälptexter visas nu vanligtvis i ett format som ligger närmare originalkällans. (Bidrag från Jelle Zijlstra i gh-101552.)

kortplats

  • Förbättrat och åtgärdat stöd för Bluetooth-uttag.

    • Fixa stöd för Bluetooth-sockets på NetBSD och DragonFly BSD. (Bidrag från Serhiy Storchaka i gh-132429.)

    • Fixar stöd för BTPROTO_HCI på FreeBSD. (Bidrag från Victor Stinner i gh-111178.)

    • Lägg till stöd för BTPROTO_SCO på FreeBSD. (Bidrag från Serhiy Storchaka i gh-85302.)

    • Lägg till stöd för cid och bdaddr_type i adressen för BTPROTO_L2CAP på FreeBSD. (Bidrag från Serhiy Storchaka i gh-132429.)

    • Lägg till stöd för channel i adressen för BTPROTO_HCI på Linux. (Bidrag från Serhiy Storchaka i gh-70145.)

    • Acceptera ett heltal som adress för BTPROTO_HCI på Linux. (Bidrag från Serhiy Storchaka i gh-132099.)

    • Returnerar cid i getsockname() för BTPROTO_L2CAP. (Bidrag från Serhiy Storchaka i gh-132429.)

    • Lägg till många nya konstanter. (Bidrag från Serhiy Storchaka i gh-132734.)

ssl

  • Ange genom ssl.HAS_PHA om ssl-modulen stöder TLSv1.3 post-handskakning av klientautentisering (PHA). (Bidrag från Will Childs-Klein i gh-128036.)

struktur

  • Stöd för C-typerna float complex och double complex i modulen struct (formateringstecken 'F' respektive 'D'). (Bidrag från Sergey B Kirpichev i gh-121249.)

symtomtabell

system

  • Den tidigare odokumenterade specialfunktionen sys.getobjects(), som bara finns i specialiserade Python-versioner, kan nu returnera objekt från andra tolkar än den som den anropas i.

  • Lägg till sys._is_immortal() för att avgöra om ett objekt är immortal. (Bidrag från Peter Bierma i gh-128509.)

  • På FreeBSD innehåller sys.platform inte huvudversionen längre. Den är alltid 'freebsd', istället för 'freebsd13' eller 'freebsd14'.

  • Utlös DeprecationWarning för sys._clear_type_cache(). Denna funktion var föråldrad i Python 3.13 men den gav inte upphov till någon varning under körning.

sys.övervakning

sysconfig

tarfil

gängning

tkinter

  • Gör så att tkinter widgetmetoderna after() och after_idle() accepterar argument som skickas med nyckelord. (Bidrag från Zhikang Yan i gh-126899.)

  • Lägg till möjligheten att ange namn för tkinter.OptionMenu och tkinter.ttk.OptionMenu. (Bidrag från Zhikang Yan i gh-130482.)

sköldpadda

typer

typing

  • types.UnionType och typing.Union är nu alias för varandra, vilket innebär att både gamla tiders unioner (skapade med Union[int, str]) och nya tiders unioner (int | str) nu skapar instanser av samma runtime-typ. Detta förenhetligar beteendet mellan de två syntaxerna, men leder till vissa skillnader i beteende som kan påverka användare som introspekterar typer vid körning:

    • Båda syntaxerna för att skapa en union ger nu samma strängrepresentation i repr(). Till exempel, repr(Union[int, str]) är nu "int | str" istället för "typing.Union[int, str]".

    • Unioner som skapats med den gamla syntaxen cachas inte längre. Tidigare skulle körning av Union[int, str] flera gånger returnera samma objekt (Union[int, str] is Union[int, str] skulle vara True), men nu kommer det att returnera två olika objekt. Användare bör använda == för att jämföra unioner för likhet, inte is. Nya unions har aldrig cachelagrats på det här sättet. Denna ändring kan öka minnesanvändningen för vissa program som använder ett stort antal unioner som skapats genom subskription av typing.Union. Flera faktorer uppväger dock denna kostnad: unioner som används i annoteringar utvärderas inte längre som standard i Python 3.14 på grund av PEP 649; en instans av types.UnionType är i sig mycket mindre än det objekt som returneras av Union[] var i tidigare Python-versioner; och att ta bort cacheminnet sparar också lite utrymme. Det är därför osannolikt att denna ändring kommer att orsaka en betydande ökning av minnesanvändningen för de flesta användare.

    • Tidigare implementerades gammaldags unioner med hjälp av den privata klassen typing._UnionGenericAlias. Denna klass behövs inte längre för implementationen, men den har behållits för bakåtkompatibilitet, med borttagning planerad till Python 3.17. Användare bör använda dokumenterade introspektionshjälpmedel som typing.get_origin() och typing.get_args() istället för att förlita sig på privata implementationsdetaljer.

    • Det är nu möjligt att använda typing.Union själv i isinstance()-kontroller. Till exempel kommer isinstance(int | str, typing.Union) att returnera True; tidigare gav detta upphov till TypeError.

    • Attributet __args__ för typing.Union-objekt är inte längre skrivbart.

    • Det är inte längre möjligt att ange några attribut på typing.Union-objekt. Detta fungerade bara för dunder-attribut i tidigare versioner, var aldrig dokumenterat att fungera och var subtilt trasigt i många fall.

    (Bidrag från Jelle Zijlstra i gh-105499.)

  • typing.TypeAliasType stöder nu uppackning av stjärnor.

unicodedata

  • Unicode-databasen har uppdaterats till Unicode 16.0.0.

unittest

urllib

  • Uppgradera HTTP digest-autentiseringsalgoritmen för urllib.request genom att stödja SHA-256 digest-autentisering enligt specifikationen i RFC 7616. (Bidrag från Calvin Bui i gh-128193.)

  • Förbättrad ergonomi och efterlevnad av standarder vid analys och utgivning av URL:er för file:.

    I urllib.request.url2pathname():

    • Acceptera en komplett URL när det nya argumentet require_scheme är satt till true.

    • Avvisa URL-behörighet om den matchar det lokala värdnamnet.

    • Kassera URL-behörighet om den löser upp till en lokal IP-adress när det nya resolve_host-argumentet är satt till true.

    • Kassera URL-fråga och fragmentkomponenter.

    • Utlös URLError om en URL-auktoritet inte är lokal, utom på Windows där vi returnerar en UNC-sökväg som tidigare.

    I urllib.request.pathname2url():

    • Returnerar en komplett URL när det nya argumentet add_scheme är satt till true.

    • Inkludera en tom URL-auktoritet när en sökväg börjar med ett snedstreck. Till exempel konverteras sökvägen /etc/hosts till URL:en ///etc/hosts.

    I Windows konverteras inte längre enhetsbokstäver till versaler, och :-tecken som inte följer efter en enhetsbokstav orsakar inte längre ett OSError-undantag.

    (Bidrag från Barney Gale i gh-125866.)

uuid

webbläsare

  • Namn i miljövariabeln BROWSER kan nu hänvisa till redan registrerade webbläsare för modulen webbrowser, i stället för att alltid generera ett nytt webbläsarkommando.

    Detta gör det möjligt att ställa in BROWSER till värdet för en av de webbläsare som stöds på macOS.

zipfile

Optimeringar

asyncio

  • Standardresultat för benchmark har förbättrats med 10-20% efter implementeringen av en ny dubbel länkad lista per tråd för native tasks, vilket också minskar minnesanvändningen. Detta gör det möjligt för externa introspektionsverktyg som python -m asyncio pstree att introspektera samtalsgrafen för asyncio-uppgifter som körs i alla trådar. (Bidrag från Kumar Aditya i gh-107803.)

  • Modulen har nu förstklassigt stöd för free-threading builds. Detta möjliggör parallell körning av flera händelseslingor över olika trådar, som skalar linjärt med antalet trådar. (Bidrag från Kumar Aditya i gh-128002.)

base64

  • b16decode() är nu upp till sex gånger snabbare. (Bidrag från Bénédikt Tran, Chris Markiewicz och Adam Turner i gh-118761.)

bdb

  • Den grundläggande felsökaren har nu en sys.monitoring-baserad backend, som kan väljas genom att skicka 'monitoring' till Bdb-klassens nya backend-parameter. (Bidrag från Tian Gao i gh-124533.)

difflib

  • Funktionen IS_LINE_JUNK() är nu upp till dubbelt så snabb. (Bidrag från Adam Turner och Semyon Moroz i gh-130167.)

gc

  • Den nya inkrementella skräpsamlaren innebär att maximala pauser minskas med en storleksordning eller mer för större högar.

    På grund av denna optimering har betydelsen av resultaten för get_threshold() och set_threshold() ändrats, tillsammans med get_count() och get_stats().

    • För bakåtkompatibilitet fortsätter get_threshold() att returnera en tupel med tre element. Det första värdet är tröskelvärdet för unga samlingar, som tidigare. Det andra värdet bestämmer hastigheten med vilken den gamla samlingen skannas (standardvärdet är 10, och högre värden innebär att den gamla samlingen skannas långsammare). Det tredje värdet är nu meningslöst och är alltid noll.

    • set_threshold() ignorerar nu alla objekt efter det andra.

    • get_count() och get_stats() fortsätter att returnera samma resultatformat. Den enda skillnaden är att i stället för att resultaten hänvisar till de unga, åldrande och gamla generationerna, hänvisar resultaten till den unga generationen och den åldrande och samlande utrymmena i den gamla generationen.

    Sammanfattningsvis kan sägas att kod som försöker manipulera beteendet hos cycle GC kanske inte fungerar exakt som avsett, men det är mycket osannolikt att den är skadlig. All annan kod kommer att fungera alldeles utmärkt.

    (Bidrag från Mark Shannon i gh-108362.)

io

  • Öppning och läsning av filer kräver nu färre systemanrop. Läsning av en liten fil som finns i operativsystemets cacheminne går upp till 15 % snabbare. (Bidrag från Cody Maloney och Victor Stinner i gh-120754 och gh-90102.)

sökväg

  • Path.read_bytes använder nu obuffrad läge för att öppna filer, vilket gör att det går mellan 9% och 17% snabbare att läsa hela filen. (Bidrag från Cody Maloney i gh-120754.)

pdb

uuid

  • uuid3() och uuid5() är nu båda ungefär 40% snabbare för 16-bytesnamn och 20% snabbare för 1024-bytesnamn. Prestandan för längre namn är oförändrad. (Bidrag från Bénédikt Tran i gh-128150.)

  • uuid4() är nu cirka 30% snabbare. (Bidrag från Bénédikt Tran i gh-128150.)

zlib

  • I Windows används nu zlib-ng som implementering av modulen zlib i standardbinärerna. Det finns inga kända inkompatibiliteter mellan zlib-ng och den tidigare använda zlib-implementeringen. Detta bör resultera i bättre prestanda på alla komprimeringsnivåer.

    Det är värt att notera att zlib.Z_BEST_SPEED (1) kan resultera i betydligt mindre komprimering än den tidigare implementeringen, samtidigt som komprimeringstiden minskas avsevärt.

    (Bidrag från Steve Dower i gh-91349.)

Borttagen

argparse

  • Ta bort parametrarna type, choices och metavar från BooleanOptionalAction. Dessa har varit föråldrade sedan Python 3.12. (Bidrag från Nikita Sobolev i gh-118805.)

  • Anrop av add_argument_group() på en argumentgrupp ger nu ett ValueError. På samma sätt ger add_argument_group() eller add_mutually_exclusive_group() på en ömsesidigt exklusiv grupp nu båda ValueErrors. Denna ”nästning” har aldrig stödts, fungerade ofta inte korrekt och exponerades oavsiktligt genom arv. Denna funktionalitet har varit föråldrad sedan Python 3.11. (Bidrag från Savannah Ostrowski i gh-127186.)

ast

  • Ta bort följande klasser, som är föråldrade alias för Constant sedan Python 3.8 och har utfärdat föråldringsvarningar sedan Python 3.12:

    • Bytes

    • Ellipsis

    • NameConstant

    • Num

    • Str

    Som en följd av dessa borttagningar kommer användardefinierade metoderna visit_Num, visit_Str, visit_Bytes, visit_NameConstant och visit_Ellipsis på anpassade NodeVisitor-underklasser inte längre att anropas när NodeVisitor-underklassen besöker en AST. Definiera istället en metod visit_Constant.

    (Bidrag från Alex Waygood i gh-119562.)

  • Ta bort följande föråldrade egenskaper på ast.Constant, som fanns för kompatibilitet med de nu borttagna AST-klasserna:

    • Constant.n

    • Constant.s

    Använd istället Constant.value. (Bidrag från Alex Waygood i gh-119562.)

asyncio

  • Ta bort följande klasser, metoder och funktioner, som har blivit föråldrade sedan Python 3.12:

    • AbstractChildWatcher

    • FastChildWatcher

    • MultiLoopChildWatcher

    • PidfdChildWatcher

    • SafeChildWatcher

    • ThreadedChildWatcher

    • AbstractEventLoopPolicy.get_child_watcher()

    • AbstractEventLoopPolicy.set_child_watcher()

    • get_child_watcher()

    • set_child_watcher()

    (Bidrag från Kumar Aditya i gh-120804.)

  • asyncio.get_event_loop() genererar nu ett RuntimeError om det inte finns någon aktuell händelseslinga och skapar inte längre implicit en händelseslinga.

    (Bidrag från Kumar Aditya i gh-126353.)

    Det finns några mönster som använder asyncio.get_event_loop(), de flesta av dem kan ersättas med asyncio.run().

    Om du kör en asynkron funktion använder du helt enkelt asyncio.run().

    Före:

    async def main():
    ...


loop = asyncio.get_event_loop()
försök:
    loop.run_until_complete(main())
slutligen:
    loop.close()

    Efter:

    async def main():
    ...

asyncio.run(main())

    Om du behöver starta något, t.ex. en server som lyssnar på en socket och sedan köra för evigt, använd asyncio.run() och en asyncio.Event.

    Före:

    def start_server(loop): ...

loop = asyncio.get_event_loop()
try:
    start_server(loop)
    loop.run_forever()
finally:
    loop.close()

    Efter:

    def start_server(loop): ...

async def main():
    start_server(asyncio.get_running_loop())
    await asyncio.Event().wait()

asyncio.run(main())

    Om du behöver köra något i en händelseslinga och sedan köra lite blockerande kod runt det, använd asyncio.Runner.

    Före:

    async def operation_one(): ...
def blocking_code(): ...
async def operation_two(): ...

loop = asyncio.get_event_loop()
try:
    loop.run_until_complete(operation_one())
    blocking_code()
    loop.run_until_complete(operation_two())
finally:
    loop.close()

    Efter:

    async def operation_one(): ...
def blocking_code(): ...
async def operation_two(): ...

with asyncio.Runner() as runner:
    runner.run(operation_one())
    blocking_code()
    runner.run(operation_two())

samlingar.abc

  • Ta bort ByteString, som har varit föråldrat sedan Python 3.12. (Bidrag från Nikita Sobolev i gh-118803.)

e-post

  • Ta bort parametern isdst från email.utils.localtime(), som blev föråldrad i och har ignorerats sedan Python 3.12. (Bidrag från Hugo van Kemenade i gh-118798.)

importlib.abc

itertools

  • Ta bort stöd för kopierings-, deepcopy- och pickle-operationer från itertools-iteratorer. Dessa har genererat en DeprecationWarning sedan Python 3.12. (Bidrag från Raymond Hettinger i gh-101588.)

sökväg

  • Ta bort stöd för att skicka ytterligare nyckelordsargument till Path. I tidigare versioner ignorerades sådana argument. (Bidrag från Barney Gale i gh-74033.)

  • Ta bort stöd för att skicka ytterligare positionsargument till PurePath.relative_to() och is_relative_to(). I tidigare versioner fogades sådana argument till other. (Bidrag från Barney Gale i gh-78707.)

pkgutil

  • Ta bort funktionerna get_loader() och find_loader(), som har blivit föråldrade sedan Python 3.12. (Bidrag från Bénédikt Tran i gh-97850.)

pty

  • Ta bort funktionerna master_open() och slave_open(), som har blivit föråldrade sedan Python 3.12. Använd istället pty.openpty(). (Bidrag från Nikita Sobolev i gh-118824.)

sqlite3

  • Ta bort version och version_info från modulen sqlite3; använd sqlite_version och sqlite_version_info för det faktiska versionsnumret för runtime-biblioteket SQLite. (Bidrag från Hugo van Kemenade i gh-118924.)

  • Att använda en sekvens av parametrar med namngivna platshållare ger nu ett ProgrammingError, eftersom detta har blivit föråldrat sedan Python 3.12. (Bidrag från Erlend E. Aasland i gh-118928 och gh-101693.)

typing

  • Ta bort ByteString, som har varit föråldrat sedan Python 3.12. (Bidrag från Nikita Sobolev i gh-118803.)

urllib

  • Ta bort klassen Quoter från urllib.parse, som har blivit föråldrad sedan Python 3.11. (Bidrag från Nikita Sobolev i gh-118827.)

  • Ta bort klasserna URLopener och FancyURLopener från urllib.request, som har blivit föråldrade sedan Python 3.3.

    myopener.open() kan ersättas med urlopen(). myopener.retrieve() kan ersättas med urlretrieve(). Anpassningar av öppningsklasserna kan ersättas genom att skicka anpassade hanterare till build_opener(). (Bidrag från Barney Gale i gh-84850.)

Föråldrat

Väntar på borttagning i Python 3.15

  • Importsystemet:

    • Att ställa in __cached__ på en modul samtidigt som man misslyckas med att ställa in __spec__.cached är föråldrat. I Python 3.15 kommer __cached__ inte längre att anges eller tas i beaktande av importsystemet eller standardbiblioteket. (gh-97879)

    • Att ställa in __package__ på en modul utan att ställa in __spec__.parent är föråldrat. I Python 3.15 kommer __package__ inte längre att anges eller tas i beaktande av importsystemet eller standardbiblioteket. (gh-97879)

  • ctypes:

    • Den odokumenterade ctypes.SetPointerType()-funktionen är föråldrad sedan Python 3.13.

  • http.server:

    • Den föråldrade och sällan använda CGIHTTPRequestHandler har utgått sedan Python 3.13. Ingen direkt ersättare finns. Anything är bättre än CGI för att koppla en webbserver till en request-hanterare.

    • Flaggan --cgi till kommandoradsgränssnittet python -m http.server har utgått sedan Python 3.13.

  • importlib:

    • load_module() metod: använd exec_module() istället.

  • locale:

  • pathlib:

  • plattform:

    • java_ver() har utgått sedan Python 3.13. Denna funktion är endast användbar för Jython-stöd, har ett förvirrande API och är i stort sett otestad.

  • sysconfig:

  • threading:

    • RLock() kommer inte att ta några argument i Python 3.15. Att skicka några argument har varit föråldrat sedan Python 3.14, eftersom Python-versionen inte tillåter några argument, men C-versionen tillåter valfritt antal positionella eller nyckelordsargument och ignorerar varje argument.

  • types:

  • typning:

    • Den odokumenterade syntaxen för nyckelordsargument för att skapa NamedTuple-klasser (till exempel Point = NamedTuple("Point", x=int, y=int)) har utgått sedan Python 3.13. Använd den klassbaserade syntaxen eller den funktionella syntaxen istället.

    • När man använder den funktionella syntaxen för TypedDicts, att inte skicka ett värde till parametern fields (TD = TypedDict("TD")) eller att skicka None (TD = TypedDict("TD", None)) har varit föråldrat sedan Python 3.13. Använd class TD(TypedDict): pass eller TD = TypedDict("TD", {}) för att skapa en TypedDict med noll fält.

    • Dekoratorfunktionen typing.no_type_check_decorator() har varit föråldrad sedan Python 3.13. Efter åtta år i modulen typing har den ännu inte fått stöd av någon större typkontroll.

  • våg:

  • zipimport:

Väntar på borttagning i Python 3.16

Väntar på borttagning i Python 3.17

  • typning:

    • Före Python 3.14 implementerades gamla tiders unioner med hjälp av den privata klassen typing._UnionGenericAlias. Denna klass behövs inte längre för implementationen, men den har behållits för bakåtkompatibilitet, med borttagning planerad till Python 3.17. Användare bör använda dokumenterade introspektionshjälpmedel som typing.get_origin() och typing.get_args() istället för att förlita sig på privata implementationsdetaljer.

Väntar på borttagning i Python 3.19

  • ctypes:

    • Implicit byte till MSVC-kompatibel struct-layout genom att ställa in _pack_ men inte _layout_ på icke-Windows-plattformar.

Avser att tas bort i framtida versioner

Följande API:er kommer att tas bort i framtiden, även om det för närvarande inte finns något datum för när de ska tas bort.

  • argparse:

    • Nesting av argumentgrupper och nesting av ömsesidigt uteslutande grupper är avförda.

    • Att skicka det odokumenterade nyckelordsargumentet prefix_chars till add_argument_group() är nu föråldrat.

    • Typomvandlaren argparse.FileType är föråldrad.

  • builtins:

    • bool(NotImplemented).

    • Generatorer: throw(type, exc, tb) och athrow(type, exc, tb) signaturen är förbrukad: använd throw(exc) och athrow(exc) istället, signaturen med ett enda argument.

    • För närvarande accepterar Python numeriska literaler omedelbart följt av nyckelord, till exempel 0in x, 1or x, 0if 1else 2. Det tillåter förvirrande och tvetydiga uttryck som [0x1for x in y] (som kan tolkas som [0x1 for x in y] eller [0x1f or x in y]). En syntaxvarning visas om den numeriska litteralen omedelbart följs av något av nyckelorden and, else, for, if, in, is och or. I en framtida version kommer det att ändras till ett syntaxfel. (gh-87999)

    • Stöd för metoderna __index__() och __int__() som returnerar icke-int-typer: dessa metoder kommer att behöva returnera en instans av en strikt underklass av int.

    • Stöd för metoden __float__() som returnerar en strikt underklass av float: dessa metoder måste returnera en instans av float.

    • Stöd för metoden __complex__() som returnerar en strikt underklass av complex: dessa metoder måste returnera en instans av complex.

    • Delegering av int() till metoden __trunc__().

    • Att skicka ett komplext tal som real eller imag argument i complex()-konstruktorn är nu föråldrat; det bör endast skickas som ett enda positionellt argument. (Bidrag från Serhiy Storchaka i gh-109218.)

  • calendar: Konstanterna calendar.January och calendar.February är föråldrade och ersätts av calendar.JANUARY och calendar.FEBRUARY. (Bidrag från Prince Roshan i gh-103636.)

  • codecs: använd open() istället för codecs.open(). (gh-133038)

  • codeobject.co_lnotab: använd istället metoden codeobject.co_lines().

  • datetime:

    • utcnow(): använd datetime.datetime.now(tz=datetime.UTC).

    • utcfromtimestamp(): använd datetime.datetime.fromtimestamp(timestamp, tz=datetime.UTC).

  • gettext: Pluralvärdet måste vara ett heltal.

  • importlib:

    • cache_from_source() Parametern debug_override är föråldrad: använd parametern optimization istället.

  • importlib.metadata:

    • EntryPoints tuple-gränssnitt.

    • Implicit None på returvärden.

  • logging: metoden warn() har utgått sedan Python 3.3, använd warning() istället.

  • mailbox: Användning av StringIO-ingång och textläge är föråldrad, använd BytesIO och binärt läge istället.

  • os: Anropar os.register_at_fork() i flertrådad process.

  • pydoc.ErrorDuringImport: Ett tupelvärde för parametern exc_info är föråldrat, använd en undantagsinstans.

  • re: Strängare regler tillämpas nu för numeriska gruppreferenser och gruppnamn i reguljära uttryck. Endast sekvenser av ASCII-siffror accepteras nu som numeriska referenser. Gruppnamnet i bytesmönster och ersättningssträngar kan nu endast innehålla ASCII-bokstäver och siffror samt understreck. (Bidrag från Serhiy Storchaka i gh-91760.)

  • modulerna sre_compile, sre_constants och sre_parse.

  • shutil: rmtree():s parameter onerror är föråldrad i Python 3.12; använd istället parametern onexc.

  • ssl alternativ och protokoll:

    • ssl.SSLContext utan protokollargument är föråldrad.

    • ssl.SSLContext: set_npn_protocols() and selected_npn_protocol() are deprecated: use ALPN instead.

    • ssl.OP_NO_SSL* alternativ

    • ssl.OP_NO_TLS* alternativ

    • ssl.PROTOCOL_SSLv3

    • ssl.PROTOCOL_TLS

    • ssl.PROTOCOL_TLSv1

    • ssl.PROTOCOL_TLSv1_1

    • ssl.PROTOCOL_TLSv1_2

    • ssl.TLSVersion.SSLv3

    • ssl.TLSVersion.TLSv1

    • ssl.TLSVersion.TLSv1_1

  • threading metoder:

  • typing.Text (gh-92332).

  • Den interna klassen typing._UnionGenericAlias används inte längre för att implementera typing.Union. För att bevara kompatibiliteten med användare som använder denna privata klass, kommer en kompatibilitets-shim att tillhandahållas åtminstone fram till Python 3.17. (Bidrag från Jelle Zijlstra i gh-105499.)

  • unittest.IsolatedAsyncioTestCase: det är förkastligt att returnera ett värde som inte är None från ett testfall.

  • urllib.parse föråldrade funktioner: urlparse() istället

    • splitattr()

    • splithost()

    • splitnport()

    • splitpasswd()

    • splitport()

    • splitquery()

    • splittag()

    • splittype()

    • splituser()

    • splitvärde()

    • to_bytes()

  • wsgiref: SimpleHandler.stdout.write() bör inte göra partiella skrivningar.

  • xml.etree.ElementTree: Att testa sanningsvärdet för en Element är föråldrat. I en framtida version kommer det alltid att returnera True. Föredra istället explicita len(elem) eller elem is not None tester.

  • sys._clear_type_cache() är föråldrad: använd sys._clear_internal_caches() istället.

CPython bytecode-ändringar

  • Ersatte opcode BINARY_SUBSCR med BINARY_OP med oparg NB_SUBSCR. (Bidrag från Irit Katriel i gh-100239.)

Portning till Python 3.14

I det här avsnittet listas tidigare beskrivna ändringar och andra buggfixar som kan kräva ändringar i din kod.

Ändringar i Python API

  • functools.partial är nu en metoddeskriptor. Packa in den i staticmethod() om du vill bevara det gamla beteendet. (Bidrag från Serhiy Storchaka och Dominykas Grigonis i gh-121027.)

  • Garbage collector är nu inkrementell, vilket innebär att beteendet hos gc.collect() ändras något:

    • gc.collect(1): Utför en ökning av skräpinsamlingen, istället för att samla in generation 1.

    • Andra anrop till gc.collect() är oförändrade.

  • Funktionen locale.nl_langinfo() ställer nu tillfälligt in LC_CTYPE-lokaliseringen i vissa fall. Denna tillfälliga ändring påverkar andra trådar. (Bidrag från Serhiy Storchaka i gh-69998.)

  • types.UnionType är nu ett alias för typing.Union, vilket orsakar förändringar i vissa beteenden. Se above för mer information. (Bidrag från Jelle Zijlstra i gh-105499.)

  • Körtidsbeteendet för annoteringar har ändrats på olika sätt; se över för detaljer. Även om den mesta kod som interagerar med annotationer bör fortsätta att fungera, kan vissa odokumenterade detaljer bete sig annorlunda.

Förändringar i byggnaden

  • GNU Autoconf 2.72 krävs nu för att generera configure. (Bidrag från Erlend Aasland i gh-115765.)

  • #pragma-baserad länkning med python3*.lib kan nu stängas av med Py_NO_LINK_LIB. (Bidrag från Jean-Christophe Fillion-Robin i gh-82909.)

PEP 761: Avveckling av PGP-signaturer

PGP-signaturer kommer inte att vara tillgängliga för CPython 3.14 och framåt. Användare som verifierar artefakter måste använda Sigstore verifieringsmaterial för att verifiera CPython-artefakter. Denna förändring i utgivningsprocessen specificeras i PEP 761.

C API-ändringar

Nya funktioner

Begränsade C API-ändringar

Portning till Python 3.14

  • Py_Finalize() raderar nu alla internaliserade strängar. Detta är bakåtkompatibelt med alla C-extensioner som behåller en internerad sträng efter ett anrop till Py_Finalize() och som sedan återanvänds efter ett anrop till Py_Initialize(). Eventuella problem som uppstår på grund av detta beteende kommer normalt att leda till krascher under exekveringen av det efterföljande anropet till Py_Initialize() på grund av åtkomst till oinitialiserat minne. För att åtgärda detta, använd en adressrensare för att identifiera eventuella use-after-free som kommer från en internerad sträng och avallokera den under modulavstängning. (Bidrag från Eddie Elizondo i gh-113601.)

  • C API:t Unicode Exception Objects ger nu upphov till ett TypeError om dess undantagsargument inte är ett UnicodeError-objekt. (Bidrag från Bénédikt Tran i gh-127691.)

Föråldrat

Väntar på borttagning i Python 3.15

Väntar på borttagning i Python 3.16

  • Den medföljande kopian av libmpdec.

Väntar på borttagning i Python 3.18

Avser att tas bort i framtida versioner

Följande API:er är föråldrade och kommer att tas bort, även om det för närvarande inte finns något datum för när de ska tas bort.

Borttagen

  • Att skapa immutable types med mutabla baser var föråldrat sedan 3.12 och ger nu upphov till ett TypeError.

  • Ta bort medlemmen PyDictObject.ma_version_tag som var föråldrad sedan Python 3.12. Använd PyDict_AddWatcher() API istället. (Bidrag från Sam Gross i gh-124296.)

  • Ta bort den privata funktionen _Py_InitializeMain(). Det var ett provisoriskt API som lades till i Python 3.8 av PEP 587. (Bidrag från Victor Stinner i gh-129033.)

  • De odokumenterade API:erna Py_C_RECURSION_LIMIT och PyThreadState.c_recursion_remaining, som lades till i 3.13, tas bort utan en avvecklingsperiod. Använd Py_EnterRecursiveCall() för att skydda mot okontrollerad rekursion i C-kod. (Borttagen i gh-133079, se även gh-130396.)