Novità in Python 3.12

Editor:

Adam Turner

Questo articolo spiega le nuove funzionalità in Python 3.12, rispetto alla versione 3.11. Python 3.12 è stato rilasciato il 2 ottobre 2023. Per i dettagli completi, consultare il changelog.

Vedi anche

PEP 693 – Programma di rilascio di Python 3.12

Sommario – Punti salienti del rilascio

Python 3.12 is a stable release of the Python programming language, with a mix of changes to the language and the standard library. The library changes focus on cleaning up deprecated APIs, usability, and correctness. Of note, the distutils package has been removed from the standard library. Filesystem support in os and pathlib has seen a number of improvements, and several modules have better performance.

Le modifiche al linguaggio si concentrano sull’usabilità, in quanto molte limitazioni dei f-strings sono state rimosse e i suggerimenti “Intendevi dire …” continuano a migliorare. La nuova sintassi dei parametri di tipo e l’istruzione type migliorano l’ergonomia per l’utilizzo di tipi generici e alias di tipo con i checker di tipo statico.

Questo articolo non tenta di fornire una specifica completa di tutte le nuove funzionalità, ma offre invece una panoramica. Per i dettagli completi, dovresti fare riferimento alla documentazione, come il Library Reference e il Language Reference. Se vuoi comprendere l’implementazione completa e la motivazione dietro una modifica, fai riferimento al PEP per una particolare nuova funzionalità; ma tieni presente che i PEP di solito non vengono aggiornati una volta che una funzionalità è stata completamente implementata.

Nuove funzionalità sintattiche:

  • PEP 695, sintassi dei parametri di tipo e l’istruzione type

Nuove funzionalità grammaticali:

Miglioramenti dell’interprete:

Miglioramenti al modello di dati di Python:

Miglioramenti significativi nella libreria standard:

  • La classe pathlib.Path ora supporta la sottoclassificazione

  • Il modulo os ha ricevuto diversi miglioramenti per il supporto di Windows

  • Un’interfaccia a riga di comando interface è stata aggiunta al modulo sqlite3

  • I controlli isinstance() contro i protocolli runtime-checkable godono di un’accelerazione tra due e 20 volte

  • Il pacchetto asyncio ha avuto numerosi miglioramenti di performance, con alcuni benchmark che mostrano un’accelerazione del 75%.

  • Un’interfaccia a riga di comando interface è stata aggiunta al modulo uuid

  • A causa delle modifiche nel PEP 701, la produzione di token tramite il modulo tokenize è fino al 64% più veloce.

Miglioramenti alla sicurezza:

  • Sostituire le implementazioni integrate del modulo hashlib di SHA1, SHA3, SHA2-384, SHA2-512 e MD5 con codice formalmente verificato dal progetto HACL*. Queste implementazioni integrate rimangono come fallback che vengono utilizzate solo quando OpenSSL non le fornisce.

Miglioramenti all’API C:

Miglioramenti all’implementazione di CPython:

  • PEP 709, inlining delle comprensioni

  • Supporto CPython per il profiler perf su Linux

  • Implementare la protezione da overflow dello stack su piattaforme supportate

Nuove funzionalità di typing:

Deprecazioni, rimozioni o restrizioni importanti:

  • PEP 623: Rimuovere wstr dagli oggetti Unicode nell’API C di Python, riducendo la dimensione di ogni oggetto str di almeno 8 byte.

  • PEP 632: Remove the distutils package. See the migration guide for advice replacing the APIs it provided. The third-party Setuptools package continues to provide distutils, if you still require it in Python 3.12 and beyond.

  • gh-95299: Non preinstallare setuptools negli ambienti virtuali creati con venv. Ciò significa che distutils, setuptools, pkg_resources e easy_install non saranno più disponibili di default; per accedervi eseguire pip install setuptools nell’ambiente virtuale attivato.

  • I moduli asynchat, asyncore e imp sono stati rimossi, insieme a diversi alias di metodo di unittest.TestCase.

Nuove Funzionalità

PEP 695: Sintassi dei Parametri di Tipo

Le classi generiche e le funzioni sotto PEP 484 erano dichiarate utilizzando una sintassi verbosa che lasciava poco chiaro l’ambito dei parametri di tipo e richiedeva dichiarazioni esplicite di varianza.

PEP 695 introduce un nuovo modo, più compatto ed esplicito, per creare classi generiche e funzioni:

def max[T](args: Iterable[T]) -> T:
    ...

class list[T]:
    def __getitem__(self, index: int, /) -> T:
        ...

    def append(self, element: T) -> None:
        ...

Inoltre, il PEP introduce un nuovo modo di dichiarare alias di tipo utilizzando l’istruzione type, che crea un’istanza di TypeAliasType:

type Point = tuple[float, float]

Gli alias di tipo possono anche essere generici:

type Point[T] = tuple[T, T]

La nuova sintassi consente di dichiarare parametri TypeVarTuple e ParamSpec, nonché parametri TypeVar con limiti o vincoli:

type IntFunc[**P] = Callable[P, int]  # ParamSpec
type LabeledTuple[*Ts] = tuple[str, *Ts]  # TypeVarTuple
type HashableSequence[T: Hashable] = Sequence[T]  # TypeVar with bound
type IntOrStrSequence[T: (int, str)] = Sequence[T]  # TypeVar with constraints

Il valore degli alias di tipo e i limiti e vincoli delle variabili di tipo creati con questa sintassi sono valutati solo su richiesta (vedi lazy evaluation). Ciò significa che gli alias di tipo possono riferirsi ad altri tipi definiti successivamente nel file.

I parametri di tipo dichiarati attraverso una lista di parametri di tipo sono visibili all’interno dell’ambito della dichiarazione e in qualsiasi ambito annidato, ma non nell’ambito esterno. Ad esempio, possono essere utilizzati nelle annotazioni di tipo per i metodi di una classe generica o nel corpo della classe. Tuttavia, non possono essere utilizzati nell’ambito del modulo dopo che la classe è stata definita. Vedi Type parameter lists per una descrizione dettagliata della semantica di runtime dei parametri di tipo.

Per supportare questa semantica di ambito, è stato introdotto un nuovo tipo di ambito, l”annotation scope. Gli ambiti di annotazione si comportano per lo più come gli ambiti delle funzioni, ma interagiscono in modo diverso con gli ambiti della classe che li contengono. In Python 3.13, le annotazioni saranno valutate negli ambiti di annotazione.

Vedi PEP 695 per ulteriori dettagli.

(PEP scritto da Eric Traut. Implementazione di Jelle Zijlstra, Eric Traut e altri in gh-103764.)

PEP 701: Formalizzazione sintattica delle f-string

PEP 701 rimuove alcune restrizioni sull’uso delle f-string. Gli elementi dell’espressione all’interno delle f-string possono ora essere qualsiasi espressione Python valida, incluse stringhe che riutilizzano la stessa virgoletta della f-string contenente, espressioni multilinea, commenti, backslash e sequenze di escape unicode. Approfondiamo questi aspetti in dettaglio:

  • Riutilizzo delle virgolette: in Python 3.11, riutilizzare le stesse virgolette della f-string contenente genera un’eccezione SyntaxError, costringendo l’utente a utilizzare altre virgolette disponibili (come l’uso delle virgolette doppie o delle virgolette triple se la f-string usa virgolette singole). In Python 3.12, è ora possibile fare cose come questa:

    >>> songs = ['Take me back to Eden', 'Alkaline', 'Ascensionism']
>>> f"This is the playlist: {", ".join(songs)}"
'This is the playlist: Take me back to Eden, Alkaline, Ascensionism'

    Prima di questa modifica non esisteva un limite esplicito su come le f-string potessero essere annidate, ma il fatto che le virgolette delle stringhe non potessero essere riutilizzate all’interno dell’elemento di espressione delle f-string rendeva impossibile annidare le f-string arbitrariamente. Infatti, questa è l’f-string più annidata che poteva essere scritta:

    >>> f"""{f'''{f'{f"{1+1}"}'}'''}"""
'2'

    Poiché ora le f-string possono contenere qualsiasi espressione Python valida all’interno degli elementi di espressione, è ora possibile annidare le f-string arbitrariamente:

    >>> f"{f"{f"{f"{f"{f"{1+1}"}"}"}"}"}"
