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

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.
