Funzioni Incorporate

L’interprete Python ha un certo numero di funzioni e tipi incorporati che sono sempre disponibili. Sono elencati qui in ordine alfabetico.

Funzioni Incorporate
A abs() aiter() all() anext() any() ascii() B bin() bool() breakpoint() bytearray() bytes() C callable() chr() classmethod() compile() complex() D delattr() dict() dir() divmod()	E enumerate() eval() exec() F filter() float() format() frozenset() G getattr() globals() H hasattr() hash() help() hex() I id() input() int() isinstance() issubclass() iter()	L len() list() locals() M map() max() memoryview() min() N next() O object() oct() open() ord() P pow() print() property()	R range() repr() reversed() round() S set() setattr() slice() sorted() staticmethod() str() sum() super() T tuple() type() V vars() Z zip() _ __import__()

abs(x)

Restituisce il valore assoluto di un numero. L’argomento può essere un intero, un numero in virgola mobile o un oggetto che implementa __abs__(). Se l’argomento è un numero complesso, ne viene restituita la magnitudine.

aiter(async_iterable)

Restituisce un asynchronous iterator per un asynchronous iterable. Equivalente a chiamare x.__aiter__().

Nota: A differenza di iter(), aiter() non ha una variante con 2 argomenti.

Added in version 3.10.

all(iterable)

Restituisce True se tutti gli elementi dell”iterable sono veri (o se l’iterable è vuoto). Equivalente a:

def all(iterable):
    for element in iterable:
        if not element:
            return False
    return True

awaitable anext(async_iterator)

awaitable anext(async_iterator, default)

Quando viene atteso, restituisce l’elemento successivo dall”asynchronous iterator dato, o default se fornito e l’iteratore è esaurito.

Questa è la variante asincrona del builtin next(), e si comporta in modo simile.

Questo chiama il metodo __anext__() di async_iterator, restituendo un awaitable. Attendere questo restituisce il prossimo valore dell’iteratore. Se default è fornito, viene restituito se l’iteratore è esaurito, altrimenti viene sollevata l’eccezione StopAsyncIteration.

Added in version 3.10.

any(iterable)

Restituisce True se qualche elemento dell”iterable è vero. Se l’iterable è vuoto, restituisce False. Equivalente a:

def any(iterable):
    for element in iterable:
        if element:
            return True
    return False

ascii(object)

Come repr(), restituisce una stringa contenente una rappresentazione stampabile di un oggetto, ma escapa i caratteri non ASCII nella stringa restituita da repr() utilizzando le sequenze di escape \x, \u o \U. Ciò genera una stringa simile a quella restituita da repr() in Python 2.

bin(x)

Converte un numero intero in una stringa binaria preceduta da «0b». Il risultato è un’espressione Python valida. Se x non è un oggetto int di Python, deve definire un metodo __index__() che restituisce un intero. Alcuni esempi:

>>> bin(3)
'0b11'
>>> bin(-10)
'-0b1010'

Se si desidera il prefisso «0b» oppure no, è possibile utilizzare uno dei seguenti modi.

>>> format(14, '#b'), format(14, 'b')
('0b1110', '1110')
>>> f'{14:#b}', f'{14:b}'
('0b1110', '1110')

Vedi anche format() per maggiori informazioni.

class bool(object=False, /)

Return a Boolean value, i.e. one of True or False. The argument is converted using the standard truth testing procedure. If the argument is false or omitted, this returns False; otherwise, it returns True. The bool class is a subclass of int (see Tipi Numerici — int, float, complex). It cannot be subclassed further. Its only instances are False and True (see Tipo Booleano - bool).

Cambiato nella versione 3.7: The parameter is now positional-only.

breakpoint(*args, **kws)

Questa funzione ti porta nel debugger nel punto in cui viene chiamata. In particolare, chiama sys.breakpointhook(), passando args e kws direttamente. Per impostazione predefinita, sys.breakpointhook() chiama pdb.set_trace() senza argomenti. In questo caso, è puramente una funzione di comodità in modo da non dover importare esplicitamente pdb o digitare tanto codice per entrare nel debugger. Tuttavia, sys.breakpointhook() può essere impostata su un’altra funzione e breakpoint() la chiamerà automaticamente, permettendo di entrare nel debugger a scelta. Se sys.breakpointhook() non è accessibile, questa funzione solleverà RuntimeError.

Per impostazione predefinita, il comportamento di breakpoint() può essere modificato con la variabile d’ambiente PYTHONBREAKPOINT. Vedi sys.breakpointhook() per i dettagli d’uso.

Nota che ciò non è garantito se sys.breakpointhook() è stato sostituito.

Solleva un evento di auditing builtins.breakpoint con l’argomento breakpointhook.

Added in version 3.7.

class bytearray(source=b'')

class bytearray(source, encoding)

class bytearray(source, encoding, errors)

Restituisce un nuovo array di byte. La classe bytearray è una sequenza mutabile di interi nell’intervallo 0 <= x < 256. Ha la maggior parte dei metodi usuali delle sequenze mutabili, descritti in Tipi di Sequenza Mutabili, oltre alla maggior parte dei metodi che il tipo bytes ha, vedi Operazioni su Bytes e Bytearray.

Il parametro opzionale source può essere utilizzato per inizializzare l’array in diversi modi:

• Se è una string, devi anche dare i parametri encoding (e facoltativamente, errors); bytearray() quindi converte la stringa in byte utilizzando str.encode().

• Se è un integer, l’array avrà quella dimensione e sarà inizializzato con byte nulli.

• Se è un oggetto conforme all”interfaccia buffer, un buffer di sola lettura dell’oggetto sarà utilizzato per inizializzare l’array di byte.

• Se è un iterable, deve essere un iterable di interi nell’intervallo 0 <= x < 256, che sono usati come contenuto iniziale dell’array.

Senza un argomento, viene creato un array di dimensione 0.

Vedi anche Tipi di sequenze binarie — bytes, bytearray, memoryview e Oggetti Bytearray.

class bytes(source=b'')

class bytes(source, encoding)

class bytes(source, encoding, errors)

Restituisce un nuovo oggetto «bytes» che è una sequenza immutabile di interi nell’intervallo 0 <= x < 256. bytes è una versione immutabile di bytearray – ha gli stessi metodi non mutanti e lo stesso comportamento di indicizzazione e slicing.

Di conseguenza, gli argomenti del costruttore sono interpretati come per bytearray().

Gli oggetti byte possono essere creati anche con letterali, vedi String and Bytes literals.

Vedi anche Tipi di sequenze binarie — bytes, bytearray, memoryview, Oggetti bytes, e Operazioni su Bytes e Bytearray.

callable(object)

Restituisce True se l’argomento object appare chiamabile, False se non lo è. Se questo restituisce True, è ancora possibile che una chiamata fallisca, ma se è False, chiamare object non avrà mai successo. Nota che le classi sono chiamabili (chiamare una classe restituisce una nuova istanza); le istanze sono chiamabili se la loro classe ha un metodo __call__().

Added in version 3.2: Questa funzione è stata prima rimossa in Python 3.0 e poi reintegrata in Python 3.2.

chr(i)

Restituisce la stringa che rappresenta un carattere il cui punto di codice Unicode è l’intero i. Ad esempio, chr(97) restituisce la stringa 'a', mentre chr(8364) restituisce la stringa '€'. Questo è l’inverso di ord().

L’intervallo valido per l’argomento va da 0 a 1.114.111 (0x10FFFF in base 16). Viene sollevata un’eccezione ValueError se i è fuori da questo intervallo.

@classmethod

Trasforma un metodo in un metodo di classe.

Un metodo di classe riceve la classe come primo argomento implicito, proprio come un metodo di istanza riceve l’istanza. Per dichiarare un metodo di classe, utilizza questo idiom:

class C:
    @classmethod
    def f(cls, arg1, arg2): ...

La forma @classmethod è un decorator di funzione – vedi Function definitions per i dettagli.

Un metodo di classe può essere chiamato sia sulla classe (come C.f()) sia su un’istanza (come C().f()). L’istanza è ignorata tranne che per la sua classe. Se un metodo di classe è chiamato per una classe derivata, l’oggetto della classe derivata è passato come primo argomento implicito.

I metodi di classe sono diversi dai metodi statici di C++ o Java. Se desideri quelli, vedi staticmethod() in questa sezione. Per maggiori informazioni sui metodi di classe, vedi The standard type hierarchy.

Cambiato nella versione 3.9: I metodi di classe ora possono avvolgere altri descrittori come property().

Cambiato nella versione 3.10: I metodi di classe ora ereditano gli attributi del metodo (__module__, __name__, __qualname__, __doc__ e __annotations__) e hanno un nuovo attributo __wrapped__.

Deprecato dalla versione 3.11, rimosso nella versione 3.13.: I metodi di classe non possono più avvolgere altri descrittori come property().

compile(source, filename, mode, flags=0, dont_inherit=False, optimize=-1)

Compila il source in un oggetto codice o AST. Gli oggetti codice possono essere eseguiti da exec() o eval(). source può essere una stringa normale, una stringa di byte o un oggetto AST. Consulta la documentazione del modulo ast per informazioni su come lavorare con gli oggetti AST.

L’argomento filename dovrebbe indicare il file da cui il codice è stato letto; passa un valore riconoscibile se non è stato letto da un file ('<string>' è comunemente utilizzato).

L’argomento mode specifica il tipo di codice che deve essere compilato; può essere 'exec' se source è costituito da una sequenza di istruzioni, 'eval' se è costituito da una singola espressione, o 'single' se è costituito da una singola istruzione interattiva (in quest’ultimo caso, le istruzioni di espressione che valutano a qualcosa di diverso da None saranno stampate).

Gli argomenti opzionali flags e dont_inherit controllano quali opzioni del compilatore devono essere attivate e quali future features dovrebbero essere consentite. Se nessuno dei due è presente (o entrambi sono zero), il codice viene compilato con le stesse opzioni che influenzano il codice che chiama compile(). Se l’argomento flags è fornito e dont_inherit non è (o è zero) allora le opzioni del compilatore e le dichiarazioni future specificate dall’argomento flags vengono utilizzate in aggiunta a quelle che sarebbero comunque utilizzate. Se dont_inherit è un numero intero diverso da zero, l’argomento flags è quello – le opzioni del compilatore (future features e opzioni del compilatore) nel codice circostante sono ignorate.