'2'

  • Espressioni multilinea e commenti: in Python 3.11, le espressioni all’interno delle f-string devono essere definite in una singola riga, anche se l’espressione all’interno della f-string potrebbe normalmente estendersi su più righe (come le liste letterali definite su più righe), rendendole più difficili da leggere. In Python 3.12 è ora possibile definire f-string che si estendono su più righe e aggiungere commenti in linea:

    >>> f"This is the playlist: {", ".join([
...     'Take me back to Eden',  # My, my, those eyes like fire
...     'Alkaline',              # Not acid nor alkaline
...     'Ascensionism'           # Take to the broken skies at last
... ])}"
'This is the playlist: Take me back to Eden, Alkaline, Ascensionism'

  • Backslash e caratteri unicode: prima di Python 3.12, le espressioni f-string non potevano contenere alcun carattere \. Questo influenzava anche le sequenze di escape unicode (come \N{snowman}) poiché contengono la parte \N che prima non poteva far parte degli elementi di espressione delle f-string. Ora puoi definire espressioni come questa:

    >>> print(f"This is the playlist: {"\n".join(songs)}")
This is the playlist: Take me back to Eden
Alkaline
Ascensionism
>>> print(f"This is the playlist: {"\N{BLACK HEART SUIT}".join(songs)}")
This is the playlist: Take me back to Eden♥Alkaline♥Ascensionism

Vedi PEP 701 per ulteriori dettagli.

Come effetto collaterale positivo di come questa funzione è stata implementata (parsing delle f-string con il PEG parser), ora i messaggi di errore per le f-string sono più precisi e includono l’esatta posizione dell’errore. Ad esempio, in Python 3.11, la seguente f-string genera un’eccezione SyntaxError:

>>> my_string = f"{x z y}" + f"{1 + 1}"
  File "<stdin>", line 1
    (x z y)
     ^^^
SyntaxError: f-string: invalid syntax. Perhaps you forgot a comma?

ma il messaggio di errore non include l’esatta posizione dell’errore all’interno della riga e ha anche l’espressione circondata artificialmente da parentesi. In Python 3.12, poiché le f-string sono parse con il PEG parser, i messaggi di errore possono essere più precisi e mostrare l’intera riga:

>>> my_string = f"{x z y}" + f"{1 + 1}"
  File "<stdin>", line 1
    my_string = f"{x z y}" + f"{1 + 1}"
                   ^^^
SyntaxError: invalid syntax. Perhaps you forgot a comma?

(Contributi da Pablo Galindo, Batuhan Taskaya, Lysandros Nikolaou, Cristián Maureira-Fredes e Marta Gómez in gh-102856. PEP scritto da Pablo Galindo, Batuhan Taskaya, Lysandros Nikolaou e Marta Gómez).

PEP 684: Un GIL per interprete

PEP 684 introduce un GIL per interprete, in modo che gli interpreti secondari possano ora essere creati con un GIL unico per interprete. Questo consente ai programmi Python di sfruttare appieno i core della CPU multipli. Attualmente è disponibile solo tramite la C-API, sebbene si preveda una API Python per la versione 3.13.

Usa la nuova funzione Py_NewInterpreterFromConfig() per creare un interprete con il proprio GIL:

PyInterpreterConfig config = {
    .check_multi_interp_extensions = 1,
    .gil = PyInterpreterConfig_OWN_GIL,
};
PyThreadState *tstate = NULL;
PyStatus status = Py_NewInterpreterFromConfig(&tstate, &config);
if (PyStatus_Exception(status)) {
    return -1;
}
/* The new interpreter is now active in the current thread. */

For further examples how to use the C-API for sub-interpreters with a per-interpreter GIL, see Modules/_xxsubinterpretersmodule.c.

(Contributi da Eric Snow in gh-104210, ecc.)

PEP 669: Monitoraggio a basso impatto per CPython

PEP 669 definisce una nuova API per profiler, debugger e altri strumenti per monitorare eventi in CPython. Copre una vasta gamma di eventi, inclusi chiamate, ritorni, righe, eccezioni, salti e altro. Questo significa che paghi solo per quello che usi, fornendo supporto per strumenti di debug e copertura a quasi zero overhead. Vedi sys.monitoring per i dettagli.

(Contributi da Mark Shannon in gh-103082.)

PEP 688: Rendere accessibile il protocollo buffer in Python

PEP 688 introduce un modo per utilizzare il protocollo buffer dal codice Python. Le classi che implementano il metodo __buffer__() sono ora utilizzabili come tipi di buffer.

Il nuovo ABC collections.abc.Buffer fornisce un modo standard per rappresentare oggetti buffer, ad esempio nelle annotazioni di tipo. Il nuovo enumerativo inspect.BufferFlags rappresenta i flag che possono essere utilizzati per personalizzare la creazione del buffer. (Contributo di Jelle Zijlstra in gh-102500.)

PEP 709: Inlining delle comprehension

Le comprehension di dizionari, liste e set sono ora inlined, piuttosto che creare un nuovo oggetto funzione monouso per ogni esecuzione della comprehension. Questo accelera l’esecuzione di una comprehension fino a due volte. Vedi PEP 709 per ulteriori dettagli.

Le variabili di iterazione delle comprehension rimangono isolate e non sovrascrivono una variabile con lo stesso nome nell’ambito esterno, né sono visibili dopo la comprehension. L’inlining comporta alcuni cambiamenti di comportamento visibili:

  • Nei traceback non c’è più un frame separato per la comprehension, e il tracciamento/profiling non mostra più la comprehension come una chiamata di funzione.

  • Il modulo symtable non produrrà più tabelle simbolo figlie per ogni comprehension; invece, le variabili locali della comprehension saranno incluse nella tabella simbolo della funzione principale.

  • Chiamando locals() all’interno di una comprehension ora include variabili dall’esterno della comprehension e non include più la variabile sintetica .0 per «l’argomento» della comprehension.

  • Una comprehension che itera direttamente su locals() (ad es. [k for k in locals()]) potrebbe vedere «RuntimeError: dimensione del dizionario cambiata durante l’iterazione» quando eseguita sotto tracciamento (ad es. misurazione della copertura del codice). Questo è lo stesso comportamento già visto, ad es. for k in locals():. Per evitare l’errore, prima crea una lista di chiavi da iterare: keys = list(locals()); [k for k in keys].

(Contributi di Carl Meyer e Vladimir Matveev in PEP 709.)

Messaggi di errore migliorati

  • I moduli della libreria standard sono ora potenzialmente suggeriti come parte dei messaggi di errore visualizzati dall’interprete quando un’eccezione NameError viene sollevata a livello superiore. (Contributi da Pablo Galindo in gh-98254.)

    >>> sys.version_info
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'sys' is not defined. Did you forget to import 'sys'?

  • Migliora il suggerimento di errore per le eccezioni NameError per le istanze. Ora, se un’eccezione NameError viene sollevata in un metodo e l’istanza ha un attributo esattamente uguale al nome nell’eccezione, il suggerimento includerà self.<NAME> invece della corrispondenza più vicina nell’ambito del metodo. (Contributi da Pablo Galindo in gh-99139.)

    >>> class A:
...    def __init__(self):
...        self.blech = 1
...
...    def foo(self):
...        somethin = blech
...
>>> A().foo()
Traceback (most recent call last):
  File "<stdin>", line 1
    somethin = blech
               ^^^^^
NameError: name 'blech' is not defined. Did you mean: 'self.blech'?

  • Migliora il messaggio di errore SyntaxError quando l’utente digita import x from y invece di from y import x. (Contributi da Pablo Galindo in gh-98931.)

    >>> import a.y.z from b.y.z
Traceback (most recent call last):
  File "<stdin>", line 1
    import a.y.z from b.y.z
    ^^^^^^^^^^^^^^^^^^^^^^^
SyntaxError: Did you mean to use 'from ... import ...' instead?

  • Le eccezioni ImportError sollevate da dichiarazioni di from <module> import <name> fallite includono ora suggerimenti per il valore di <name> basati sui nomi disponibili in <module>. (Contributi da Pablo Galindo in gh-91058.)

    >>> from collections import chainmap
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ImportError: cannot import name 'chainmap' from 'collections'. Did you mean: 'ChainMap'?

