# 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)

  Return the absolute value of a number. The argument may be an integer, a floating-point number, or an object implementing `__abs__()`. If the argument is a complex number, its magnitude is returned.

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, /)

  Restituisce un valore booleano, ossia uno tra `True` o `False`. L’argomento viene convertito utilizzando la procedura standard di verifica della verità. Se l’argomento è falso o omesso, restituisce `False`; altrimenti, restituisce `True`. La classe `bool` è una sottoclasse di `int` (vedi Tipi Numerici — int, float, complex). Non può essere ulteriormente sottoclassata. I suoi unici istanze sono `False` e `True` (vedi Tipo Booleano - bool).

  Cambiato nella versione 3.7: Il parametro ora è solo posizionale.

breakpoint(*args, **kws)

  This function drops you into the debugger at the call site. Specifically, it calls `sys.breakpointhook()`, passing `args` and `kws` straight through. By default, `sys.breakpointhook()` calls `pdb.set_trace()` expecting no arguments. In this case, it is purely a convenience function so you don’t have to explicitly import `pdb` or type as much code to enter the debugger. However, `sys.breakpointhook()` can be set to some other function and `breakpoint()` will automatically call that, allowing you to drop into the debugger of choice. If `sys.breakpointhook()` is not accessible, this function will raise `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: Class methods now inherit the method attributes (`__module__`, `__name__`, `__qualname__`, `__doc__` and `__annotations__`) and have a new `__wrapped__` attribute.

  Cambiato nella versione 3.11: 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` e `filename`. Questo evento può essere sollevato anche dalla compilazione implicita.

  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)

  Converte una singola stringa o numero in un numero complesso, oppure crea un numero complesso dalle parti reale e immaginaria.

  Esempi:

      >>> 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)

  Se l’argomento è una stringa, deve contenere o una parte reale (nello stesso formato della funzione `float()`) o una parte immaginaria (nello stesso formato ma con un suffisso `'j'` o `'J'`), o entrambe le parti reali e immaginarie (il segno della parte immaginaria è obbligatorio in questo caso). La stringa può facoltativamente essere circondata da spazi bianchi e dalle parentesi tonde `'('` e `')'`, che vengono ignorate. La stringa non deve contenere spazi bianchi tra `'+'`, `'-'`, il suffisso `'j'` o `'J'` e il numero decimale. Ad esempio, `complex('1+2j')` va bene, ma `complex('1 + 2j')` solleva un’eccezione `ValueError`. Più precisamente, l’input deve conformarsi alla regola di produzione `complexvalue` nella seguente grammatica, dopo che sono stati rimossi le parentesi e i caratteri di spazio all’inizio e alla fine:

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

  Se l’argomento è un numero, il costruttore funziona come una conversione numerica come per `int` e `float`. Per un oggetto Python generico `x`, `complex(x)` delega a `x.__complex__()`. Se `__complex__()` non è definito, ricade su `__float__()`. Se `__float__()` non è definito, ricade su `__index__()`.

  Se vengono forniti due argomenti o si utilizzano argomenti chiave, ogni argomento può essere di qualsiasi tipo numerico (incluso complesso). Se entrambi gli argomenti sono numeri reali, restituisce un numero complesso con la componente reale real e la componente immaginaria imag. Se entrambi gli argomenti sono numeri complessi, restituire un numero complesso con la componente reale `real.real - imag.imag` e la componente immaginaria `real.imag + imag.real`. Se uno degli argomenti è un numero reale, viene utilizzata solo la sua componente reale nelle espressioni sopra.

  Se tutti gli argomenti sono omessi, restituisce `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.

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)

  Take two (non-complex) numbers as arguments and return a pair of numbers consisting of their quotient and remainder when using integer division. With mixed operand types, the rules for binary arithmetic operators apply. For integers, the result is the same as `(a // b, a % b)`. For floating-point numbers the result is `(q, a % b)`, where q is usually `math.floor(a / b)` but may be 1 less than that. In any case `q * b + a % b` is very close to a, if `a % b` is non-zero it has the same sign as b, and `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(expression, globals=None, locals=None)
  Parametri:

    - expression (`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.

  Avvertimento

  This function executes arbitrary code. Calling it with user-supplied input may lead to security vulnerabilities.

  L’argomento expression viene interpretato e valutato come un’espressione Python (tecnicamente parlando, una lista di condizioni) utilizzando i dizionari globals e locals come namespace 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 built-in `builtins` sotto quella chiave prima di interpretare l’espressione expression. In questo modo puoi controllare quali built-in sono disponibili nel codice eseguito inserendo il tuo dizionario `__builtins__` in globals prima di passarlo a `eval()`. Se il dizionario locals è omesso, si predefinisce al dizionario globals. Se entrambi i dizionari sono omessi, l’espressione viene eseguita con i globals e locals nell’ambiente in cui viene chiamata `eval()`. Nota, eval() non ha accesso agli scopi annidati (non-locals) nell’ambiente circostante.

  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 l’oggetto codice come argomento. Possono anche essere sollevati eventi di compilazione del codice.

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

  Avvertimento

  This function executes arbitrary code. Calling it with user-supplied input may lead to security vulnerabilities.

  Questa funzione supporta l’esecuzione dinamica di codice Python. object deve essere una stringa o un oggetto codice. Se è una stringa, la stringa viene interpretata come una suite di dichiarazioni Python che vengono poi eseguite (a meno che non si verifichi un errore di sintassi). [1] Se è un oggetto codice, viene semplicemente eseguito. In tutti i casi, il codice che viene eseguito deve essere valido come input di file (vedere la sezione File input nel Manuale di Riferimento). Tieni presente che le dichiarazioni `nonlocal`, `yield` e `return` non possono essere utilizzate al di fuori delle definizioni di funzione, anche nel contesto del codice passato alla funzione `exec()`. Il valore di ritorno è `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

  La maggior parte degli utenti dovrebbe semplicemente passare un argomento globals e mai locals. Se exec riceve due oggetti separati come globals e locals, il codice verrà eseguito come se fosse incorporato 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 l’oggetto codice come argomento. Possono anche essere sollevati eventi di compilazione del codice.

  Nota

  Le funzioni built-in `globals()` e `locals()` restituiscono il dizionario globale e locale corrente, rispettivamente, il che può risultare utile da passare come secondo e terzo argomento a `exec()`.

  Nota

  I locals predefiniti agiscono come descritto per la funzione `locals()` qui sotto: non dovrebbero essere tentate modifiche al dizionario locals predefinito. Passa un dizionario locals esplicito se hai bisogno di vedere gli effetti del codice sui locals dopo che la funzione `exec()` ha restituito.

  Cambiato nella versione 3.11: Aggiunto il parametro closure.

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.

  Esempi:

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

  Se l’argomento è una stringa, dovrebbe contenere un numero decimale, facoltativamente preceduto da un segno, e facoltativamente incorporato in spazi bianchi. Il segno facoltativo può essere `'+'` o `'-'`; un segno `'+'` non ha effetto sul valore prodotto. L’argomento può anche essere una stringa che rappresenta un NaN (not-a-number), o infinito positivo o negativo. Più precisamente, l’input deve conformarsi alla regola di produzione `floatvalue` nella seguente grammatica, dopo che sono stati rimossi i caratteri di spazio all’inizio e alla fine:

      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.

  Otherwise, if the argument is an integer or a floating-point number, a floating-point number with the same value (within Python’s floating-point precision) is returned. If the argument is outside the range of a Python float, an `OverflowError` will be raised.

  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: Il parametro ora è solo posizionale.

  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()`.

  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` prima di leggere l’input.

  Solleva un evento di auditing `builtins.input/result` con il risultato dopo aver letto l’input con successo.

class int(number=0, /)
class int(string, /, base=10)

  Restituisce un oggetto intero costruito da un numero o una stringa, o restituisce `0` se non vengono forniti argomenti.

  Esempi:

      >>> 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__()`. If the argument defines `__trunc__()`, it returns `x.__trunc__()`. For floating-point numbers, this truncates towards zero.

  Se l’argomento non è un numero o se base è fornito, allora deve essere una stringa, un’istanza di `bytes` o di `bytearray` che rappresenta un intero in base base. Facoltativamente, la stringa può essere preceduta da `+` o `-` (senza spazio in mezzo), avere zeri di fronte, essere circondata da spazi bianchi e avere trattini bassi intercalati tra le cifre.

  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: Il primo parametro ora è solo posizionale.

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

  Cambiato nella versione 3.11: La delega a `__trunc__()` è deprecata.

  Cambiato nella versione 3.11: Gli input stringa e le rappresentazioni stringa della classe `int` possono essere limitati per evitare attacchi denial of service. Viene sollevata un’eccezione `ValueError` quando il limite viene superato mentre si converte una stringa in un `int` o quando la conversione di un `int` in una stringa supera il limite. Vedi la documentazione limitazione della lunghezza della stringa di conversione intera.

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).

  `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()

  Aggiorna e restituisce un dizionario che rappresenta la tabella dei simboli locali corrente. Le variabili libere vengono restituite da `locals()` quando viene chiamato nei blocchi funzione, ma non nei blocchi di classe. Nota che a livello di modulo, `locals()` e `globals()` sono lo stesso dizionario.

  Nota

  Il contenuto di questo dizionario non dovrebbe essere modificato; le modifiche potrebbero non influenzare i valori delle variabili locali e libere utilizzate dall’interprete.

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

  This is the ultimate base class of all other classes. It has methods that are common to all instances of Python classes. When the constructor is called, it returns a new featureless object. The constructor does not accept any arguments.

  Nota

  `object` instances do not have `__dict__` attributes, so you can’t assign arbitrary attributes to an instance of `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 is an optional string that specifies the mode in which the file is opened. It defaults to `'r'` which means open for reading in text mode. Other common values are `'w'` for writing (truncating the file if it already exists), `'x'` for exclusive creation, and `'a'` for appending (which on some Unix systems, means that all writes append to the end of the file regardless of the current seek position). In text mode, if encoding is not specified the encoding used is platform-dependent: `locale.getencoding()` is called to get the current locale encoding. (For reading and writing raw bytes use binary mode and leave encoding unspecified.) The available modes are:

  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`.

  Raises an auditing event `open` with arguments `path`, `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 Floating-Point Arithmetic: Issues and Limitations 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: Static methods now inherit the method attributes (`__module__`, `__name__`, `__qualname__`, `__doc__` and `__annotations__`), have a new `__wrapped__` attribute, and are now callable as regular functions.

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.

  For some use cases, there are good alternatives to `sum()`. The preferred, fast way to concatenate a sequence of strings is by calling `''.join(sequence)`. To add floating-point values with extended precision, see `math.fsum()`. To concatenate a series of iterables, consider using `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 dei numeri in virgola mobile è stata cambiata in un algoritmo che offre una maggiore precisione nella 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.

  For example, if `__mro__` of object_or_type is `D -> B -> C -> A -> object` and the value of type is `B`, then `super()` searches `C -> A -> object`.

  The `__mro__` attribute of the class corresponding to object_or_type lists the method resolution search order used by both `getattr()` and `super()`. The attribute is dynamic and can change whenever the inheritance hierarchy is updated.

  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).

  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)

  With one argument, return the type of an object. The return value is a type object and generally the same object as returned by `object.__class__`.

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

  With three arguments, return a new type object. This is essentially a dynamic form of the `class` statement. The name string is the class name and becomes the `__name__` attribute. The bases tuple contains the base classes and becomes the `__bases__` attribute; if empty, `object`, the ultimate base of all classes, is added. The dict dictionary contains attribute and method definitions for the class body; it may be copied or wrapped before becoming the `__dict__` attribute. The following two statements create identical `type` objects:

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

  See also:

  - Documentation on attributes and methods on classes.

  - 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: Subclasses of `type` which don’t override `type.__new__` may no longer use the one-argument form to get the type of an object.

vars()
vars(object)

  Return the `__dict__` attribute for a module, class, instance, or any other object with a `__dict__` attribute.

  Objects such as modules and instances have an updateable `__dict__` attribute; however, other objects may have write restrictions on their `__dict__` attributes (for example, classes use a `types.MappingProxyType` to prevent direct dictionary updates).

  Senza un argomento, `vars()` funziona come `locals()`. Nota, il dizionario locals è utile solo per le letture poiché le modifiche al dizionario locals vengono ignorate.

  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__`).

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.