Le opzioni del compilatore e le dichiarazioni future sono specificate da bit che possono essere combinati con l’operatore OR bit a bit per specificare più opzioni. Il campo di bit richiesto per specificare una particolare future feature può essere trovato come attributo compiler_flag sull’istanza _Feature nel modulo __future__. Le flag del compilatore possono essere trovate nel modulo ast, con il prefisso PyCF_.

L’argomento optimize specifica il livello di ottimizzazione del compilatore; il valore predefinito -1 seleziona il livello di ottimizzazione dell’interprete come indicato dalle opzioni -O. I livelli espliciti sono 0 (nessuna ottimizzazione; __debug__ è vero), 1 (gli assert vengono rimossi, __debug__ è falso) o 2 (anche i docstring vengono rimossi).

Questa funzione solleva SyntaxError se la sorgente compilata non è valida, e ValueError se la sorgente contiene byte nulli.

Se vuoi fare il parsing del codice Python nella sua rappresentazione AST, vedi ast.parse().

Solleva un evento di auditing compile con argomenti source, filename.

Nota

Quando si compila una stringa con codice multi-linea in modalità 'single' o 'eval', l’input deve essere terminato da almeno un carattere di nuova riga. Questo per facilitare il rilevamento delle istruzioni incomplete e complete nel modulo code.

Avvertimento

È possibile mandare in crash l’interprete Python con una stringa sufficientemente grande/complessa quando si compila in un oggetto AST a causa delle limitazioni della profondità dello stack del compilatore AST di Python.

Cambiato nella versione 3.2: Consentito l’uso delle newline di Windows e Mac. Inoltre, l’input in modalità 'exec' non deve più terminare con una newline. Aggiunto il parametro optimize.

Cambiato nella versione 3.5: In precedenza, veniva sollevata un’eccezione TypeError quando venivano incontrati byte nulli nella sorgente.

Added in version 3.8: ast.PyCF_ALLOW_TOP_LEVEL_AWAIT può ora essere passato in flags per abilitare il supporto per await, async for e async with al livello superiore.

class complex(number=0, /)

class complex(string, /)

class complex(real=0, imag=0)

Convert a single string or number to a complex number, or create a complex number from real and imaginary parts.

Examples:

>>> complex('+1.23')
(1.23+0j)
>>> complex('-4.5j')
-4.5j
>>> complex('-1.23+4.5j')
(-1.23+4.5j)
>>> complex('\t( -1.23+4.5J )\n')
(-1.23+4.5j)
>>> complex('-Infinity+NaNj')
(-inf+nanj)
>>> complex(1.23)
(1.23+0j)
>>> complex(imag=-4.5)
-4.5j
>>> complex(-1.23, 4.5)
(-1.23+4.5j)

If the argument is a string, it must contain either a real part (in the same format as for float()) or an imaginary part (in the same format but with a 'j' or 'J' suffix), or both real and imaginary parts (the sign of the imaginary part is mandatory in this case). The string can optionally be surrounded by whitespaces and the round parentheses '(' and ')', which are ignored. The string must not contain whitespace between '+', '-', the 'j' or 'J' suffix, and the decimal number. For example, complex('1+2j') is fine, but complex('1 + 2j') raises ValueError. More precisely, the input must conform to the complexvalue production rule in the following grammar, after parentheses and leading and trailing whitespace characters are removed:

complexvalue ::=  floatvalue |
                  floatvalue ("j" | "J") |
                  floatvalue sign absfloatvalue ("j" | "J")

If the argument is a number, the constructor serves as a numeric conversion like int and float. For a general Python object x, complex(x) delegates to x.__complex__(). If __complex__() is not defined then it falls back to __float__(). If __float__() is not defined then it falls back to __index__().

If two arguments are provided or keyword arguments are used, each argument may be any numeric type (including complex). If both arguments are real numbers, return a complex number with the real component real and the imaginary component imag. If both arguments are complex numbers, return a complex number with the real component real.real-imag.imag and the imaginary component real.imag+imag.real. If one of arguments is a real number, only its real component is used in the above expressions.

If all arguments are omitted, returns 0j.

Il tipo complesso è descritto in Tipi Numerici — int, float, complex.

Cambiato nella versione 3.6: È consentito raggruppare le cifre con trattini bassi come nei letterali di codice.

Cambiato nella versione 3.8: Ricade su __index__() se __complex__() e __float__() non sono definiti.

Deprecato dalla versione 3.14: Passing a complex number as the real or imag argument is now deprecated; it should only be passed as a single positional argument.

delattr(object, name)

Questo è un parente di setattr(). Gli argomenti sono un oggetto e una stringa. La stringa deve essere il nome di uno degli attributi dell’oggetto. La funzione elimina l’attributo denominato, a condizione che l’oggetto lo permetta. Ad esempio, delattr(x, 'foobar') è equivalente a del x.foobar. name non deve necessariamente essere un identificatore Python (vedi setattr()).

class dict(**kwarg)

class dict(mapping, **kwarg)

class dict(iterable, **kwarg)

Crea un nuovo dizionario. L’oggetto dict è la classe del dizionario. Vedi dict e Tipi di Mapping — dict per la documentazione su questa classe.

Per altri contenitori vedere le classi integrate list, set e tuple, così come il modulo collections.

dir()

dir(object)

Senza argomenti, restituisce l’elenco dei nomi nell’attuale ambito locale. Con un argomento, tenta di restituire un elenco di attributi validi per quell’oggetto.

Se l’oggetto ha un metodo chiamato __dir__(), verrà chiamato e deve restituire l’elenco degli attributi. Questo consente agli oggetti che implementano una funzione personalizzata __getattr__() o __getattribute__() di personalizzare il modo in cui dir() riporta i loro attributi.

Se l’oggetto non fornisce __dir__(), la funzione fa del suo meglio per raccogliere informazioni dall’attributo __dict__ dell’oggetto, se definito, e dal suo tipo di oggetto. L’elenco risultante non è necessariamente completo e può essere inaccurato se l’oggetto ha una funzione personalizzata __getattr__().

Il meccanismo predefinito di dir() si comporta diversamente con diversi tipi di oggetti, poiché tenta di produrre le informazioni più rilevanti, piuttosto che complete:

• Se l’oggetto è un oggetto modulo, l’elenco contiene i nomi degli attributi del modulo.

• Se l’oggetto è un oggetto di tipo o classe, l’elenco contiene i nomi dei suoi attributi e, ricorsivamente, degli attributi delle sue basi.

• Altrimenti, l’elenco contiene i nomi degli attributi dell’oggetto, i nomi degli attributi della sua classe e, ricorsivamente, degli attributi delle sue classi base.

L’elenco risultante è ordinato alfabeticamente. Ad esempio:

>>> import struct
>>> dir()   # show the names in the module namespace  
['__builtins__', '__name__', 'struct']
>>> dir(struct)   # show the names in the struct module 
['Struct', '__all__', '__builtins__', '__cached__', '__doc__', '__file__',
 '__initializing__', '__loader__', '__name__', '__package__',
 '_clearcache', 'calcsize', 'error', 'pack', 'pack_into',
 'unpack', 'unpack_from']
>>> class Shape:
...     def __dir__(self):
...         return ['area', 'perimeter', 'location']
...
>>> s = Shape()
>>> dir(s)
['area', 'location', 'perimeter']

Nota

Poiché dir() è fornito principalmente come praticità per l’uso in un prompt interattivo, tenta di fornire un insieme di nomi interessante piuttosto che un insieme definito rigorosamente o coerentemente, e il suo comportamento dettagliato può cambiare tra le versioni. Ad esempio, gli attributi delle metaclassi non sono nella lista dei risultati quando l’argomento è una classe.

divmod(a, b)