Altre modifiche al Linguaggio

  • Il parser ora solleva SyntaxError quando analizza il codice sorgente contenente byte nulli. (Contributo di Pablo Galindo in gh-96670.)

  • Una coppia carattere-barra rovesciata che non è una sequenza di escape valida ora genera un SyntaxWarning, invece di un DeprecationWarning. Ad esempio, re.compile("\d+\.\d+") ora emette un SyntaxWarning ("\d" è una sequenza di escape non valida, utilizzare stringhe raw per le espressioni regolari: re.compile(r"\d+\.\d+")). In una futura versione di Python, verrà infine sollevato un SyntaxError, invece di un SyntaxWarning. (Contributo di Victor Stinner in gh-98401.)

  • Le sequenze di escape ottali con valore maggiore di 0o377 (es: "\477"), deprecate in Python 3.11, ora producono un SyntaxWarning, invece di un DeprecationWarning. In una futura versione di Python, diventeranno infine un SyntaxError. (Contributo di Victor Stinner in gh-98401.)

  • Le variabili utilizzate nella parte target delle comprensioni che non vengono memorizzate possono ora essere utilizzate nelle espressioni di assegnazione (:=). Ad esempio, in [(b := 1) for a, b.prop in some_iter], l’assegnazione a b è ora consentita. Si noti che l’assegnazione a variabili memorizzate nella parte target delle comprensioni (come a) è ancora vietata, come per PEP 572. (Contributo di Nikita Sobolev in gh-100581.)

  • Le eccezioni sollevate nel metodo __set_name__ di una classe o di un tipo non vengono più avvolte da un RuntimeError. Le informazioni di contesto vengono aggiunte all’eccezione come nota PEP 678. (Contributo di Irit Katriel in gh-77757.)

  • Quando una costruzione try-except* gestisce l’intero ExceptionGroup e solleva un’altra eccezione, quella eccezione non è più avvolta in un ExceptionGroup. Anche modificato nella versione 3.11.4. (Contributo di Irit Katriel in gh-103590.)

  • Il Garbage Collector ora viene eseguito solo sul meccanismo eval breaker del ciclo di valutazione del bytecode Python invece delle allocazioni di oggetti. Il GC può anche essere eseguito quando viene chiamato PyErr_CheckSignals() in modo che le estensioni C che devono essere eseguite per lungo tempo senza eseguire alcun codice Python abbiano anche la possibilità di eseguire periodicamente il GC. (Contributo di Pablo Galindo in gh-97922.)

  • Tutti i callable builtin e delle estensioni che si aspettano parametri booleani ora accettano argomenti di qualsiasi tipo invece di soli bool e int. (Contributo di Serhiy Storchaka in gh-60203.)

  • memoryview supporta ora il tipo half-float (il codice di formato «e»). (Contributo di Donghee Na e Antoine Pitrou in gh-90751.)

  • Gli oggetti slice sono ora hashabili, consentendo loro di essere utilizzati come chiavi di dizionari e elementi di insiemi. (Contributo di Will Bradshaw, Furkan Onder e Raymond Hettinger in gh-101264.)

  • sum() utilizza ora la sommatoria Neumaier per migliorare la precisione e la commutatività quando si sommano float o mix di int e float. (Contributo di Raymond Hettinger in gh-100425.)

  • ast.parse() solleva ora SyntaxError invece di ValueError quando analizza il codice sorgente contenente byte nulli. (Contributo di Pablo Galindo in gh-96670.)

  • I metodi di estrazione in tarfile, e shutil.unpack_archive(), hanno un nuovo argomento filter che consente di limitare le funzionalità tar che possono essere sorprendenti o pericolose, come la creazione di file al di fuori della directory di destinazione. Vedere tarfile extraction filters per ulteriori dettagli. In Python 3.14, il valore predefinito passerà a 'data'. (Contributo di Petr Viktorin in PEP 706.)

  • Le istanze di types.MappingProxyType sono ora hashabili se la mappa sottostante è hashabile. (Contributo di Serhiy Storchaka in gh-87995.)

  • Aggiungo supporto per il profiler perf attraverso la nuova variabile di ambiente PYTHONPERFSUPPORT e l’opzione da riga di comando -X perf, così come le nuove funzioni sys.activate_stack_trampoline(), sys.deactivate_stack_trampoline() e sys.is_stack_trampoline_active(). (Progettazione di Pablo Galindo. Contributo di Pablo Galindo e Christian Heimes con contributi di Gregory P. Smith [Google] e Mark Shannon in gh-96123.)

Nuovi Moduli

  • Nessuno.

Moduli Migliorati

array

asyncio

calendar

csv

dis

  • Gli opcode delle pseudo-istruzioni (che sono utilizzati dal compilatore ma non compaiono nel bytecode eseguibile) sono ora esposti nel modulo dis. HAVE_ARGUMENT è ancora rilevante per i reali opcode, ma non è utile per le pseudo-istruzioni. Usare la nuova collezione dis.hasarg al suo posto. (Contributo di Irit Katriel in gh-94216.)

  • Aggiungo la collezione dis.hasexc per indicare le istruzioni che impostano un gestore di eccezioni. (Contributo di Irit Katriel in gh-94216.)

fractions

importlib.resources

inspect

itertools

  • Add itertools.batched() for collecting into even-sized tuples where the last batch may be shorter than the rest. (Contributed by Raymond Hettinger in gh-98363.)

matematica

  • Aggiungi math.sumprod() per calcolare una somma di prodotti. (Contribuito da Raymond Hettinger in gh-100485.)

  • Estendere math.nextafter() per includere un argomento steps per muoversi su o giù di più passi alla volta. (Contribuito da Matthias Goergens, Mark Dickinson, e Raymond Hettinger in gh-94906.)

os

  • Aggiungi os.PIDFD_NONBLOCK per aprire un file descriptor per un processo con os.pidfd_open() in modalità non bloccante. (Contribuito da Kumar Aditya in gh-93312.)

  • os.DirEntry ora include un metodo os.DirEntry.is_junction() per verificare se l’elemento è una giunzione. (Contribuito da Charles Machalow in gh-99547.)

  • Aggiungi le funzioni os.listdrives(), os.listvolumes() e os.listmounts() su Windows per enumerare unità, volumi e punti di montaggio. (Contribuito da Steve Dower in gh-102519.)

  • Le funzioni os.stat() e os.lstat() sono ora più precise su Windows. Il campo st_birthtime verrà ora riempito con il tempo di creazione del file e st_ctime è deprecato ma contiene ancora il tempo di creazione (ma in futuro restituirà l’ultima modifica ai metadati, per coerenza con altre piattaforme). st_dev può essere fino a 64 bit e st_ino fino a 128 bit a seconda del file system, e st_rdev è sempre impostato su zero anziché valori errati. Entrambe le funzioni possono essere significativamente più veloci nelle nuove versioni di Windows. (Contribuito da Steve Dower in gh-99726.)

os.path

pathlib

pdb

  • Aggiungi variabili di convenienza per tenere temporaneamente i valori per la sessione di debug e fornire un accesso rapido a valori come il frame corrente o il valore di ritorno. (Contribuito da Tian Gao in gh-103693.)

random

shutil

  • shutil.make_archive() ora passa l’argomento root_dir agli archiviatori personalizzati che lo supportano. In questo caso, non cambia più temporaneamente la directory di lavoro corrente del processo in root_dir per eseguire l’archiviazione. (Contribuito da Serhiy Storchaka in gh-74696.)

  • shutil.rmtree() ora accetta un nuovo argomento onexc che è un gestore di errori simile a onerror ma che si aspetta un’istanza di eccezione piuttosto che un terzetto (typ, val, tb). onerror è deprecato. (Contribuito da Irit Katriel in gh-102828.)

  • shutil.which() ora consulta la variabile d’ambiente PATHEXT per trovare corrispondenze all’interno di PATH su Windows anche quando il cmd dato include un componente di directory. (Contribuito da Charles Machalow in gh-103179.)

    shutil.which() chiamerà NeedCurrentDirectoryForExePathW quando interroga per eseguibili su Windows per determinare se la directory di lavoro corrente dovrebbe essere aggiunta al percorso di ricerca. (Contribuito da Charles Machalow in gh-103179.)

    shutil.which() restituirà un percorso corrispondente al cmd con un componente da PATHEXT prima di una corrispondenza diretta altrove nel percorso di ricerca su Windows. (Contribuito da Charles Machalow in gh-103179.)

