# 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(number, /)

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

  Convert an integer number to a binary string prefixed with «0b». The result is a valid Python expression. If integer is not a Python `int` object, it has to define an `__index__()` method that returns an integer. Some examples:

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

  See also `enum.bin()` to represent negative values as twos-complement.

  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)

  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, errors='strict')

  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, errors='strict')

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

  Return the string representing a character with the specified Unicode code point. For example, `chr(97)` returns the string `'a'`, while `chr(8364)` returns the string `'€'`. This is the inverse of `ord()`.

  The valid range for the argument is from 0 through 1,114,111 (0x10FFFF in base 16). `ValueError` will be raised if it is outside that range.

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

  Deprecated since version 3.11, removed in version 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).

  This function raises `SyntaxError` or `ValueError` if the compiled source is invalid.

  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)

  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.

  See also `complex.from_number()` which only accepts a single numeric argument.

  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(**kwargs)
class dict(mapping, /, **kwargs)
class dict(iterable, /, **kwargs)

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

  Avvertimento

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

  The source argument is parsed and evaluated as a Python expression (technically speaking, a condition list) using the globals and locals mappings as global and local namespace. If the globals dictionary is present and does not contain a value for the key `__builtins__`, a reference to the dictionary of the built-in module `builtins` is inserted under that key before source is parsed. That way you can control what builtins are available to the executed code by inserting your own `__builtins__` dictionary into globals before passing it to `eval()`. If the locals mapping is omitted it defaults to the globals dictionary. If both mappings are omitted, the source is executed with the globals and locals in the environment where `eval()` is called. Note, eval() will only have access to the nested scopes (non-locals) in the enclosing environment if they are already referenced in the scope that is calling `eval()` (e.g. via a `nonlocal` statement).

  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.

  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)

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

  The closure argument specifies a closure–a tuple of cellvars. It’s only valid when the object is a code object containing free (closure) variables. The length of the tuple must exactly match the length of the code object’s `co_freevars` attribute.

  Solleva un evento di auditing `exec` con l’oggetto codice come argomento. Possono anche essere sollevati eventi di compilazione del codice.

  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.

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

  See also `float.from_number()` which only accepts a numeric argument.

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

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

  Convert an integer number to a lowercase hexadecimal string prefixed with «0x». If integer is not a Python `int` object, it has to define an `__index__()` method that returns an integer. Some examples:

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

  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(iterable, /)
iter(callable, sentinel, /)

  Return an iterator object. The first argument is interpreted very differently depending on the presence of the second argument. Without a second argument, the single argument must be a collection object which supports the iterable protocol (the `__iter__()` method), or it must support the sequence protocol (the `__getitem__()` method with integer arguments starting at `0`). If it does not support either of those protocols, `TypeError` is raised. If the second argument, sentinel, is given, then the first argument must be a callable object. The iterator created in this case will call callable with no arguments for each call to its `__next__()` method; if the value returned is equal to sentinel, `StopIteration` will be raised, otherwise the value will be returned.

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

  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(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, strict=False)

  Return an iterator that applies function to every item of iterable, yielding the results. If additional iterables arguments are passed, function must take that many arguments and is applied to the items from all iterables in parallel. With multiple iterables, the iterator stops when the shortest iterable is exhausted. If strict is `True` and one of the iterables is exhausted before the others, a `ValueError` is raised. For cases where the function inputs are already arranged into argument tuples, see `itertools.starmap()`.

  Cambiato nella versione 3.14: Added the strict parameter.

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

  Convert an integer number to an octal string prefixed with «0o». The result is a valid Python expression. If integer is not a Python `int` object, it has to define an `__index__()` method that returns an integer. For example:

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

  - Binary files are buffered in fixed-size chunks; the size of the buffer is `max(min(blocksize, 8 MiB), DEFAULT_BUFFER_SIZE)` when the device block size is available. On most systems, the buffer will typically be 128 kilobytes long.

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

  Return the ordinal value of a character.

  If the argument is a one-character string, return the Unicode code point of that character. For example, `ord('a')` returns the integer `97` and `ord('€')` (Euro sign) returns `8364`. This is the inverse of `chr()`.

  If the argument is a `bytes` or `bytearray` object of length 1, return its single byte value. For example, `ord(b'a')` returns the integer `97`.

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

  When arguments are builtin 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.

  __name__

    Attribute holding the name of the property. The name of the property can be changed at runtime.

    Added in version 3.13.

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

  Return a reverse iterator. The argument must be an object which has a `__reversed__()` method or supports the sequence protocol (the `__len__()` method and the `__getitem__()` method with integer arguments starting at `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(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 Names (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`.

  Slice objects are also generated when slicing syntax is used. For example: `a[start:stop:step]` or `a[start:stop, i]`.

  See `itertools.islice()` for an alternate version that returns an iterator.

  start
  stop
  step

    These read-only attributes are set to the argument values (or their default). They have no other explicit functionality; however, they are used by NumPy and other third-party packages.

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

  The sort algorithm uses only `<` comparisons between items. While defining an `__lt__()` method will suffice for sorting, PEP 8 recommends that all six rich comparisons be implemented. This will help avoid bugs when using the same data with other ordering tools such as `max()` that rely on a different underlying method. Implementing all six comparisons also helps avoid confusion for mixed type comparisons which can call the reflected `__gt__()` method.

  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(*, encoding='utf-8', errors='strict')
class str(object)
class str(object, encoding, errors='strict')
class str(object, *, errors)

  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 di float è passata a un algoritmo che offre maggiore precisione e migliore commutatività sulla maggior parte delle build.

  Cambiato nella versione 3.14: Added specialization for summation of complexes, using same algorithm as for summation of floats.

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

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

  Cambiato nella versione 3.14: `super` objects are now `pickleable` and `copyable`.

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

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