Prende due numeri (non complessi) come argomenti e restituisce una coppia di numeri costituita dal loro quoziente e resto quando si usa la divisione intera. Con tipi di operandi misti, si applicano le regole per gli operatori aritmetici binari. Per gli interi, il risultato è lo stesso di (a // b, a % b). Per i numeri in virgola mobile il risultato è (q, a % b), dove q è solitamente math.floor(a / b) ma può essere 1 in meno di quello. In ogni caso q * b + a % b è molto vicino a a, se a % b è diverso da zero ha lo stesso segno di b, e 0 <= abs(a % b) < abs(b).

enumerate(iterable, start=0)

Restituisce un oggetto enumerate. iterable deve essere una sequenza, un iterator o qualche altro oggetto che supporti l’iterazione. Il metodo __next__() dell’iteratore restituito da enumerate() restituisce una tupla contenente un conteggio (da start che per impostazione predefinita è 0) e i valori ottenuti iterando su iterable.

>>> seasons = ['Spring', 'Summer', 'Fall', 'Winter']
>>> list(enumerate(seasons))
[(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]
>>> list(enumerate(seasons, start=1))
[(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]

Equivalente a:

def enumerate(iterable, start=0):
    n = start
    for elem in iterable:
        yield n, elem
        n += 1

eval(source, /, globals=None, locals=None)

Parametri:

• source (str | code object) – Un’espressione Python.

• globals (dict | None) – Lo spazio dei nomi globale (predefinito: None).

• locals (mapping | None) – Lo spazio dei nomi locale (predefinito: None).

Ritorna:

Il risultato dell’espressione valutata.

solleva:

Gli errori di sintassi sono segnalati come eccezioni.

L’argomento expression viene analizzato e valutato come un’espressione Python (tecnicamente parlando, una lista di condizioni) usando le mappature globals e locals come spazio dei nomi globale e locale. Se il dizionario globals è presente e non contiene un valore per la chiave __builtins__, viene inserito un riferimento al dizionario del modulo integrato builtins sotto quella chiave prima che expression venga analizzata. In questo modo puoi controllare quali builtins sono disponibili per il codice eseguito inserendo il tuo dizionario __builtins__ in globals prima di passarlo a eval(). Se la mappatura locals è omessa, viene impostata al dizionario globals. Se entrambe le mappature sono omesse, l’espressione viene eseguita con i globals e i locals nell’ambiente in cui viene chiamato eval(). Nota, eval() avrà accesso solo agli nested scopes (non-locals) nell’ambiente di inclusione se sono già referenziati nello scope che chiama eval() (ad esempio tramite un’istruzione nonlocal).

Esempio:

>>> x = 1
>>> eval('x+1')
2

Questa funzione può essere utilizzata anche per eseguire oggetti codice arbitrari (come quelli creati da compile()). In questo caso, passa un oggetto codice invece di una stringa. Se l’oggetto codice è stato compilato con 'exec' come argomento mode, il valore restituito da eval() sarà None.

Suggerimenti: l’esecuzione dinamica delle istruzioni è supportata dalla funzione exec(). Le funzioni globals() e locals() restituiscono rispettivamente il dizionario globale e locale corrente, che possono essere utili da passare per l’uso da parte di eval() o exec().

Se la sorgente data è una stringa, allora gli spazi e le tabulazioni iniziali e finali vengono rimossi.

Vedi ast.literal_eval() per una funzione che può valutare in sicurezza stringhe con espressioni contenenti solo letterali.

Solleva un evento di auditing exec con argomento code_object.

Cambiato nella versione 3.13: Gli argomenti globals e locals possono ora essere passati come parole chiave.

Cambiato nella versione 3.13: La semantica dello spazio dei nomi locals predefinito è stata modificata come descritto peril builtin locals().

exec(source, /, globals=None, locals=None, *, closure=None)

Questa funzione supporta l’esecuzione dinamica di codice Python. source deve essere una stringa o un oggetto codice. Se è una stringa, la stringa viene analizzata come una suite di istruzioni Python che viene quindi eseguita (a meno che non si verifichi un errore di sintassi). [1] Se è un oggetto codice, viene semplicemente eseguito. In tutti i casi, il codice eseguito è previsto come input di file valido (vedi la sezione File input nel Manuale di Riferimento). Tieni presente che le istruzioni nonlocal, yield e return non possono essere utilizzate al di fuori delle definizioni delle funzioni anche all’interno del contesto del codice passato alla funzione exec(). Il valore restituito è None.

In ogni caso, se vengono omesse le parti opzionali, il codice viene eseguito nell’ambito corrente. Se viene fornito solo globals, deve essere un dizionario (e non una sottoclasse del dizionario), che verrà utilizzato sia per le variabili globali che per quelle locali. Se vengono forniti globals e locals, vengono utilizzati rispettivamente per le variabili globali e locali. Se fornito, locals può essere qualsiasi oggetto di mappatura. Ricorda che a livello di modulo, globals e locals sono lo stesso dizionario.

Nota

Quando exec ottiene due oggetti separati come globals e locals, il codice verrà eseguito come se fosse incorporato in una definizione di classe. Ciò significa che le funzioni e le classi definite nel codice eseguito non potranno accedere alle variabili assegnate a livello di alto (poiché le variabili «di alto livello» sono trattate come variabili di classe in una definizione di classe).

Se il dizionario globals non contiene un valore per la chiave __builtins__, viene inserito un riferimento al dizionario del modulo integrato builtins sotto quella chiave. In questo modo puoi controllare quali builtins sono disponibili per il codice eseguito inserendo il tuo dizionario __builtins__ in globals prima di passarlo a exec().

L’argomento closure specifica una chiusura–una tupla di cellvars. È valido solo quando l”oggetto è un oggetto codice contenente variabili libere. La lunghezza della tupla deve esattamente corrispondere al numero di variabili libere referenziate dall’oggetto codice.

Solleva un evento di auditing exec con argomento code_object.

Nota

Le funzioni integrate globals() e locals() restituiscono rispettivamente l’attuale spazio dei nomi globale e locale, che possono essere utili da passare come secondo e terzo argomento a exec().

Nota

Il locals predefinito agisce come descritto per la funzione locals() di seguito. Passa un dizionario locals esplicito se hai bisogno di vedere gli effetti del codice su locals dopo che la funzione exec() restituisce.

Cambiato nella versione 3.11: Aggiunto il parametro closure.

Cambiato nella versione 3.13: Gli argomenti globals e locals possono ora essere passati come parole chiave.

Cambiato nella versione 3.13: La semantica dello spazio dei nomi locals predefinito è stata modificata come descritto peril builtin locals().

filter(function, iterable)

Costruisce un iteratore dagli elementi di iterable per i quali function è vera. iterable può essere una sequenza, un contenitore che supporta l’iterazione, o un iteratore. Se function è None, si assume la funzione identità, ovvero, tutti gli elementi di iterable che sono falsi vengono rimossi.

Nota che filter(function, iterable) è equivalente all’espressione generatrice (item for item in iterable if function(item)) se function non è None e (item for item in iterable if item) se function è None.

Vedi itertools.filterfalse() per la funzione complementare che restituisce elementi di iterable per i quali function è falsa.

class float(number=0.0, /)

class float(string, /)

Return a floating point number constructed from a number or a string.

Examples:

>>> float('+1.23')
1.23
>>> float('   -12345\n')
-12345.0
>>> float('1e-003')
0.001
>>> float('+1E6')
1000000.0
>>> float('-Infinity')
-inf

If the argument is a string, it should contain a decimal number, optionally preceded by a sign, and optionally embedded in whitespace. The optional sign may be '+' or '-'; a '+' sign has no effect on the value produced. The argument may also be a string representing a NaN (not-a-number), or positive or negative infinity. More precisely, the input must conform to the floatvalue production rule in the following grammar, after leading and trailing whitespace characters are removed:

sign          ::=  "+" | "-"
infinity      ::=  "Infinity" | "inf"
nan           ::=  "nan"
digit         ::=  <a Unicode decimal digit, i.e. characters in Unicode general category Nd>
digitpart     ::=  digit (["_"] digit)*
number        ::=  [digitpart] "." digitpart | digitpart ["."]
exponent      ::=  ("e" | "E") [sign] digitpart
floatnumber   ::=  number [exponent]
absfloatvalue ::=  floatnumber | infinity | nan
floatvalue    ::=  [sign] absfloatvalue

La distinzione tra maiuscole e minuscole non è significativa, quindi, per esempio, «inf», «Inf», «INFINITY» e «iNfINity» sono tutte ortografie accettabili per l’infinito positivo.

In caso contrario, se l’argomento è un numero intero o a virgola mobile, viene restituito un numero a virgola mobile con lo stesso valore (entro la precisione dei numeri a virgola mobile di Python). Se l’argomento è al di fuori del range di un float di Python, viene sollevata un’eccezione OverflowError.

Per un oggetto Python generico x, float(x) si delega a x.__float__(). Se __float__() non è definito, si ritorna a __index__().

Se non viene fornito alcun argomento, viene restituito 0.0.

Il tipo float è descritto in Tipi Numerici — int, float, complex.

Cambiato nella versione 3.6: È consentito raggruppare le cifre con trattini bassi come nei letterali di codice.

Cambiato nella versione 3.7: The parameter is now positional-only.

Cambiato nella versione 3.8: Ritorna a __index__() se __float__() non è definito.

format(value, format_spec='')

Converte un value in una rappresentazione «formattata», come controllato da format_spec. L’interpretazione di format_spec dipenderà dal tipo dell’argomento value; tuttavia, esiste una sintassi di formattazione standard utilizzata dalla maggior parte dei tipi integrati: Format Specification Mini-Language.

Il format_spec predefinito è una stringa vuota che di solito dà lo stesso effetto di una chiamata a str(value).

Una chiamata a format(value, format_spec) viene tradotta in type(value).__format__(value, format_spec) che bypassa il dizionario dell’istanza quando si cerca il metodo __format__() del valore. Viene sollevata un’eccezione TypeError se la ricerca del metodo raggiunge object e format_spec non è vuoto, o se format_spec o il valore restituito non sono stringhe.

Cambiato nella versione 3.4: object().__format__(format_spec) solleva TypeError se format_spec non è una stringa vuota.

class frozenset(iterable=set())

Restituisce un nuovo oggetto frozenset, opzionalmente con elementi tratti da iterable. frozenset è una classe integrata. Vedi frozenset e Tipi di Insiemi — set, frozenset per la documentazione su questa classe.

Per altri contenitori vedere le classi integrate set, list, tuple e dict, così come il modulo collections.

getattr(object, name)

getattr(object, name, default)

Restituisce il valore dell’attributo nominato di object. name deve essere una stringa. Se la stringa è il nome di uno degli attributi dell’oggetto, il risultato è il valore di quell’attributo. Ad esempio, getattr(x, 'foobar') è equivalente a x.foobar. Se l’attributo nominato non esiste, viene restituito default se fornito, altrimenti viene sollevata un’eccezione AttributeError. name non deve necessariamente essere un identificatore Python (vedi setattr()).

Nota

Poiché il private name mangling avviene al momento della compilazione, è necessario manipolare manualmente il nome di un attributo privato (attributi con due underscore iniziali) per recuperarlo con getattr().

globals()

Restituisce il dizionario che implementa lo spazio dei nomi del modulo corrente. Per il codice all’interno delle funzioni, questo viene impostato quando la funzione è definita e rimane lo stesso indipendentemente da dove la funzione viene chiamata.

hasattr(object, name)

Gli argomenti sono un oggetto e una stringa. Il risultato è True se la stringa è il nome di uno degli attributi dell’oggetto, False se non lo è. (Questo è implementato chiamando getattr(object, name) e verificando se solleva un’eccezione AttributeError o meno.)

hash(object)

Restituisce il valore hash dell’oggetto (se ne ha uno). I valori hash sono interi. Vengono utilizzati per confrontare rapidamente le chiavi del dizionario durante una ricerca nel dizionario. I valori numerici che risultano uguali hanno lo stesso valore hash (anche se sono di tipi diversi, come nel caso di 1 e 1.0).

Nota

Per gli oggetti con metodi personalizzati __hash__(), si noti che hash() tronca il valore restituito in base alla larghezza di bit della macchina ospite.

help()

help(request)

Avvia il sistema di aiuto integrato. (Questa funzione è destinata all’uso interattivo.) Se non viene fornito alcun argomento, il sistema di aiuto interattivo si avvia sulla console dell’interprete. Se l’argomento è una stringa, la stringa viene cercata come nome di un modulo, funzione, classe, metodo, parola chiave o argomento della documentazione, e viene stampata una pagina di aiuto sulla console. Se l’argomento è di qualsiasi altro tipo di oggetto, viene generata una pagina di aiuto sull’oggetto.

Si noti che se appare una barra (/) nell’elenco dei parametri di una funzione quando si invoca help(), significa che i parametri precedenti alla barra sono solo posizionali. Per ulteriori informazioni, vedere la FAQ sugli argomenti solo posizionali.

Questa funzione viene aggiunta allo spazio dei nomi integrato dal modulo site.

Cambiato nella versione 3.4: Le modifiche a pydoc e inspect significano che le firme riportate per gli oggetti invocabili sono ora più complete e coerenti.

hex(x)

Converte un numero intero in una stringa esadecimale in minuscolo con prefisso «0x». Se x non è un oggetto int di Python, deve definire un metodo __index__() che ritorna un intero. Alcuni esempi:

>>> hex(255)
'0xff'
>>> hex(-42)
'-0x2a'

Se si desidera convertire un numero intero in una stringa esadecimale maiuscola o minuscola con prefisso o meno, è possibile utilizzare uno dei seguenti modi:

>>> '%#x' % 255, '%x' % 255, '%X' % 255
('0xff', 'ff', 'FF')
>>> format(255, '#x'), format(255, 'x'), format(255, 'X')
('0xff', 'ff', 'FF')
>>> f'{255:#x}', f'{255:x}', f'{255:X}'
('0xff', 'ff', 'FF')

Vedi anche format() per maggiori informazioni.

Vedi anche int() per convertire una stringa esadecimale in un numero intero utilizzando una base di 16.

Nota

Per ottenere una rappresentazione in stringa esadecimale di un float, utilizzare il metodo float.hex().

id(object)

Restituisce «l’identità» di un oggetto. Questo è un numero intero che è garantito essere unico e costante per questo oggetto durante la sua vita. Due oggetti con vite non sovrapposte possono avere lo stesso valore di id().

Dettaglio dell’implementazione di CPython: Questo è l’indirizzo dell’oggetto in memoria.

Solleva un evento di auditing builtins.id con l’argomento id.

input()

input(prompt)

Se l’argomento prompt è presente, viene scritto nello standard output senza un a capo finale. La funzione legge quindi una riga dall’input, la converte in una stringa (eliminando il newline finale) e la restituisce. Quando EOF viene letto, viene sollevata l’eccezione EOFError. Esempio:

>>> s = input('--> ')  
--> Monty Python's Flying Circus
>>> s  
"Monty Python's Flying Circus"

Se il modulo readline è stato caricato, allora input() lo utilizzerà per fornire funzionalità di modifica elaborata delle righe e cronologia.

Solleva un evento di auditing builtins.input con l’argomento prompt.

Solleva un evento di auditing builtins.input/result con l’argomento result.

class int(number=0, /)

class int(string, /, base=10)

Return an integer object constructed from a number or a string, or return 0 if no arguments are given.

Examples:

>>> int(123.45)
123
>>> int('123')
123
>>> int('   -12_345\n')
-12345
>>> int('FACE', 16)
64206
>>> int('0xface', 0)
64206
>>> int('01110011', base=2)
115

If the argument defines __int__(), int(x) returns x.__int__(). If the argument defines __index__(), it returns x.__index__(). For floating point numbers, this truncates towards zero.

If the argument is not a number or if base is given, then it must be a string, bytes, or bytearray instance representing an integer in radix base. Optionally, the string can be preceded by + or - (with no space in between), have leading zeros, be surrounded by whitespace, and have single underscores interspersed between digits.

Una stringa intera in base-n contiene cifre, ciascuna rappresentante un valore da 0 a n-1. I valori 0-9 possono essere rappresentati da qualsiasi cifra decimale Unicode. I valori 10-35 possono essere rappresentati da a a z (o A a Z). La base predefinita è 10. Le basi consentite sono 0 e 2-36. Le stringhe in base 2, 8 e 16 possono essere opzionalmente precedute dai prefissi 0b/0B, 0o/0O o 0x/0X, come con i letterali interi nel codice. Per la base 0, la stringa viene interpretata in modo simile a un letterale intero nel codice, nel senso che la base effettiva è 2, 8, 10 o 16 come determinato dal prefisso. La base 0 disabilita anche gli zeri iniziali: int('010', 0) non è legale, mentre int('010') e int('010', 8) lo sono.

Il tipo di intero è descritto in Tipi Numerici — int, float, complex.

Cambiato nella versione 3.4: Se base non è un’istanza di int e l’oggetto base ha un metodo base.__index__, quel metodo viene chiamato per ottenere un intero per la base. Le versioni precedenti usavano base.__int__ invece di base.__index__.

Cambiato nella versione 3.6: È consentito raggruppare le cifre con trattini bassi come nei letterali di codice.

Cambiato nella versione 3.7: The first parameter is now positional-only.

Cambiato nella versione 3.8: Ritorna a __index__() se __int__() non è definito.

Cambiato nella versione 3.11: int string inputs and string representations can be limited to help avoid denial of service attacks. A ValueError is raised when the limit is exceeded while converting a string to an int or when converting an int into a string would exceed the limit. See the integer string conversion length limitation documentation.

Cambiato nella versione 3.14: int() no longer delegates to the __trunc__() method.

isinstance(object, classinfo)

Restituisce True se l’argomento object è un’istanza dell’argomento classinfo, o di una sua sottoclasse (diretta, indiretta o virtual). Se object non è un oggetto di quel tipo, la funzione restituisce sempre False. Se classinfo è una tupla di oggetti di tipo (o ricorsivamente, altre tuple di questo tipo) o una Tipo Unione di più tipi, restituisce True se object è un’istanza di uno qualsiasi dei tipi. Se classinfo non è un tipo o una tupla di tipi e tali tuple, viene sollevata un’eccezione TypeError. TypeError può non essere sollevata per un tipo non valido se un controllo precedente ha successo.

Cambiato nella versione 3.10: classinfo può essere una Tipo Unione.

issubclass(class, classinfo)

Restituisce True se class è una sottoclasse (diretta, indiretta o virtual) di classinfo. Una classe è considerata una sottoclasse di se stessa. classinfo può essere una tupla di oggetti di classe (o ricorsivamente, altre tuple di questo tipo) o una Tipo Unione, nel qual caso restituisce True se class è una sottoclasse di uno qualsiasi degli elementi in classinfo. In ogni altro caso, viene sollevata un’eccezione TypeError.

Cambiato nella versione 3.10: classinfo può essere una Tipo Unione.

iter(object)

iter(object, sentinel)

Restituisce un oggetto iterator. Il primo argomento è interpretato in modo molto diverso a seconda della presenza del secondo argomento. Senza un secondo argomento, object deve essere un oggetto di raccolta che supporta il protocollo iterable (il metodo __iter__()), oppure deve supportare il protocollo della sequenza (il metodo __getitem__() con argomenti interi a partire da 0). Se non supporta nessuno di questi protocolli, viene sollevata un’eccezione TypeError. Se il secondo argomento, sentinel, è dato, allora object deve essere un oggetto callable. L’iteratore creato in questo caso chiamerà object senza argomenti per ogni chiamata al suo metodo __next__(); se il valore restituito è uguale a sentinel, viene sollevata un’eccezione StopIteration, altrimenti il valore verrà restituito.

Vedi anche Tipi di Iteratore.

Una applicazione utile della seconda forma di iter() è costruire un lettore di blocchi. Ad esempio, leggere blocchi a larghezza fissa da un file di database binario fino a raggiungere la fine del file:

from functools import partial
with open('mydata.db', 'rb') as f:
    for block in iter(partial(f.read, 64), b''):
        process_block(block)

len(s)

Restituisce la lunghezza (il numero di elementi) di un oggetto. L’argomento può essere una sequenza (come una stringa, bytes, tuple, list o range) o una collezione (come un dizionario, set o frozenset).

Dettaglio dell’implementazione di CPython: len solleva OverflowError su lunghezze maggiori di sys.maxsize, come range(2 ** 100).

class list

class list(iterable)

Piuttosto che essere una funzione, list è effettivamente un tipo di sequenza mutabile, come documentato in Liste e Tipi di Sequenza — list, tuple, range.

locals()

Restituisce un oggetto di mapping che rappresenta la tabella dei simboli locali corrente, con i nomi delle variabili come chiavi e i riferimenti attualmente associati come valori.

A livello di modulo, così come quando si usa exec() o eval() con uno spazio dei nomi singolo, questa funzione restituisce lo stesso spazio dei nomi di globals().

A livello di classe, restituisce lo spazio dei nomi che sarà passato al costruttore della metaclasse.

Quando si usa exec() o eval() con argomenti locali e globali separati, restituisce lo spazio dei nomi locale passato alla chiamata della funzione.

In tutti i casi sopra menzionati, ogni chiamata a locals() in un determinato frame di esecuzione restituirà lo stesso oggetto di mapping. Le modifiche apportate tramite l’oggetto di mapping restituito da locals() saranno visibili come variabili locali assegnate, riassegnate o eliminate, e assegnare, riassegnare o eliminare variabili locali influenzerà immediatamente il contenuto dell’oggetto di mapping restituito.

In un optimized scope (inclusi funzioni, generatori e coroutine), ogni chiamata a locals() restituisce invece un dizionario nuovo contenente i binding correnti delle variabili locali della funzione e qualsiasi riferimento a celle non locali. In questo caso, le modifiche ai binding dei nomi apportate tramite il dizionario restituito non vengono scritte nuovamente nelle corrispondenti variabili locali o nei riferimenti a celle non locali, e assegnare, riassegnare o eliminare variabili locali e riferimenti a celle non locali non influisce sul contenuto dei dizionari precedentemente restituiti.

Chiamare locals() come parte di una comprensione in una funzione, generatore o coroutine equivale a chiamarlo nello scope contenente, eccetto che le variabili di iterazione inizializzate della comprensione saranno incluse. In altri scope, si comporta come se la comprensione stesse eseguendo come una funzione annidata.

Chiamare locals() come parte di un’espressione del generatore equivale a chiamarlo in una funzione generatore annidata.

Cambiato nella versione 3.12: Il comportamento di locals() in una comprensione è stato aggiornato come descritto in PEP 709.

Cambiato nella versione 3.13: Come parte di PEP 667, sono ora definiti i semantici della modifica degli oggetti mapping restituiti da questa funzione. Il comportamento in ambiti ottimizzati è ora come descritto sopra. A parte essere definiti, il comportamento in altri ambiti rimane invariato rispetto alle versioni precedenti.

map(function, iterable, *iterables)

Restituisce un iteratore che applica funzione a ogni elemento di iterabile, producendo i risultati. Se vengono forniti ulteriori argomenti iterable, function deve prendere altrettanti argomenti ed è applicata agli elementi di tutti gli iterabili in parallelo. Con più iterabili, l’iteratore si ferma quando l’iterabile più corto è esaurito. Per i casi in cui gli input della funzione sono già disposti in tuple di argomenti, vedere itertools.starmap().

max(iterable, *, key=None)

max(iterable, *, default, key=None)

max(arg1, arg2, *args, key=None)

Restituisce l’elemento più grande in un iterabile o il più grande tra due o più argomenti.

Se viene fornito un solo argomento posizionale, dovrebbe essere un iterable. Viene restituito l’elemento più grande dell’iterabile. Se vengono forniti due o più argomenti posizionali, viene restituito il più grande degli argomenti posizionali.

Ci sono due argomenti opzionali solo per parole chiave. L’argomento key specifica una funzione di ordinamento a un argomento, come quella utilizzata per list.sort(). L’argomento default specifica un oggetto da restituire se l’iterabile fornito è vuoto. Se l’iterabile è vuoto e default non è fornito, viene sollevata una ValueError.

Se ci sono più elementi massimali, la funzione restituisce il primo che incontra. Questo è coerente con altri strumenti che preservano la stabilità dell’ordinamento come sorted(iterable, key=keyfunc, reverse=True)[0] e heapq.nlargest(1, iterable, key=keyfunc).

Cambiato nella versione 3.4: Aggiunto il parametro default solo per parole chiave.

Cambiato nella versione 3.8: L’argomento key può essere None.

class memoryview(object)

Restituisce un oggetto «memory view» creato dall’argomento fornito. Vedi Memory Views per ulteriori informazioni.

min(iterable, *, key=None)

min(iterable, *, default, key=None)

min(arg1, arg2, *args, key=None)

Restituisce l’elemento più piccolo in un iterabile o il più piccolo tra due o più argomenti.

Se viene fornito un solo argomento posizionale, dovrebbe essere un iterable. Viene restituito l’elemento più piccolo dell’iterabile. Se vengono forniti due o più argomenti posizionali, viene restituito il più piccolo degli argomenti posizionali.

Ci sono due argomenti opzionali solo per parole chiave. L’argomento key specifica una funzione di ordinamento a un argomento, come quella utilizzata per list.sort(). L’argomento default specifica un oggetto da restituire se l’iterabile fornito è vuoto. Se l’iterabile è vuoto e default non è fornito, viene sollevata una ValueError.

Se ci sono più elementi minimi, la funzione restituisce il primo che incontra. Questo è coerente con altri strumenti che preservano la stabilità dell’ordinamento come sorted(iterable, key=keyfunc)[0] e heapq.nsmallest(1, iterable, key=keyfunc).

Cambiato nella versione 3.4: Aggiunto il parametro default solo per parole chiave.

Cambiato nella versione 3.8: L’argomento key può essere None.

next(iterator)

next(iterator, default)

Recupera l’elemento successivo dall”iterator chiamando il suo metodo __next__(). Se viene fornito default, esso viene restituito se l’iteratore è esaurito, altrimenti viene sollevata l’eccezione StopIteration.

class object

Restituisce un nuovo oggetto senza caratteristiche. object è una base per tutte le classi. Ha metodi comuni a tutte le istanze delle classi Python. Questa funzione non accetta alcun argomento.

Nota

object non ha un __dict__, quindi non puoi assegnare attributi arbitrari a un’istanza della classe object.

oct(x)

Converte un numero intero in una stringa ottale preceduta da «0o». Il risultato è un’istruzione valida in Python. Se x non è un oggetto Python int, deve definire un metodo __index__() che restituisce un intero. Ad esempio:

>>> oct(8)
'0o10'
>>> oct(-56)
'-0o70'

Se vuoi convertire un numero intero in una stringa ottale con o senza il prefisso «0o», puoi usare uno dei seguenti modi.

>>> '%#o' % 10, '%o' % 10
('0o12', '12')
>>> format(10, '#o'), format(10, 'o')
('0o12', '12')
>>> f'{10:#o}', f'{10:o}'
('0o12', '12')

Vedi anche format() per maggiori informazioni.

open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)

Apre file e restituisce un corrispondente file object. Se il file non può essere aperto, viene sollevata un’eccezione OSError. Vedi Lettura e Scrittura di File per ulteriori esempi su come utilizzare questa funzione.

file è un path-like object che fornisce il percorso (assoluto o relativo alla directory di lavoro corrente) del file da aprire o un descrittore del file intero del file da incapsulare. (Se viene fornito un file descriptor, esso viene chiuso quando l’oggetto I/O restituito viene chiuso, a meno che closefd non sia impostato su False.)

mode è una stringa opzionale che specifica il modo in cui il file viene aperto. Il valore predefinito è 'r', che significa aprire per la lettura in modalità testo. Altri valori comuni sono 'w' per la scrittura (troncando il file se esiste già), 'x' per la creazione esclusiva e 'a' per l’aggiunta (che su alcuni sistemi Unix significa che tutte le scritture vengono aggiunte alla fine del file indipendentemente dalla posizione corrente del seek). In modalità testo, se encoding non è specificato, la codifica usata dipende dal sistema: viene chiamata locale.getencoding() per ottenere la codifica locale corrente. (Per leggere e scrivere byte grezzi, usare la modalità binaria e lasciare encoding non specificato.) I modi disponibili sono:

Carattere	Significato
'r'	apri per lettura (predefinito)
'w'	apri per scrittura, troncando prima il file
'x'	apri per creazione esclusiva, fallendo se il file esiste già
'a'	apri per scrittura, aggiungendo alla fine del file se esiste
'b'	modalità binaria
't'	modalità testo (predefinito)
'+'	apri per aggiornamento (lettura e scrittura)

Il modo predefinito è 'r' (aperto per la lettura di testo, sinonimo di 'rt'). I modi 'w+' e 'w+b' aprono il file e lo troncano. I modi 'r+' e 'r+b' aprono il file senza troncamento.

Come menzionato nella Overview, Python distingue tra I/O binario e di testo. I file aperti in modalità binaria (incluso 'b' nell’argomento mode) restituiscono il contenuto come oggetti bytes senza alcuna decodifica. In modalità testo (la predefinita, o quando 't' è incluso nell’argomento mode), il contenuto del file è restituito come str, con i byte decodificati utilizzando una codifica dipendente dalla piattaforma o quella specificata dall’opzione encoding se fornita.

Nota

Python non dipende dalla nozione di file di testo del sistema operativo sottostante; tutta l’elaborazione è fatta da Python stesso e quindi è indipendente dalla piattaforma.

buffering è un intero opzionale utilizzato per impostare la politica di buffering. Passa 0 per disattivare il buffering (consentito solo in modalità binaria), 1 per selezionare il line buffering (utilizzabile solo durante la scrittura in modalità testo) e un intero > 1 per indicare la dimensione in byte di un buffer a dimensione fissa. Nota che specificare una dimensione del buffer in questo modo si applica per I/O binario bufferizzato, ma TextIOWrapper (cioè, i file aperti con mode='r+') avrebbe un altro buffering. Per disabilitare il buffering in TextIOWrapper, considera l’uso del flag write_through per io.TextIOWrapper.reconfigure(). Quando non viene dato l’argomento buffering, la politica di buffering predefinita funziona come segue:

• I file binari sono bufferizzati in blocchi a dimensione fissa; la dimensione del buffer è scelta usando un’euristica che tenta di determinare la «dimensione del blocco» del dispositivo sottostante e ricade su io.DEFAULT_BUFFER_SIZE. In molti sistemi, il buffer sarà tipicamente lungo 4096 o 8192 byte.

• I file di testo «interattivi» (file per cui isatty() restituisce True) utilizzano il line buffering. Altri file di testo utilizzano la politica descritta sopra per i file binari.

encoding è il nome della codifica utilizzata per decodificare o codificare il file. Questo dovrebbe essere usato solo in modalità testo. La codifica predefinita dipende dalla piattaforma (qualsiasi cosa restituita da locale.getencoding()), ma qualsiasi text encoding supportato da Python può essere utilizzato. Vedi il modulo codecs per l’elenco delle codifiche supportate.

errors è una stringa opzionale che specifica come devono essere gestiti gli errori di codifica e decodifica — questo non può essere usato in modalità binaria. È disponibile una varietà di gestori di errore standard (elencati sotto Error Handlers), anche se qualsiasi nome di gestione degli errori registrato con codecs.register_error() è anche valido. I nomi standard includono:

• 'strict' per sollevare un’eccezione ValueError se c’è un errore di codifica. Il valore predefinito di None ha lo stesso effetto.

• 'ignore' ignora gli errori. Nota che ignorare gli errori di codifica può portare a perdita di dati.

• 'replace' fa sì che un marcatore di sostituzione (come '?') venga inserito dove ci sono dati malformati.

• 'surrogateescape' rappresenterà eventuali byte errati come unità di codice basso surrogate che vanno da U+DC80 a U+DCFF. Queste unità di codice surrogate verranno quindi trasformate di nuovo negli stessi byte quando il gestore di errori surrogateescape è utilizzato durante la scrittura dei dati. Questo è utile per elaborare file in una codifica sconosciuta.

• 'xmlcharrefreplace' è supportato solo durante la scrittura in un file. I caratteri non supportati dalla codifica sono sostituiti con il riferimento ai caratteri XML appropriato &#nnn;.

• 'backslashreplace' sostituisce i dati malformati con le sequenze di escape con barra rovesciata di Python.

• 'namereplace' (anche questo supportato solo durante la scrittura) sostituisce i caratteri non supportati con le sequenze di escape \N{...}.

newline determina come analizzare i caratteri di nuova riga dal flusso. Può essere None, '', '\n', '\r' e '\r\n'. Funziona come segue:

• Quando si legge l’input dal flusso, se newline è None, è attivata la modalità di nuove righe universali. Le righe nell’input possono terminare con '\n', '\r' o '\r\n' e queste sono tradotte in '\n' prima di essere restituite al chiamante. Se è '', è attivata la modalità di nuove righe universali, ma le terminazioni di riga sono restituite al chiamante non tradotte. Se ha uno degli altri valori legali, le righe di input sono terminate solo dalla stringa data e la terminazione della riga è restituita al chiamante non tradotta.

• Quando si scrive l’output nel flusso, se newline è None, qualsiasi carattere '\n' scritto è tradotto nel separatore di linea predefinito del sistema, os.linesep. Se newline è '' o '\n', non avviene alcuna traduzione. Se newline è uno degli altri valori legali, qualsiasi carattere '\n' scritto è tradotto nella stringa data.

Se closefd è False e viene fornito un descrittore di file anziché un nome file, il descrittore di file sottostante verrà mantenuto aperto quando il file viene chiuso. Se viene fornito un nome file, closefd deve essere True (predefinito); altrimenti verrà generato un errore.

Un apri-file personalizzato può essere utilizzato passando un callable come opener. Il descrittore di file sottostante per l’oggetto file viene quindi ottenuto chiamando opener con (file, flags). opener deve restituire un descrittore di file aperto (passando os.open come opener si ottiene una funzionalità simile a quella di passare None).

Il file appena creato è non-inheritable.

Il seguente esempio utilizza il parametro dir_fd della funzione os.open() per aprire un file rispetto a una determinata directory:

>>> import os
>>> dir_fd = os.open('somedir', os.O_RDONLY)
>>> def opener(path, flags):
...     return os.open(path, flags, dir_fd=dir_fd)
...
>>> with open('spamspam.txt', 'w', opener=opener) as f:
...     print('This will be written to somedir/spamspam.txt', file=f)
...
>>> os.close(dir_fd)  # don't leak a file descriptor

Il tipo di file object restituito dalla funzione open() dipende dalla modalità. Quando open() è usato per aprire un file in modalità testo ('w', 'r', 'wt', 'rt', ecc.), restituisce una sottoclasse di io.TextIOBase (specificamente io.TextIOWrapper). Quando è usato per aprire un file in modalità binaria con buffering, la classe restituita è una sottoclasse di io.BufferedIOBase. La classe esatta varia: in modalità di lettura binaria, restituisce un io.BufferedReader; in modalità di scrittura binaria e di aggiunta binaria, restituisce un io.BufferedWriter, e in modalità di lettura/scrittura, restituisce un io.BufferedRandom. Quando il buffering è disabilitato, viene restituito il flusso raw, una sottoclasse di io.RawIOBase, io.FileIO.

Vedi anche i moduli di gestione dei file, come fileinput, io (dove è dichiarato open()), os, os.path, tempfile e shutil.

Solleva un auditing event open con argomenti file, mode, flags.

Gli argomenti mode e flags potrebbero essere stati modificati o dedotti dalla chiamata originale.

Cambiato nella versione 3.3:

• È stato aggiunto il parametro opener.

• È stato aggiunto il modo 'x'.

• IOError veniva sollevato in passato, ora è un alias di OSError.

• FileExistsError viene ora sollevato se il file aperto in modalità di creazione esclusiva ('x') esiste già.

Cambiato nella versione 3.4:

• Il file ora è non ereditabile.

Cambiato nella versione 3.5:

• Se la chiamata di sistema viene interrotta e il gestore dei segnali non solleva un’eccezione, la funzione ora riprova la chiamata di sistema anziché sollevare un’eccezione InterruptedError (vedi PEP 475 per la motivazione).

• È stato aggiunto il gestore di errori 'namereplace'.

Cambiato nella versione 3.6:

• È stato aggiunto il supporto per accettare oggetti che implementano os.PathLike.

• Su Windows, l’apertura di un buffer di console può restituire una sottoclasse di io.RawIOBase diversa da io.FileIO.

Cambiato nella versione 3.11: È stato rimosso il modo 'U'.

ord(c)

Data una stringa che rappresenta un carattere Unicode, restituisce un intero che rappresenta il punto di codice Unicode di quel carattere. Ad esempio, ord('a') restituisce l’intero 97 e ord('€') (segno dell’Euro) restituisce 8364. Questo è l’inverso di chr().

pow(base, exp, mod=None)

Restituisce base elevato a exp; se mod è presente, restituisce base elevato a exp, modulo mod (calcolato più efficientemente di pow(base, exp) % mod). La forma a due argomenti pow(base, exp) è equivalente all’utilizzo dell’operatore di potenza: base**exp.

The arguments must have numeric types. With mixed operand types, the coercion rules for binary arithmetic operators apply. For int operands, the result has the same type as the operands (after coercion) unless the second argument is negative; in that case, all arguments are converted to float and a float result is delivered. For example, pow(10, 2) returns 100, but pow(10, -2) returns 0.01. For a negative base of type int or float and a non-integral exponent, a complex result is delivered. For example, pow(-9, 0.5) returns a value close to 3j. Whereas, for a negative base of type int or float with an integral exponent, a float result is delivered. For example, pow(-9, 2.0) returns 81.0.

Per gli operandi int base e exp, se mod è presente, mod deve essere anche di tipo intero e mod deve essere diverso da zero. Se mod è presente e exp è negativo, base deve essere relativamente primo a mod. In tal caso, viene restituito pow(inv_base, -exp, mod), dove inv_base è un inverso di base modulo mod.

Ecco un esempio di calcolo di un inverso per 38 modulo 97:

>>> pow(38, -1, mod=97)
23
>>> 23 * 38 % 97 == 1
True

Cambiato nella versione 3.8: Per gli operandi int, la forma a tre argomenti di pow ora consente che il secondo argomento sia negativo, permettendo il calcolo degli inversi modulari.

Cambiato nella versione 3.8: Consente argomenti di parola chiave. In passato, erano supportati solo argomenti posizionali.

print(*objects, sep=' ', end='\n', file=None, flush=False)

Stampa objects sul flusso di testo file, separati da sep e seguiti da end. sep, end, file e flush, se presenti, devono essere dati come argomenti di parola chiave.

Tutti gli argomenti non di parola chiave sono convertiti in stringhe come fa str() e scritti nel flusso, separati da sep e seguiti da end. Sia sep che end devono essere stringhe; possono anche essere None, il che significa usare i valori predefiniti. Se non vengono dati objects, print() scriverà solo end.

L’argomento file deve essere un oggetto con un metodo write(string); se non è presente o è None, verrà utilizzato sys.stdout. Poiché gli argomenti stampati sono convertiti in stringhe di testo, print() non può essere utilizzato con oggetti file in modalità binaria. Per questi, utilizzare file.write(...) invece.

Il buffering dell’output è di solito determinato da file. Tuttavia, se flush è vero, il flusso viene forzato a essere svuotato.

Cambiato nella versione 3.3: Aggiunto il parametro di parola chiave flush.

class property(fget=None, fset=None, fdel=None, doc=None)

Restituisce un attributo di proprietà.

fget è una funzione per ottenere il valore di un attributo. fset è una funzione per impostare il valore di un attributo. fdel è una funzione per eliminare il valore di un attributo. E doc crea una docstring per l’attributo.

Un uso tipico è definire un attributo gestito x:

class C:
    def __init__(self):
        self._x = None

    def getx(self):
        return self._x

    def setx(self, value):
        self._x = value

    def delx(self):
        del self._x

    x = property(getx, setx, delx, "I'm the 'x' property.")

Se c è un’istanza di C, c.x invocherà il getter, c.x = valore invocherà il setter, e del c.x il deleter.

Se fornito, doc sarà la docstring dell’attributo property. Altrimenti, la property copierà la docstring di fget (se esiste). Questo rende possibile creare facilmente proprietà di sola lettura usando property() come un decorator:

class Parrot:
    def __init__(self):
        self._voltage = 100000

    @property
    def voltage(self):
        """Get the current voltage."""
        return self._voltage

Il decoratore @property trasforma il metodo voltage() in un «getter» per un attributo di sola lettura con lo stesso nome, e imposta la docstring di voltage a «Get the current voltage.»

@getter

@setter

@deleter

Un oggetto property ha metodi getter, setter, e deleter utilizzabili come decoratori che creano una copia della property con la funzione di accesso corrispondente impostata sulla funzione decorata. Questo è spiegato al meglio con un esempio:

class C:
    def __init__(self):
        self._x = None

    @property
    def x(self):
        """I'm the 'x' property."""
        return self._x

    @x.setter
    def x(self, value):
        self._x = value

    @x.deleter
    def x(self):
        del self._x

Questo codice è esattamente equivalente al primo esempio. Assicurati di dare alle funzioni aggiuntive lo stesso nome della proprietà originale (x in questo caso.)

L’oggetto property restituito ha anche gli attributi fget, fset, e fdel corrispondenti agli argomenti del costruttore.

Cambiato nella versione 3.5: Le docstring degli oggetti property ora sono scrivibili.

class range(stop)

class range(start, stop, step=1)

Piuttosto che essere una funzione, range è in realtà un tipo di sequenza immutabile, come documentato in Intervalli e Tipi di Sequenza — list, tuple, range.

repr(object)

Restituisce una stringa contenente una rappresentazione stampabile di un oggetto. Per molti tipi, questa funzione tenta di restituire una stringa che produrrebbe un oggetto con lo stesso valore quando passato a eval(); altrimenti, la rappresentazione è una stringa racchiusa tra parentesi angolari che contiene il nome del tipo dell’oggetto insieme a informazioni aggiuntive, spesso includendo il nome e l’indirizzo dell’oggetto. Una classe può controllare ciò che questa funzione restituisce per le sue istanze definendo un metodo __repr__(). Se sys.displayhook() non è accessibile, questa funzione genererà RuntimeError.

Questa classe ha una rappresentazione personalizzata che può essere valutata:

class Person:
   def __init__(self, name, age):
      self.name = name
      self.age = age

   def __repr__(self):
      return f"Person('{self.name}', {self.age})"

reversed(seq)

Restituisce un iterator invertito. seq deve essere un oggetto che ha un metodo __reversed__() o supporta il protocollo delle sequenze (il metodo __len__() e il metodo __getitem__() con argomenti interi a partire da 0).

round(number, ndigits=None)

Restituisce number arrotondato a ndigits precisione dopo il punto decimale. Se ndigits è omesso o è None, restituisce l’intero più vicino al valore di input.

Per i tipi built-in che supportano round(), i valori sono arrotondati al multiplo più vicino di 10 elevato alla potenza con segno meno ndigits; se due multipli sono ugualmente vicini, l’arrotondamento è fatto verso la scelta pari (così, per esempio, sia round(0.5) che round(-0.5) sono 0, e round(1.5) è 2). Qualsiasi valore intero è valido per ndigits (positivo, zero o negativo). Il valore restituito è un intero se ndigits è omesso o è None. Altrimenti, il valore restituito ha lo stesso tipo di number.

Per un oggetto Python generico number, round delega a number.__round__.

Nota

Il comportamento di round() per i float può essere sorprendente: per esempio, round(2.675, 2) dà 2.67 invece del previsto 2.68. Questo non è un bug: è il risultato del fatto che la maggior parte delle frazioni decimali non può essere rappresentata esattamente come un float. Vedi Aritmetica con i Numeri in Virgola Mobile: Problemi e Limitazioni per maggiori informazioni.

class set

class set(iterable)

Restituisce un nuovo oggetto set, opzionalmente con elementi presi da iterable. set è una classe built-in. Vedi set e Tipi di Insiemi — set, frozenset per la documentazione su questa classe.

Per altri contenitori vedi le classi built-in frozenset, list, tuple, e dict, così come il modulo collections.

setattr(object, name, value)

Questo è il corrispettivo di getattr(). Gli argomenti sono un oggetto, una stringa e un valore arbitrario. La stringa può nominare un attributo esistente o un nuovo attributo. La funzione assegna il valore all’attributo, a condizione che l’oggetto lo consenta. Per esempio, setattr(x, 'foobar', 123) è equivalente a x.foobar = 123.

name non deve essere necessariamente un identificatore Python come definito in Identifiers and keywords a meno che l’oggetto non scelga di far rispettare ciò, per esempio in un metodo personalizzato __getattribute__() o tramite __slots__. Un attributo il cui nome non è un identificatore non sarà accessibile usando la notazione a punto, ma è accessibile tramite getattr() ecc.

Nota

Poiché nome privato confuso avviene al momento della compilazione, bisogna manualmente confondere il nome di un attributo privato (attributi con due trattini bassi all’inizio) per impostarlo con setattr().

class slice(stop)

class slice(start, stop, step=None)

Restituisce un oggetto slice che rappresenta l’insieme di indici specificati da range(start, stop, step). Gli argomenti start e step predefiniti sono None.

start

stop

step

Gli oggetti Slice hanno attributi dati di sola lettura start, stop, e step che restituiscono semplicemente i valori degli argomenti (o il loro valore predefinito). Non hanno altra funzionalità esplicita; tuttavia, sono usati da NumPy e da altri pacchetti di terze parti.

Gli oggetti Slice vengono anche generati quando viene utilizzata la sintassi di indicizzazione estesa. Per esempio: a[start:stop:step] o a[start:stop, i]. Vedi itertools.islice() per una versione alternativa che restituisce un iterator.

Cambiato nella versione 3.12: Gli oggetti Slice ora sono hashable (fornito che start, stop, e step siano hashable).

sorted(iterable, /, *, key=None, reverse=False)

Restituisce una nuova lista ordinata dagli elementi in iterable.

Ha due argomenti opzionali che devono essere specificati come argomenti per parola chiave.

key specifica una funzione di un argomento che viene utilizzata per estrarre una chiave di confronto da ciascun elemento in iterable (per esempio, key=str.lower). Il valore predefinito è None (confronta gli elementi direttamente).

reverse è un valore booleano. Se impostato su True, gli elementi della lista vengono ordinati come se ogni confronto fosse inverso.

Usa functools.cmp_to_key() per convertire una vecchia funzione cmp in una funzione key.

La funzione built-in sorted() è garantita per essere stabile. Un ordinamento è stabile se garantisce di non modificare l’ordine relativo degli elementi che confronta uguali — questo è utile per ordinare in più passaggi (per esempio, ordinare per reparto, poi per grado di stipendio).

L’algoritmo di ordinamento utilizza solo confronti < tra gli elementi. Sebbene la definizione di un metodo __lt__() sia sufficiente per ordinare, PEP 8 raccomanda che tutte e sei le comparazioni ricche siano implementate. Questo aiuterà ad evitare bug quando si utilizza lo stesso dato con altri strumenti di ordinamento come max() che si basano su un metodo sottostante diverso. Implementare tutte e sei le comparazioni aiuta anche a evitare confusione per i confronti di tipo misto che possono chiamare il metodo riflesso __gt__().

Per esempi di ordinamento e un breve tutorial sull’ordinamento, vedere Sorting Techniques.

@staticmethod

Trasforma un metodo in un metodo statico.

Un metodo statico non riceve un argomento primo implicito. Per dichiarare un metodo statico, usa questo idiom:

class C:
    @staticmethod
    def f(arg1, arg2, argN): ...

La forma @staticmethod è un decorator di funzione – vedere Function definitions per dettagli.

Un metodo statico può essere chiamato sia sulla classe (come C.f()) che su un’istanza (come C().f()). Inoltre, il descriptor del metodo statico è anche invocabile, quindi può essere utilizzato nella definizione della classe (come f()).

I metodi statici in Python sono simili a quelli trovati in Java o C++. Inoltre, vedere classmethod() per una variante utile per creare costruttori di classe alternativi.

Come tutti i decoratori, è anche possibile chiamare staticmethod come una funzione regolare e fare qualcosa con il suo risultato. Questo è necessario in alcuni casi in cui è necessario un riferimento a una funzione dal corpo di una classe e si desidera evitare la trasformazione automatica a metodo istanza. Per questi casi, utilizza questo idiom:

def regular_function():
    ...

class C:
    method = staticmethod(regular_function)

Per maggiori informazioni sui metodi statici, vedere The standard type hierarchy.

Cambiato nella versione 3.10: I metodi statici ora ereditano gli attributi del metodo (__module__, __name__, __qualname__, __doc__ e __annotations__), hanno un nuovo attributo __wrapped__, e ora sono invocabili come funzioni regolari.

class str(object='')

class str(object=b'', encoding='utf-8', errors='strict')

Restituisce una versione str di object. Vedi str() per dettagli.

str è la class stringa built-in. Per informazioni generali sulle stringhe, vedere Tipo Sequenza di Testo — str.

sum(iterable, /, start=0)

Somma start e gli elementi di un iterable da sinistra a destra e restituisce il totale. Gli elementi dell”iterable sono normalmente numeri, e il valore iniziale non può essere una stringa.

Per alcuni casi d’uso, ci sono buone alternative a sum(). Il modo preferito e rapido per concatenare una sequenza di stringhe è chiamare ''.join(sequence). Per aggiungere valori a virgola mobile con precisione estesa, vedere math.fsum(). Per concatenare una serie di oggetti iterabili, considera di usare itertools.chain().

Cambiato nella versione 3.8: Il parametro start può essere specificato come argomento per parola chiave.

Cambiato nella versione 3.12: La somma di float è passata a un algoritmo che offre maggiore precisione e migliore commutatività sulla maggior parte delle build.

class super

class super(type, object_or_type=None)

Restituisce un oggetto proxy che delega le chiamate ai metodi a una classe genitrice o sorella di type. Questo è utile per accedere a metodi ereditati che sono stati sovrascritti in una classe.

L”object_or_type determina l’ordine di risoluzione del method resolution order da cercare. La ricerca inizia dalla classe subito dopo type.

Per esempio, se l”__mro__ di object_or_type è D -> B -> C -> A -> object e il valore di type è B, allora super() cerca C -> A -> object.

L’attributo __mro__ di object_or_type elenca l’ordine di ricerca per la risoluzione dei metodi usato sia da getattr() che da super(). L’attributo è dinamico e può cambiare ogni volta che la gerarchia di ereditarietà viene aggiornata.

Se il secondo argomento viene omesso, l’oggetto super restituito non è associato ad alcuna istanza. Se il secondo argomento è un oggetto, isinstance(obj, type) deve essere vero. Se il secondo argomento è un tipo, issubclass(type2, type) deve essere vero (questo è utile per i classmethods).

Quando viene chiamato direttamente all’interno di un metodo ordinario di una classe, entrambi gli argomenti possono essere omessi («zero-argomento super()»). In questo caso, type sarà la classe contenitrice e obj sarà il primo argomento della funzione immediatamente contenitrice (di solito self). (Questo significa che super() con zero argomenti non funzionerà come previsto all’interno di funzioni nidificate, inclusi gli espressioni generatore, che creano implicitamente funzioni nidificate).

Ci sono due casi d’uso tipici per super. In una gerarchia di classi con ereditarietà singola, super può essere usato per riferirsi alle classi genitori senza nominarle esplicitamente, rendendo così il codice più mantenibile. Questo uso è molto simile all’uso di super in altri linguaggi di programmazione.

Il secondo caso d’uso è supportare l’ereditarietà multipla cooperativa in un ambiente di esecuzione dinamico. Questo caso d’uso è unico per Python e non si trova nei linguaggi compilati staticamente o nei linguaggi che supportano solo l’ereditarietà singola. Questo rende possibile implementare «diagrammi a diamante» dove più classi base implementano lo stesso metodo. Un buon design richiede che tali implementazioni abbiano la stessa firma di chiamata in ogni caso (poiché l’ordine delle chiamate è determinato in fase di runtime, perché tale ordine si adatta ai cambiamenti nella gerarchia di classi e perché tale ordine può includere classi sorelle che sono sconosciute prima del runtime).

Per entrambi i casi d’uso, una chiamata tipica alla superclass sembra così:

class C(B):
    def method(self, arg):
        super().method(arg)    # This does the same thing as:
                               # super(C, self).method(arg)

Oltre alla ricerca di metodi, super() funziona anche per la ricerca degli attributi. Un possibile caso d’uso per questo è chiamare i descrittori in una classe genitore o sorella.

Nota che super() è implementato come parte del processo di associazione per le ricerche di attributi punteggiate esplicite come super().__getitem__(name). Lo fa implementando il proprio metodo __getattribute__() per la ricerca di classi in un ordine prevedibile che supporta l’ereditarietà multipla cooperativa. Di conseguenza, super() non è definito per le ricerche implicite utilizzando dichiarazioni o operatori come super()[name].

Nota anche che, a parte la forma con zero argomenti, super() non è limitato all’uso all’interno di metodi. La forma a due argomenti specifica esattamente gli argomenti e fa i riferimenti appropriati. La forma a zero argomenti funziona solo all’interno di una definizione di classe, poiché il compilatore riempie i dettagli necessari per recuperare correttamente la classe in fase di definizione, così come accedere all’istanza corrente per i metodi ordinari.

Per suggerimenti pratici su come progettare classi cooperative usando super(), vedi guida all’uso di super().

class tuple

class tuple(iterable)

Piuttosto che essere una funzione, tuple è effettivamente un tipo di sequenza immutabile, come documentato in Tuple e Tipi di Sequenza — list, tuple, range.

class type(object)

class type(name, bases, dict, **kwds)

Con un argomento, restituisce il tipo di un oggetto. Il valore restituito è un oggetto di tipo ed è generalmente lo stesso oggetto restituito da object.__class__.

La funzione incorporata isinstance() è raccomandata per testare il tipo di un oggetto, poiché prende in considerazione le sottoclassi.

Con tre argomenti, restituisce un nuovo oggetto di tipo. Questo è essenzialmente una forma dinamica della dichiarazione class. La stringa name è il nome della classe e diventa l’attributo __name__. La tupla bases contiene le classi base e diventa l’attributo __bases__; se vuota, object, la base ultima di tutte le classi, è aggiunta. Il dizionario dict contiene le definizioni di attributi e metodi per il corpo della classe; può essere copiato o avvolto prima di diventare l’attributo __dict__. Le seguenti due dichiarazioni creano oggetti type identici:

>>> class X:
...     a = 1
...
>>> X = type('X', (), dict(a=1))

Vedi anche Oggetti Tipo.

Gli argomenti di parole chiave forniti alla forma a tre argomenti sono passati alla macchina adeguata della metaclasse (di solito __init_subclass__()) allo stesso modo degli argomenti di parole chiave in una definizione di classe (a parte metaclass).

Vedi anche Customizing class creation.

Cambiato nella versione 3.6: Le sottoclassi di type che non sovrascrivono type.__new__ possono non usare più la forma con un argomento per ottenere il tipo di un oggetto.

vars()

vars(object)

Restituisce l’attributo __dict__ per un modulo, classe, istanza o qualsiasi altro oggetto con un attributo __dict__.

Oggetti come moduli e istanze hanno un attributo __dict__ aggiornabile; tuttavia, altri oggetti possono avere restrizioni di scrittura sui loro attributi __dict__ (ad esempio, le classi usano un types.MappingProxyType per prevenire aggiornamenti diretti al dizionario).

Senza argomento, vars() si comporta come locals().

Viene sollevata un’eccezione TypeError se viene specificato un oggetto ma non possiede un attributo __dict__ (ad esempio, se la sua classe definisce l’attributo __slots__).

Cambiato nella versione 3.13: Il risultato della chiamata a questa funzione senza argomento è stato aggiornato come descritto per il builtin locals().

zip(*iterables, strict=False)

Itera su più iterabili in parallelo, producendo tuple con un elemento da ciascun iterabile.

Esempio:

>>> for item in zip([1, 2, 3], ['sugar', 'spice', 'everything nice']):
...     print(item)
...
(1, 'sugar')
(2, 'spice')
(3, 'everything nice')

Più formalmente: zip() restituisce un iteratore di tuple, dove la i-esima tupla contiene l”i-esimo elemento di ciascuno degli iterabili argomento.

Un altro modo di pensare a zip() è che trasforma righe in colonne e colonne in righe. Questo è simile a trasporre una matrice.

zip() è pigro: gli elementi non saranno processati fino a quando l’iterabile non viene iterato, ad esempio, tramite un ciclo for o avvolgendolo in una list.

Una cosa da considerare è che gli iterabili passati a zip() potrebbero avere lunghezze diverse; a volte per progettazione e a volte a causa di un bug nel codice che ha preparato questi iterabili. Python offre tre approcci diversi per affrontare questo problema:

• Per impostazione predefinita, zip() si ferma quando l’iterabile più breve è esaurito. Ignorerà gli elementi rimanenti negli iterabili più lunghi, tagliando il risultato alla lunghezza dell’iterabile più corto:

  >>> list(zip(range(3), ['fee', 'fi', 'fo', 'fum']))
  [(0, 'fee'), (1, 'fi'), (2, 'fo')]
  

• zip() è spesso usato nei casi in cui si presume che gli iterabili abbiano la stessa lunghezza. In tali casi, è raccomandato usare l’opzione strict=True. Il suo output è lo stesso del normale zip():

  >>> list(zip(('a', 'b', 'c'), (1, 2, 3), strict=True))
  [('a', 1), ('b', 2), ('c', 3)]
  

  A differenza del comportamento predefinito, solleva un’eccezione ValueError se un iterabile è esaurito prima degli altri:

  >>> for item in zip(range(3), ['fee', 'fi', 'fo', 'fum'], strict=True):  
  ...     print(item)
  ...
  (0, 'fee')
  (1, 'fi')
  (2, 'fo')
  Traceback (most recent call last):
    ...
  ValueError: zip() argument 2 is longer than argument 1
  

  Senza l’argomento strict=True, qualsiasi bug che risulti in iterabili di lunghezze diverse verrà silenziato, possibilmente manifestandosi come un bug difficile da trovare in un’altra parte del programma.

• Gli iterabili più corti possono essere imbottiti con un valore costante per rendere tutti gli iterabili della stessa lunghezza. Questo viene fatto da itertools.zip_longest().

Casi limite: Con un singolo argomento iterabile, zip() restituisce un iteratore di 1-tuple. Senza argomenti, restituisce un iteratore vuoto.

Suggerimenti e trucchi:

• L’ordine di valutazione da sinistra a destra degli iterabili è garantito. Questo rende possibile un idioma per raggruppare una serie di dati in gruppi di lunghezza n usando zip(*[iter(s)]*n, strict=True). Questo ripete lo stesso iteratore n volte in modo che ogni tupla di output contenga il risultato di n chiamate all’iteratore. Questo ha l’effetto di dividere l’input in blocchi di lunghezza n.

• zip() in combinazione con l’operatore * può essere usato per separare una lista:

  >>> x = [1, 2, 3]
  >>> y = [4, 5, 6]
  >>> list(zip(x, y))
  [(1, 4), (2, 5), (3, 6)]
  >>> x2, y2 = zip(*zip(x, y))
  >>> x == list(x2) and y == list(y2)
  True
  

Cambiato nella versione 3.10: Aggiunto l’argomento strict.

__import__(name, globals=None, locals=None, fromlist=(), level=0)

Nota

Questa è una funzione avanzata che non è necessaria nella programmazione Python quotidiana, a differenza di importlib.import_module().

Questa funzione è invocata dalla dichiarazione import. Può essere sostituita (importando il modulo builtins e assegnando a builtins.__import__) al fine di cambiare la semantica della dichiarazione import, ma farlo è fortemente sconsigliato poiché è di solito più semplice usare gli hook di importazione (vedi PEP 302) per raggiungere gli stessi obiettivi e non causa problemi con il codice che assume che l’implementazione di importazione predefinita sia in uso. L’uso diretto di __import__() è anche sconsigliato a favore di importlib.import_module().

La funzione importa il modulo name, potenzialmente utilizzando i globals e locals dati per determinare come interpretare il nome in un contesto di pacchetto. La fromlist fornisce i nomi degli oggetti o sottomoduli che dovrebbero essere importati dal modulo specificato da name. L’implementazione standard non utilizza affatto il suo argomento locals e utilizza il suo argomento globals solo per determinare il contesto di pacchetto della dichiarazione import.

level specifica se usare importazioni assolute o relative. 0 (il valore predefinito) significa eseguire solo importazioni assolute. Valori positivi per level indicano il numero di directory genitore da cercare relativi alla directory del modulo che chiama __import__() (vedi PEP 328 per i dettagli).

Quando la variabile name è della forma package.module, normalmente viene restituito il pacchetto di livello superiore (il nome fino al primo punto), non il modulo denominato name. Tuttavia, quando viene fornito un argomento fromlist non vuoto, viene restituito il modulo denominato name.

Ad esempio, la dichiarazione import spam risulta in un bytecode simile al seguente codice:

spam = __import__('spam', globals(), locals(), [], 0)

La dichiarazione import spam.ham risulta in questa chiamata:

spam = __import__('spam.ham', globals(), locals(), [], 0)

Nota come __import__() restituisce qui il modulo di livello superiore perché questo è l’oggetto che viene associato a un nome dalla dichiarazione import.

D’altra parte, la dichiarazione from spam.ham import eggs, sausage as saus risulta in

_temp = __import__('spam.ham', globals(), locals(), ['eggs', 'sausage'], 0)
eggs = _temp.eggs
saus = _temp.sausage

Qui, il modulo spam.ham viene restituito da __import__(). Da questo oggetto, vengono recuperati i nomi da importare e assegnati ai loro rispettivi nomi.

Se vuoi semplicemente importare un modulo (potenzialmente all’interno di un pacchetto) per nome, usa importlib.import_module().

Cambiato nella versione 3.3: I valori negativi per level non sono più supportati (il che cambia anche il valore predefinito a 0).

Cambiato nella versione 3.9: Quando vengono utilizzate le opzioni della linea di comando -E o -I, la variabile d’ambiente PYTHONCASEOK viene ora ignorata.

Note a piè di pagina

[1]

Nota che il parser accetta solo la convenzione Unix per la fine della riga. Se stai leggendo il codice da un file, assicurati di usare la modalità di conversione delle interruzioni di riga per convertire le interruzioni di riga in stile Windows o Mac.