sqlite3

statistica

  • Estendere statistics.correlation() per includere un metodo ranked per calcolare la correlazione di Spearman di dati classificati. (Contribuito da Raymond Hettinger in gh-95861.)

sys

tempfile

  • La funzione tempfile.NamedTemporaryFile ha un nuovo parametro opzionale delete_on_close (Contribuito da Evgeny Zorin in gh-58451.)

  • tempfile.mkdtemp() ora ritorna sempre un percorso assoluto, anche se l’argomento fornito al parametro dir è un percorso relativo.

threading

tkinter

  • tkinter.Canvas.coords() ora appiattisce i suoi argomenti. Ora accetta non solo coordinate come argomenti separati (x1, y1, x2, y2, ...) e una sequenza di coordinate ([x1, y1, x2, y2, ...]), ma anche coordinate raggruppate in coppie ((x1, y1), (x2, y2), ... e [(x1, y1), (x2, y2), ...]), come i metodi create_*(). (Contributo di Serhiy Storchaka in gh-94473.)

tokenize

types

typing

  • I controlli isinstance() contro i runtime-checkable protocols ora utilizzano inspect.getattr_static() anziché hasattr() per verificare l’esistenza degli attributi. Ciò significa che i descrittori e i metodi __getattr__() non vengono più valutati inaspettatamente durante i controlli isinstance() contro i protocolli verificabili a runtime. Tuttavia, ciò può anche significare che alcuni oggetti che in precedenza erano considerati istanze di un protocollo verificabile a runtime potrebbero non essere più considerati tali con Python 3.12+ e viceversa. La maggior parte degli utenti non dovrebbe essere influenzata da questo cambiamento. (Contributo di Alex Waygood in gh-102433.)

  • I membri di un protocollo verificabile a runtime sono ora considerati «congelati» a runtime non appena la classe è stata creata. Il monkey-patching degli attributi in un protocollo verificabile a runtime funzionerà ancora, ma non avrà alcun impatto sui controlli isinstance() che confrontano oggetti con il protocollo. Per esempio:

    >>> from typing import Protocol, runtime_checkable
>>> @runtime_checkable
... class HasX(Protocol):
...     x = 1
...
>>> class Foo: ...
...
>>> f = Foo()
>>> isinstance(f, HasX)
False
>>> f.x = 1
>>> isinstance(f, HasX)
True
>>> HasX.y = 2
>>> isinstance(f, HasX)  # unchanged, even though HasX now also has a "y" attribute
True

    Questa modifica è stata apportata per velocizzare i controlli isinstance() contro i protocolli verificabili a runtime.

  • Il profilo delle prestazioni dei controlli isinstance() contro i runtime-checkable protocols è cambiato significativamente. La maggior parte dei controlli isinstance() contro i protocolli con pochi membri dovrebbe essere almeno 2 volte più veloce rispetto alla versione 3.11, e alcuni potrebbero essere 20 volte più veloci o più. Tuttavia, i controlli isinstance() contro i protocolli con molti membri potrebbero risultare più lenti rispetto a Python 3.11. (Contributo di Alex Waygood in gh-74690 e gh-103193.)

  • Tutte le classi typing.TypedDict e typing.NamedTuple ora possiedono l’attributo __orig_bases__. (Contributo di Adrian Garcia Badaracco in gh-103699.)

  • Aggiungi il parametro frozen_default a typing.dataclass_transform(). (Contributo di Erik De Bonte in gh-99957.)

unicodedata

  • Il database Unicode è stato aggiornato alla versione 15.0.0. (Contributo di Benjamin Peterson in gh-96734).

unittest

Aggiungi l’opzione di linea di comando --durations, che mostra i N casi di test più lenti:

python3 -m unittest --durations=3 lib.tests.test_threading
.....
Slowest test durations
----------------------------------------------------------------------
1.210s     test_timeout (Lib.test.test_threading.BarrierTests)
1.003s     test_default_timeout (Lib.test.test_threading.BarrierTests)
0.518s     test_timeout (Lib.test.test_threading.EventTests)

(0.000 durations hidden.  Use -v to show these durations.)
----------------------------------------------------------------------
Ran 158 tests in 9.869s

OK (skipped=3)

(Contributo di Giampaolo Rodola in gh-48330)

uuid

Ottimizzazioni

  • Rimuovi i membri wstr e wstr_length dagli oggetti Unicode. Ciò riduce la dimensione degli oggetti di 8 o 16 byte sulla piattaforma a 64 bit. (PEP 623) (Contributo di Inada Naoki in gh-92536.)

  • Aggiungi il supporto sperimentale per l’uso dell’ottimizzatore binario BOLT nel processo di build, che migliora le prestazioni dell’1-5%. (Contributo di Kevin Modzelewski in gh-90536 e ottimizzato da Donghee Na in gh-101525)

  • Velocizza la sostituzione delle espressioni regolari (funzioni re.sub() e re.subn() e i corrispondenti metodi di re.Pattern) per le stringhe di sostituzione contenenti riferimenti di gruppo di 2-3 volte. (Contributo di Serhiy Storchaka in gh-91524.)

  • Velocizza la creazione di asyncio.Task rimandando la formattazione delle stringhe costosa. (Contributo di Itamar Oren in gh-103793.)

  • Le funzioni tokenize.tokenize() e tokenize.generate_tokens() sono fino al 64% più veloci come effetto collaterale delle modifiche necessarie per coprire PEP 701 nel modulo tokenize. (Contributo di Marta Gómez Macías e Pablo Galindo in gh-102856.)

  • Velocizza le chiamate al metodo super() e i caricamenti degli attributi tramite la nuova istruzione LOAD_SUPER_ATTR. (Contributo di Carl Meyer e Vladimir Matveev in gh-103497.)

Modifiche al bytecode di CPython

Demos e Tools

  • Rimuovi la directory Tools/demo/ che conteneva vecchi script demo. Una copia può essere trovata nel progetto old-demos. (Contributo di Victor Stinner in gh-97681.)

  • Rimuovi script di esempio obsoleti dalla directory Tools/scripts/. Una copia può essere trovata nel progetto old-demos. (Contributo di Victor Stinner in gh-97669.)

Deprecato

Rimozione pianificata in Python 3.13

Moduli (vedi PEP 594):

  • aifc

  • audioop

  • cgi

  • cgitb

  • chunk

  • crypt

  • imghdr

  • mailcap

  • msilib

  • nis

  • nntplib

  • ossaudiodev

  • pipes

  • sndhdr

  • spwd

  • sunau

  • telnetlib

  • uu

  • xdrlib

Altri moduli:

  • lib2to3, e il programma 2to3 (gh-84540)

API:

Rimozione prevista in Python 3.14

Rimozione in sospeso in Python 3.15

  • The import system:

    • Setting __cached__ on a module while failing to set __spec__.cached is deprecated. In Python 3.15, __cached__ will cease to be set or take into consideration by the import system or standard library. (gh-97879)

    • Setting __package__ on a module while failing to set __spec__.parent is deprecated. In Python 3.15, __package__ will cease to be set or take into consideration by the import system or standard library. (gh-97879)

  • ctypes:

    • The undocumented ctypes.SetPointerType() function has been deprecated since Python 3.13.

  • http.server:

    • The obsolete and rarely used CGIHTTPRequestHandler has been deprecated since Python 3.13. No direct replacement exists. Anything is better than CGI to interface a web server with a request handler.

    • The --cgi flag to the python -m http.server command-line interface has been deprecated since Python 3.13.

  • importlib:

    • load_module() method: use exec_module() instead.

  • locale:

  • pathlib:

  • platform:

    • java_ver() has been deprecated since Python 3.13. This function is only useful for Jython support, has a confusing API, and is largely untested.

  • threading:

    • RLock() will take no arguments in Python 3.15. Passing any arguments has been deprecated since Python 3.14, as the Python version does not permit any arguments, but the C version allows any number of positional or keyword arguments, ignoring every argument.

  • types:

  • typing:

    • The undocumented keyword argument syntax for creating NamedTuple classes (e.g. Point = NamedTuple("Point", x=int, y=int)) has been deprecated since Python 3.13. Use the class-based syntax or the functional syntax instead.

    • The typing.no_type_check_decorator() decorator function has been deprecated since Python 3.13. After eight years in the typing module, it has yet to be supported by any major type checker.

  • wave:

