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

   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)
class bytearray(source, encoding, errors)

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

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

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

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

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

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

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

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

class bytes(source=b'')
class bytes(source, encoding)
class bytes(source, encoding, errors)

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

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

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

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

callable(object)

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

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

chr(i)

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

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

@classmethod

   Trasforma un metodo in un metodo di classe.

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

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

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

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

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

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

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

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

   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)

   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(**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(source, /, globals=None, locals=None)

   Parametri:
      * **source** ("str" | code object) -- Un'espressione Python.

      * **globals** ("dict" | "None") -- Lo spazio dei nomi globale
        (predefinito: "None").

      * **locals** (*mapping* | "None") -- Lo spazio dei nomi locale
        (predefinito: "None").

   Ritorna:
      Il risultato dell'espressione valutata.

   solleva:
      Gli errori di sintassi sono segnalati come eccezioni.

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

   Esempio:

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

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

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

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

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

   Solleva un evento di auditing "exec" con 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)

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

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

   Nota:

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

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

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

   Solleva un evento di auditing "exec" con 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=set())

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

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

getattr(object, name)
getattr(object, name, default)

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

   Nota:

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

globals()

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

hasattr(object, name)

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

hash(object)

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

   Nota:

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

help()
help(request)

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

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

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

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

hex(x)

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

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

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

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

   Vedi anche "format()" per maggiori informazioni.

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

   Nota:

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

id(object)

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

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

   Solleva un evento di auditing "builtins.id" con l'argomento "id".

input()
input(prompt)

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

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

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

   Solleva un evento di auditing "builtins.input" con l'argomento
   "prompt" 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(object)
iter(object, sentinel)

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

   Vedi anche Tipi di Iteratore.

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

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

len(s)

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

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

class list
class list(iterable)

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

locals()

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

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

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

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

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

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

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

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

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

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

map(function, iterable, *iterables)

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

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

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

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

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

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

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

   Cambiato nella versione 3.8: L'argomento *key* può essere "None".

class memoryview(object)

   Restituisce un oggetto "memory view" creato dall'argomento fornito.
   Vedi Memory Views per ulteriori informazioni.

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

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

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

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

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

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

   Cambiato nella versione 3.8: L'argomento *key* può essere "None".

next(iterator)
next(iterator, default)

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

class object

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

   Nota:

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

oct(x)

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

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

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

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

   Vedi anche "format()" per maggiori informazioni.

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

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

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

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

   __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(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: I metodi statici ora ereditano gli
   attributi del metodo ("__module__", "__name__", "__qualname__",
   "__doc__" e "__annotations__"), hanno un nuovo attributo
   "__wrapped__", e ora sono invocabili come funzioni regolari.

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

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

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

sum(iterable, /, start=0)

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

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

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

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

class tuple
class tuple(iterable)

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

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

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

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

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

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

   Vedi anche Oggetti Tipo.

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

   Vedi anche Customizing class creation.

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

vars()
vars(object)

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

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

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

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

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

zip(*iterables, strict=False)

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

   Esempio:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

   Suggerimenti e trucchi:

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

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

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

   Cambiato nella versione 3.10: Aggiunto l'argomento "strict".

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

   Nota:

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

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

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

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

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

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

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

   La dichiarazione "import spam.ham" risulta in questa chiamata:

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

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

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

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

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

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

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

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

-[ Note a piè di pagina ]-

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