Pending removal in Python 3.16

  • The import system:

    • Setting __loader__ on a module while failing to set __spec__.loader is deprecated. In Python 3.16, __loader__ will cease to be set or taken into consideration by the import system or the standard library.

  • array:

    • The 'u' format code (wchar_t) has been deprecated in documentation since Python 3.3 and at runtime since Python 3.13. Use the 'w' format code (Py_UCS4) for Unicode characters instead.

  • asyncio:

  • builtins:

    • Bitwise inversion on boolean types, ~True or ~False has been deprecated since Python 3.12, as it produces surprising and unintuitive results (-2 and -1). Use not x instead for the logical negation of a Boolean. In the rare case that you need the bitwise inversion of the underlying integer, convert to int explicitly (~int(x)).

  • shutil:

    • The ExecError exception has been deprecated since Python 3.14. It has not been used by any function in shutil since Python 3.4, and is now an alias of RuntimeError.

  • symtable:

  • sys:

  • tarfile:

    • The undocumented and unused TarFile.tarfile attribute has been deprecated since Python 3.13.

Rimozione in sospeso nelle versioni future

The following APIs will be removed in the future, although there is currently no date scheduled for their removal.

  • argparse: Nesting argument groups and nesting mutually exclusive groups are deprecated.

  • Il codice di formato 'u' di array (gh-57281)

  • builtins:

    • bool(NotImplemented).

    • Generators: throw(type, exc, tb) and athrow(type, exc, tb) signature is deprecated: use throw(exc) and athrow(exc) instead, the single argument signature.

    • Currently Python accepts numeric literals immediately followed by keywords, for example 0in x, 1or x, 0if 1else 2. It allows confusing and ambiguous expressions like [0x1for x in y] (which can be interpreted as [0x1 for x in y] or [0x1f or x in y]). A syntax warning is raised if the numeric literal is immediately followed by one of keywords and, else, for, if, in, is and or. In a future release it will be changed to a syntax error. (gh-87999)

    • Support for __index__() and __int__() method returning non-int type: these methods will be required to return an instance of a strict subclass of int.

    • Support for __float__() method returning a strict subclass of float: these methods will be required to return an instance of float.

    • Support for __complex__() method returning a strict subclass of complex: these methods will be required to return an instance of complex.

    • Delegation of int() to __trunc__() method.

    • Passing a complex number as the real or imag argument in the complex() constructor is now deprecated; it should only be passed as a single positional argument. (Contributed by Serhiy Storchaka in gh-109218.)

  • calendar: Le costanti calendar.January e calendar.February sono deprecate e sostituite da calendar.JANUARY e calendar.FEBRUARY. (Contributo di Prince Roshan in gh-103636.)

  • codeobject.co_lnotab: use the codeobject.co_lines() method instead.

  • datetime:

    • utcnow(): use datetime.datetime.now(tz=datetime.UTC).

    • utcfromtimestamp(): use datetime.datetime.fromtimestamp(timestamp, tz=datetime.UTC).

  • gettext: Plural value must be an integer.

  • importlib:

    • cache_from_source() debug_override parameter is deprecated: use the optimization parameter instead.

  • importlib.metadata:

    • EntryPoints tuple interface.

    • Implicit None on return values.

  • logging: the warn() method has been deprecated since Python 3.3, use warning() instead.

  • mailbox: Use of StringIO input and text mode is deprecated, use BytesIO and binary mode instead.

  • os: Calling os.register_at_fork() in multi-threaded process.

  • pydoc.ErrorDuringImport: A tuple value for exc_info parameter is deprecated, use an exception instance.

  • re: More strict rules are now applied for numerical group references and group names in regular expressions. Only sequence of ASCII digits is now accepted as a numerical reference. The group name in bytes patterns and replacement strings can now only contain ASCII letters and digits and underscore. (Contributed by Serhiy Storchaka in gh-91760.)

  • sre_compile, sre_constants and sre_parse modules.

  • shutil: rmtree()”s onerror parameter is deprecated in Python 3.12; use the onexc parameter instead.

  • ssl options and protocols:

    • ssl.SSLContext without protocol argument is deprecated.

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

    • ssl.OP_NO_SSL* options

    • ssl.OP_NO_TLS* options

    • 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

  • sysconfig.is_python_build() check_home parameter is deprecated and ignored.

  • threading methods:

  • typing.Text (gh-92332).

  • unittest.IsolatedAsyncioTestCase: it is deprecated to return a value that is not None from a test case.

  • urllib.parse deprecated functions: urlparse() instead

    • splitattr()

    • splithost()

    • splitnport()

    • splitpasswd()

    • splitport()

    • splitquery()

    • splittag()

    • splittype()

    • splituser()

    • splitvalue()

    • to_bytes()

  • urllib.request: URLopener and FancyURLopener style of invoking requests is deprecated. Use newer urlopen() functions and methods.

  • wsgiref: SimpleHandler.stdout.write() should not do partial writes.

  • xml.etree.ElementTree: Testing the truth value of an Element is deprecated. In a future release it will always return True. Prefer explicit len(elem) or elem is not None tests instead.

  • zipimport.zipimporter.load_module() is deprecated: use exec_module() instead.

Rimosso

asynchat e asyncore

  • Questi due moduli sono stati rimossi secondo il programma in PEP 594, essendo stati deprecati in Python 3.6. Utilizzare asyncio invece. (Contribuito da Nikita Sobolev in gh-96580.)

configparser

distutils

  • Rimozione del pacchetto distutils. È stato deprecato in Python 3.10 da PEP 632 «Deprecazione del modulo distutils». Per i progetti che ancora utilizzano distutils e non possono essere aggiornati ad altro, il progetto setuptools può essere installato: fornisce ancora distutils. (Contribuito da Victor Stinner in gh-92584.)

ensurepip

  • Rimozione della ruota setuptools inclusa in ensurepip, e cessazione dell’installazione di setuptools negli ambienti creati da venv.

    pip (>= 22.1) non richiede che setuptools sia installato nell’ambiente. I pacchetti basati su setuptools (e su distutils) possono ancora essere utilizzati con pip install, poiché pip fornirà setuptools nell’ambiente di build che utilizza per costruire un pacchetto.

    easy_install, pkg_resources, setuptools e distutils non sono più forniti di default negli ambienti creati con venv o bootstrap con ensurepip, poiché fanno parte del pacchetto setuptools. Per i progetti che dipendono da questi a runtime, il progetto setuptools dovrebbe essere dichiarato come una dipendenza e installato separatamente (tipicamente, utilizzando pip).

    (Contribuito da Pradyun Gedam in gh-95299.)

enum

  • Rimozione di EnumMeta.__getattr__ di enum, che non è più necessario per l’accesso agli attributi degli enum. (Contribuito da Ethan Furman in gh-95083.)

ftplib

  • Rimozione dell’attributo di classe FTP_TLS.ssl_version di ftplib: utilizzare invece il parametro context. (Contribuito da Victor Stinner in gh-94172.)

gzip

  • Rimozione dell’attributo filename di gzip.GzipFile di gzip, deprecato dalla versione Python 2.6, utilizzare invece l’attributo name. In modalità scrittura, l’attributo filename aggiungeva l’estensione di file '.gz' se non era presente. (Contribuito da Victor Stinner in gh-94196.)

hashlib

  • Remove the pure Python implementation of hashlib’s hashlib.pbkdf2_hmac(), deprecated in Python 3.10. Python 3.10 and newer requires OpenSSL 1.1.1 (PEP 644): this OpenSSL version provides a C implementation of pbkdf2_hmac() which is faster. (Contributed by Victor Stinner in gh-94199.)

importlib

  • Molti di precedenti deprecazioni in importlib sono ora state completate:

    • References to, and support for module_repr() has been removed. (Contributed by Barry Warsaw in gh-97850.)

    • importlib.util.set_package, importlib.util.set_loader e importlib.util.module_for_loader sono stati tutti rimossi. (Contribuito da Brett Cannon e Nikita Sobolev in gh-65961 e gh-97850.)

    • Il supporto per le API find_loader() e find_module() è stato rimosso. (Contribuito da Barry Warsaw in gh-98040.)

    • importlib.abc.Finder, pkgutil.ImpImporter e pkgutil.ImpLoader sono stati rimossi. (Contribuito da Barry Warsaw in gh-98040.)

imp

  • Il modulo imp è stato rimosso. (Contribuito da Barry Warsaw in gh-98040.)

    Per migrare, consultare la seguente tabella di corrispondenza:

    imp

    importlib

    imp.NullImporter

    Inserire None in sys.path_importer_cache

    imp.cache_from_source()

    importlib.util.cache_from_source()

    imp.find_module()

    importlib.util.find_spec()

    imp.get_magic()

    importlib.util.MAGIC_NUMBER

    imp.get_suffixes()

    importlib.machinery.SOURCE_SUFFIXES, importlib.machinery.EXTENSION_SUFFIXES, and importlib.machinery.BYTECODE_SUFFIXES

    imp.get_tag()

    sys.implementation.cache_tag

    imp.load_module()

    importlib.import_module()

    imp.new_module(name)

    types.ModuleType(name)

    imp.reload()

    importlib.reload()

    imp.source_from_cache()

    importlib.util.source_from_cache()

    imp.load_source()

    Vedi sotto

    Sostituire imp.load_source() con:

    import importlib.util
import importlib.machinery

def load_source(modname, filename):
    loader = importlib.machinery.SourceFileLoader(modname, filename)
    spec = importlib.util.spec_from_file_location(modname, filename, loader=loader)
    module = importlib.util.module_from_spec(spec)
    # The module is always executed and not cached in sys.modules.
    # Uncomment the following line to cache the module.
    # sys.modules[module.__name__] = module
    loader.exec_module(module)
    return module

  • Rimuovere le funzioni e gli attributi di imp senza sostituzioni:

    • Funzioni non documentate:

      • imp.init_builtin()

      • imp.load_compiled()

      • imp.load_dynamic()

      • imp.load_package()

    • imp.lock_held(), imp.acquire_lock(), imp.release_lock(): lo schema di blocco è cambiato in Python 3.3 a blocchi per modulo.

    • Costanti di imp.find_module(): SEARCH_ERROR, PY_SOURCE, PY_COMPILED, C_EXTENSION, PY_RESOURCE, PKG_DIRECTORY, C_BUILTIN, PY_FROZEN, PY_CODERESOURCE, IMP_HOOK.

io

  • Rimuovere io.OpenWrapper di io e _pyio.OpenWrapper, deprecati in Python 3.10: utilizzare semplicemente open(). La funzione open() (io.open()) è una funzione integrata. Dalla versione 3.10 di Python, _pyio.open() è anche un metodo statico. (Contributo di Victor Stinner in gh-94169.)

locale

smtpd

  • Il modulo smtpd è stato rimosso secondo il programma di PEP 594, essendo stato deprecato in Python 3.4.7 e 3.5.4. Utilizzare il modulo PyPI aiosmtpd o qualsiasi altro server basato su asyncio. (Contributo di Oleg Iarygin in gh-93243.)

sqlite3

  • Le seguenti funzionalità non documentate di sqlite3, deprecate in Python 3.10, sono ora rimosse:

    • sqlite3.enable_shared_cache()

    • sqlite3.OptimizedUnicode

    Se è necessario utilizzare una cache condivisa, aprire il database in modalità URI utilizzando il parametro di query cache=shared.

    La text factory sqlite3.OptimizedUnicode è stata un alias per str fin dalla versione 3.3 di Python. Il codice che precedentemente impostava la text factory su OptimizedUnicode può utilizzare esplicitamente str, o affidarsi al valore predefinito che è anch’esso str.

    (Contributo di Erlend E. Aasland in gh-92548.)

ssl

  • Rimuovere la funzione ssl.RAND_pseudo_bytes() di ssl, deprecata in Python 3.6: utilizzare invece os.urandom() o ssl.RAND_bytes(). (Contributo di Victor Stinner in gh-94199.)

  • Rimuovere la funzione ssl.match_hostname(). È stata deprecata in Python 3.7. OpenSSL esegue il confronto degli hostname dalla versione 3.7 di Python, Python non utilizza più la funzione ssl.match_hostname(). (Contributo di Victor Stinner in gh-94199.)

  • Rimuovere la funzione ssl.wrap_socket(), deprecata in Python 3.7: creare invece un oggetto ssl.SSLContext e chiamare il suo metodo ssl.SSLContext.wrap_socket. Qualsiasi pacchetto che utilizza ancora ssl.wrap_socket() è rotto e non sicuro. La funzione non invia né un’estensione TLS SNI né valida l’hostname del server. Il codice è soggetto a CWE 295 (Validazione Impropria del Certificato). (Contributo di Victor Stinner in gh-94199.)

unittest

webbrowser

  • Rimuovi il supporto per i browser obsoleti da webbrowser. I browser rimossi includono: Grail, Mosaic, Netscape, Galeon, Skipstone, Iceape, Firebird e le versioni di Firefox fino alla 35 (gh-102871).

xml.etree.ElementTree

  • Rimuovi il metodo ElementTree.Element.copy() dell’implementazione pura in Python, deprecato in Python 3.10, usa invece la funzione copy.copy(). L’implementazione in C di xml.etree.ElementTree non ha metodo copy(), ma solo un metodo __copy__(). (Contribuito da Victor Stinner in gh-94383.)

zipimport

  • Rimuovi i metodi find_loader() e find_module() di zipimport, deprecati in Python 3.10: usa invece il metodo find_spec(). Vedi PEP 451 per la spiegazione. (Contribuito da Victor Stinner in gh-94379.)

Altri

  • Rimuovi la regola suspicious dal Makefile della documentazione e da Doc/tools/rstlint.py, entrambe a favore di sphinx-lint. (Contribuito da Julien Palard in gh-98179.)

  • Rimuovi i parametri keyfile e certfile dai moduli ftplib, imaplib, poplib e smtplib, e i parametri key_file, cert_file e check_hostname dal modulo http.client, tutti deprecati da Python 3.6. Usa invece il parametro context (ssl_context in imaplib). (Contribuito da Victor Stinner in gh-94172.)

  • Rimuovi hack di compatibilità con Jython da diversi moduli e test della stdlib. (Contribuito da Nikita Sobolev in gh-99482.)

  • Rimuovi il flag _use_broken_old_ctypes_structure_semantics_ dal modulo ctypes. (Contribuito da Nikita Sobolev in gh-99285.)

Porting a Python 3.12

Questa sezione elenca i cambiamenti precedentemente descritti e altre correzioni di bug che potrebbero richiedere modifiche al tuo codice.

Modifiche nell’API di Python

  • Ora si applicano regole più severe per i riferimenti di gruppo numerici e i nomi di gruppo nelle espressioni regolari. Sono accettati solo riferimenti numerici che sono una sequenza di cifre ASCII. Il nome del gruppo nei pattern in bytes e nelle stringhe di sostituzione ora può contenere solo lettere e cifre ASCII e il carattere di sottolineatura. (Contribuito da Serhiy Storchaka in gh-91760.)

  • Rimosso il funzionamento di randrange() deprecato da Python 3.10. In precedenza, randrange(10.0) veniva convertito senza perdita a randrange(10). Ora solleva un’eccezione TypeError. Inoltre, l’eccezione sollevata per valori non interi come randrange(10.5) o randrange('10') è cambiata da ValueError a TypeError. Questo impedisce anche bug dove randrange(1e25) selezionava silenziosamente da un intervallo più ampio rispetto a randrange(10**25). (Originariamente suggerito da Serhiy Storchaka gh-86388.)

  • argparse.ArgumentParser ha cambiato la codifica e il gestore di errori per la lettura degli argomenti dai file (ad esempio l’opzione fromfile_prefix_chars) dalla codifica di testo predefinita (ad esempio locale.getpreferredencoding(False)) a filesystem encoding and error handler. I file degli argomenti dovrebbero essere codificati in UTF-8 invece che in ANSI Codepage su Windows.

  • Rimosso il modulo smtpd basato su asyncore deprecato in Python 3.4.7 e 3.5.4. Una sostituzione raccomandata è il modulo PyPI asyncio-based aiosmtpd.

  • shlex.split(): Passare None per l’argomento s ora solleva un’eccezione, invece di leggere da sys.stdin. La funzionalità è stata deprecata in Python 3.9. (Contribuito da Victor Stinner in gh-94352.)

  • Il modulo os non accetta più percorsi di tipo bytes, come bytearray e memoryview: solo il tipo esatto bytes è accettato per stringhe di tipo bytes. (Contribuito da Victor Stinner in gh-98393.)

  • syslog.openlog() e syslog.closelog() ora falliscono se utilizzati nei subinterpreti. syslog.syslog() può ancora essere usato nei subinterpreti, ma solo se syslog.openlog() è stato già chiamato nel main interpreter. Queste nuove restrizioni non si applicano al main interpreter, quindi solo un insieme molto ristretto di utenti potrebbe essere interessato. Questa modifica aiuta con l’isolamento degli interpreti. Inoltre, syslog è un wrapper attorno a risorse globali del processo, che sono meglio gestite dal main interpreter. (Contribuito da Donghee Na in gh-99127.)

  • Il comportamento di blocco non documentato di cached_property() è stato rimosso, perché bloccava tutte le istanze della classe, portando a una forte contention dei lock. Questo significa che ora una funzione getter della proprietà in cache potrebbe essere eseguita più di una volta per una singola istanza, se due thread sono in competizione. Per la maggior parte delle proprietà in cache semplici (ad esempio quelle che sono idempotenti e calcolano semplicemente un valore basato su altri attributi dell’istanza) questo sarà accettabile. Se è necessaria la sincronizzazione, implementare il locking all’interno della funzione getter della proprietà in cache o intorno ai punti di accesso multi-thread.

  • sys._current_exceptions() ora restituisce una mappa da thread-id a un’istanza di eccezione, anziché a una tupla (typ, exc, tb). (Contribuito da Irit Katriel in gh-103176.)

  • Quando si estraggono file tar usando tarfile o shutil.unpack_archive(), passare l’argomento filter per limitare le funzionalità che possono essere sorprendenti o pericolose. Vedere Extraction filters per i dettagli.

  • L’output delle funzioni tokenize.tokenize() e tokenize.generate_tokens() è ora cambiato a causa delle modifiche introdotte in PEP 701. Questo significa che i token STRING non sono più emessi per le f-string e i token descritti in PEP 701 sono ora prodotti al loro posto: FSTRING_START, FSTRING_MIDDLE e FSTRING_END sono ora emessi per le parti «string» delle f-string in aggiunta ai token appropriati per la tokenizzazione nei componenti di espressione. Ad esempio, per la f-string f"start {1+1} end" la vecchia versione del tokenizer emetteva:

    1,0-1,18:           STRING         'f"start {1+1} end"'

    mentre la nuova versione emette:

    1,0-1,2:            FSTRING_START  'f"'
1,2-1,8:            FSTRING_MIDDLE 'start '
1,8-1,9:            OP             '{'
1,9-1,10:           NUMBER         '1'
1,10-1,11:          OP             '+'
1,11-1,12:          NUMBER         '1'
1,12-1,13:          OP             '}'
1,13-1,17:          FSTRING_MIDDLE ' end'
1,17-1,18:          FSTRING_END    '"'

    Inoltre, potrebbero esserci alcuni cambiamenti comportamentali minori come conseguenza delle modifiche necessarie per supportare PEP 701. Alcuni di questi cambiamenti includono:

    • L’attributo type dei token emessi quando si tokenizzano alcuni caratteri Python non validi come ! è cambiato da ERRORTOKEN a OP.

    • Le stringhe a riga singola incomplete ora sollevano tokenize.TokenError come fanno le stringhe multilinea incomplete.

    • Alcuni codici Python incompleti o non validi ora sollevano tokenize.TokenError invece di restituire token ERRORTOKEN arbitrari durante la tokenizzazione.

    • La miscelazione di tabulazioni e spazi come indentazione nello stesso file non è più supportata e genererà un’eccezione TabError.

  • Il modulo threading ora si aspetta che il modulo _thread abbia un attributo _is_main_interpreter. È una funzione senza argomenti che restituisce True se l’interprete corrente è il main interpreter.

    Qualsiasi libreria o applicazione che fornisce un modulo _thread personalizzato dovrebbe fornire _is_main_interpreter(). (Vedere gh-112826.)

Modifiche alla Build

  • Python non utilizza più setup.py per costruire moduli di estensione C condivisi. I parametri di build come intestazioni e librerie sono rilevati nello script configure. Le estensioni sono costruite da Makefile. La maggior parte delle estensioni utilizza pkg-config e ricorre al rilevamento manuale. (Contribuito da Christian Heimes in gh-93939.)

  • va_start() con due parametri, come va_start(args, format), è ora richiesto per costruire Python. va_start() non viene più chiamato con un solo parametro. (Contribuito da Kumar Aditya in gh-93207.)

  • CPython ora utilizza l’opzione ThinLTO come politica predefinita di ottimizzazione del tempo di link se il compilatore Clang accetta il flag. (Contribuito da Donghee Na in gh-89536.)

  • Aggiunta la variabile COMPILEALL_OPTS in Makefile per sovrascrivere le opzioni di compileall (predefinito: -j0) in make install. Inoltre, combinati i 3 comandi compileall in un unico comando per costruire i file .pyc per tutti i livelli di ottimizzazione (0, 1, 2) in una volta. (Contribuito da Victor Stinner in gh-99289.)

  • Aggiunti triplette di piattaforma per LoongArch a 64 bit:

    • loongarch64-linux-gnusf

    • loongarch64-linux-gnuf32

    • loongarch64-linux-gnu

    (Contribuito da Zhang Na in gh-90656.)

  • PYTHON_FOR_REGEN ora richiede Python 3.10 o versioni successive.

  • Autoconf 2.71 e aclocal 1.16.4 sono ora richiesti per rigenerare !configure. (Contribuito da Christian Heimes in gh-89886.)

  • Le build di Windows e gli installer per macOS da python.org ora utilizzano OpenSSL 3.0.

Modifiche all’API C

Nuove Funzionalità

  • PEP 683: Introdurre Immortal Objects, che consente agli oggetti di bypassare i conti di riferimento, e modifiche correlate alla C-API:

    • _Py_IMMORTAL_REFCNT: Il conteggio dei riferimenti che definisce un oggetto

      come immortale.

    • _Py_IsImmortal Controlla se un oggetto ha il conteggio dei riferimenti immortali.

    • PyObject_HEAD_INIT Ora inizializzerà il conteggio dei riferimenti a

      SSTATE_INTERNED_IMMORTAL Un identificatore per oggetti Unicode internati

    • SSTATE_INTERNED_IMMORTAL An identifier for interned unicode objects

      che sono immortali.

    • SSTATE_INTERNED_IMMORTAL_STATIC Un identificatore per oggetti Unicode internati

      sys.getunicodeinternedsize Restituisce il numero totale di oggetti Unicode

    • sys.getunicodeinternedsize This returns the total number of unicode

      che sono stati internati. Questo è ora necessario per refleak.py per monitorare correttamente i conti di riferimenti e i blocchi allocati.

    (Contributo di Eddie Elizondo in gh-84436.)

  • PEP 684: Aggiunta la nuova funzione Py_NewInterpreterFromConfig() e PyInterpreterConfig, che possono essere utilizzate per creare sotto-interpreti con i propri GIL. (Vedi PEP 684: Un GIL per interprete per maggiori informazioni.) (Contributo di Eric Snow in gh-104110.)

  • Nella versione 3.12 della limited C API, le funzioni Py_INCREF() e Py_DECREF() sono ora implementate come chiamate di funzione opache per nascondere i dettagli dell’implementazione. (Contributo di Victor Stinner in gh-105387.)

Porting a Python 3.12

  • Le API Unicode legacy basate sulla rappresentazione Py_UNICODE* sono state rimosse. Si prega di migrare alle API basate su UTF-8 o wchar_t*.

  • Le funzioni di analisi degli argomenti come PyArg_ParseTuple() non supportano più i formati basati su Py_UNICODE* (ad esempio u, Z). Si prega di migrare ad altri formati per Unicode come s, z, es e U.

  • tp_weaklist per tutti i tipi built-in statici è sempre NULL. Questo è un campo solo interno su PyTypeObject, ma segnaliamo la modifica nel caso qualcuno lo stia accedendo direttamente. Per evitare interruzioni, si consiglia di utilizzare invece la C-API pubblica esistente o, se necessario, la macro (solo interna) _PyObject_GET_WEAKREFS_LISTPTR().

  • Questo campo solo interno PyTypeObject.tp_subclasses potrebbe ora non essere un puntatore a oggetto valido. Il suo tipo è stato cambiato in void* per riflettere questo. Menzioniamo questa modifica nel caso qualcuno stia accedendo direttamente al campo solo interno.

    To get a list of subclasses, call the Python method __subclasses__() (using PyObject_CallMethod(), for example).

  • Aggiunto supporto per più opzioni di formattazione (allineamento a sinistra, ottali, esadecimali maiuscoli, intmax_t, ptrdiff_t, stringhe C wchar_t, larghezza e precisione variabili) in PyUnicode_FromFormat() e PyUnicode_FromFormatV(). (Contributo di Serhiy Storchaka in gh-98836.)

  • Un carattere di formato non riconosciuto in PyUnicode_FromFormat() e PyUnicode_FromFormatV() ora imposta una SystemError. Nelle versioni precedenti, causava la copia invariata del resto della stringa di formato nella stringa di risultato e scartava eventuali argomenti extra. (Contributo di Serhiy Storchaka in gh-95781.)

  • Corretta la posizione errata del segno in PyUnicode_FromFormat() e PyUnicode_FromFormatV(). (Contributo di Philip Georgi in gh-95504.)

  • Extension classes wanting to add a __dict__ or weak reference slot should use Py_TPFLAGS_MANAGED_DICT and Py_TPFLAGS_MANAGED_WEAKREF instead of tp_dictoffset and tp_weaklistoffset, respectively. The use of tp_dictoffset and tp_weaklistoffset is still supported, but does not fully support multiple inheritance (gh-95589), and performance may be worse. Classes declaring Py_TPFLAGS_MANAGED_DICT must call _PyObject_VisitManagedDict() and _PyObject_ClearManagedDict() to traverse and clear their instance’s dictionaries. To clear weakrefs, call PyObject_ClearWeakRefs(), as before.

  • La funzione PyUnicode_FSDecoder() non accetta più percorsi simili a byte, come bytearray e tipi memoryview: solo il tipo esatto bytes è accettato per le stringhe di byte. (Contributo di Victor Stinner in gh-98393.)

  • Le macro Py_CLEAR, Py_SETREF e Py_XSETREF ora valutano i loro argomenti solo una volta. Se un argomento ha effetti collaterali, questi effetti collaterali non vengono più duplicati. (Contributo di Victor Stinner in gh-98724.)

  • L’indicatore di errore dell’interprete è ora sempre normalizzato. Questo significa che PyErr_SetObject(), PyErr_SetString() e le altre funzioni che impostano l’indicatore di errore ora normalizzano l’eccezione prima di memorizzarla. (Contributo di Mark Shannon in gh-101578.)

  • _Py_RefTotal non è più autorevole e viene mantenuto solo per la compatibilità ABI. Nota che è una globale interna e disponibile solo build di debug. Se stai usando questa variabile, dovrai iniziare a usare _Py_GetGlobalRefTotal().

  • Le seguenti funzioni ora selezionano una metaclasse appropriata per il tipo appena creato:

    Creare classi la cui metaclasse sovrascrive tp_new è deprecato e in Python 3.14+ sarà disabilitato. Nota che queste funzioni ignorano tp_new della metaclasse, possibilmente permettendo un’inizializzazione incompleta.

    Nota che PyType_FromMetaclass() (aggiunto in Python 3.12) già impedisce la creazione di classi la cui metaclasse sovrascrive tp_new (__new__() in Python).

    Poiché tp_new sovrascrive quasi tutto ciò che fanno le funzioni PyType_From*, i due sono incompatibili tra loro. Il comportamento esistente — ignorare la metaclasse per diversi passaggi della creazione del tipo — è generalmente insicuro, poiché (meta)classi assumono che tp_new sia stato chiamato. Non esiste una soluzione generale semplice. Una delle seguenti opzioni potrebbe funzionare per te:

    • Se controlli la metaclasse, evita di usare tp_new in essa:

      • Se l’inizializzazione può essere saltata, può essere fatta al contrario in tp_init.

      • Se la metaclasse non ha bisogno di essere istanziata da Python, imposta il suo tp_new su NULL utilizzando il flag Py_TPFLAGS_DISALLOW_INSTANTIATION. Ciò la rende accettabile per le funzioni PyType_From*.

    • Evita le funzioni PyType_From*: se non ti servono funzionalità specifiche di C (slot o impostazione della dimensione dell’istanza), crea tipi tramite la chiamata della metaclasse.

    • Se sai che tp_new può essere saltato in sicurezza, filtra l’avviso di deprecazione usando warnings.catch_warnings() da Python.

  • PyOS_InputHook e PyOS_ReadlineFunctionPointer non vengono più chiamati in subinterpreters. Questo perché i client generalmente si affidano allo stato globale del processo (poiché questi callback non hanno modo di recuperare lo stato del modulo di estensione).

    Questo evita anche situazioni in cui le estensioni potrebbero trovarsi in esecuzione in un subinterprete che non supportano (o non sono ancora state caricate in). Vedi gh-104668 per ulteriori informazioni.

  • PyLongObject ha avuto i suoi interni cambiati per migliorare le prestazioni. Sebbene gli interni di PyLongObject siano privati, vengono utilizzati da alcuni moduli di estensione. I campi interni non devono più essere acceduti direttamente, ma devono essere utilizzate le funzioni API che iniziano con PyLong_.... Vengono fornite due nuove funzioni API instabili per un accesso efficiente al valore dei PyLongObjects che rientrano in una sola parola macchina:

  • Gli allocatori personalizzati, impostati tramite PyMem_SetAllocator(), sono ora richiesti per essere thread-safe, indipendentemente dal dominio di memoria. Gli allocatori che non hanno uno stato proprio, compresi i «ganci», non sono interessati. Se il tuo allocatore personalizzato non è già thread-safe e hai bisogno di assistenza, crea un nuovo problema su GitHub e CC @ericsnowcurrently.

Deprecato

Rimozione prevista in Python 3.14

Rimozione in sospeso in Python 3.15

Rimozione in sospeso nelle versioni future

Le seguenti API sono deprecate e verranno rimosse, anche se attualmente non è prevista una data di rimozione.

Rimosso

  • Rimuovi il file di intestazione token.h. Non c’è mai stata un’API pubblica per il tokenizer C. Il file di intestazione token.h è stato progettato solo per essere usato dagli interni di Python. (Contribuito da Victor Stinner in gh-92651.)

  • Le API Unicode legacy sono state rimosse. Vedi PEP 623 per i dettagli.

    • PyUnicode_WCHAR_KIND

    • PyUnicode_AS_UNICODE()

    • PyUnicode_AsUnicode()

    • PyUnicode_AsUnicodeAndSize()

    • PyUnicode_AS_DATA()

    • PyUnicode_FromUnicode()

    • PyUnicode_GET_SIZE()

    • PyUnicode_GetSize()

    • PyUnicode_GET_DATA_SIZE()

  • Remove the PyUnicode_InternImmortal() function macro. (Contributed by Victor Stinner in gh-85858.)