3.2 La gerarchia dei tipi standard

Di seguito una lista di tutti i tipi che vengono costruiti in Python. I moduli di estensione (scritti in C, Java o altri linguaggi, in funzione dell'implementazione) possono definire ulteriori tipi. Le future versioni di Python potranno aggiungere tipi alla gerarchia dei tipi (per esempio numeri razionali, array di interi memorizzati efficientemente, etc.).

Alcuni dei tipi descritti contengono un paragrafo che elenca gli `attributi speciali'. Questi sono attributi che forniscono accesso all'implemenatzione e non sono intesi per l'uso generale. La loro definizione potrà cambiare in futuro.

None

Questo tipo ha un singolo valore. C'è un solo oggetto con questo valore. Questo oggetto è accessibile attraverso il nome built-in None. Viene utilizzato per indicare l'assenza di un valore in molte situazioni, per esempio, viene restituito dalle funzioni che non restituiscono esplicitamente qualcosa. Il suo valore di verità è ``Falso''.

NotImplemented

Questo tipo ha un singolo valore. C'è un solo oggetto con questo valore. Questo oggetto è accessibile attraverso il nome built-in NotImplemented. I metodi numerici ed i metodi di confronto complessi possono restituire questo valore se non implementano l'operazione per l'operando fornito. (L'interprete proverà quindi a riflettere l'operazione, o altri metodi di fallback, a seconda dell'operatore in questione.) Il suo valore di verità è ``Vero''.

Ellipsis

Questo tipo ha un singolo valore. C'è un solo oggetto con questo valore. Questo oggetto è accessibile con il nome built-in Ellipsis. Viene utilizzato per indicare la presenza di "..." nella sintassi di una sequenza. Il suo valore di verità è ``Vero''.

Numbers

Questi vengono creati da costanti numeriche e restuituiti come risultato di operazioni aritmetiche o funzioni aritmetiche built-in. Gli oggetti numerici sono immutabili; una volta creati, il loro valore non verrà mai cambiato. I numeri Python sono ovviamente strettamente correlati con i numeri matematici, ma soggetti alle limitazioni numeriche della rappresentazione su computer.

Python distingue tra interi, numeri in virgola mobile e numeri complessi:

Integers

Questi rappresentano elementi dall'insieme matematico di tutti i numeri:

Ci sono tre tipi di interi:

Interi Plain: Questi rappresentano numeri nell'intervallo da -2147483648 a 2147483647. (L'intervallo può essere maggiore su architetture con una dimensione più grande, ma mai minore.) Quando il risultato di un'operazione cade al di fuori di questo intervallo, il risultato viene normalmente restituito come un intero di tipo long (in alcuni casi, viene invece sollevata l'eccezione OverflowError). Per scopi volti ad operazioni di scorrimento o per maschere, si assume che gli interi abbiano una notazione binaria in complemento a 2, utilizzando 32 bit o più e nascondendo alcuni bit all'utente (cioé, tutti i 4294967296 differenti modelli di bit corrispondono a differenti valori).
Interi Long: Questi rappresentano i numeri in un intervallo illimitato, soggetti solamente alla memoria (virtuale) disponibile. Per scopi volti ad operazioni di scorrimento o per maschere, si assume una rappresentazione binaria e i numeri negativi vengono rappresentati in una variante della notazione in complemento a due che dà l'illusione di una stringa infinita di bit con segno che si estende verso sinistra.
Booleani: Questi rappresentano i valori di verità ``Vero'' e ``Falso''. I due oggetti che rappresentano ``Vero'' e ``Falso'' sono gli unici oggetti booleani. Il tipo Boolean è un sottotipo degli interi plain ed i valori di Boolean si comportano come i valori 0 e 1 rispettivamente, in quasi tutti i contesti, ad eccezione di quando vendono convertiti in stringa, dove vendono restituite, rispettivamente, le stringhe "False" e "True".

Il risultato per la rappresentazione degli interi è intesa per fare l'interpretazione più utile delle operazioni di scorrimento e per le maschere che riguardano i numeri negativi e le minori sorprese possibili quando si effettua un cambiamento tra il dominio degli interi plain e gli interi long. Ogni operazione, ad eccezione dello scorrimento a sinistra, se genera un risultato nel dominio degli interi plain senza generare overflow, genera lo stesso risultato nel dominio degli interi long o quando si utilizzano operandi misti.

Numeri in virgola mobile

Questi rappresentano i numeri in virgola mobile in precisione doppia (rappresentazione finita disponibile su un computer). Siete lasciati alla misericordia dell'architettura sottostante (e delle implementazioni C e Java) per l'intervallo accettato e la gestione dell'overflow. Python non supporta i numeri in virgola mobile in precisione singola; il guadagno in utilizzo di processore e memoria, che è in genere il motivo per utilizzarli, viene sminuito dall'overhead di utilizzare oggetti in Python, perciò non c'è ragione di complicare il linguaggio con due tipi di numeri in virgola mobile.

Numeri complessi

Rappresentano numeri complessi come una coppia di numeri in virgola mobile in precisione doppia. Valgono gli stessi avvertimenti dati per i numeri in virgola mobile. Le parti reali ed immaginarie di un numero complesso z possono essere recuperate attraverso degli attributi in sola lettura z.real e z.imag.

Sequenze

Rappresentano degli insiemi ordinati e finiti di elementi indicizzati tramite numeri non negativi. La funzione built-in len() restituisce il numero di elementi di una sequenza. Quando la lunghezza di una sequenza è n, l'indice contiene i numeri 0, 1, ..., n-1. L'elemento i di una sequenza a viene selezionata tramite a[i].

Le sequenza supportano anche l'affettamento: a[i:j] seleziona tutti gli elementi con indice k tale che vari <= k < j. Quando utilizzata come un'espressione, una fetta è una sequenza dello stesso tipo. Questo implica che l'insieme degli indici viene rinumerato in modo che inizi da 0.

Alcune sequenze supportano anche l'``affettazione estesa'' con un terzo parametro ``passo'': a[i:j:k] seleziona tutti gli elementi di a con un indice x dove x = i + n*k, n >= 0 e i <= x < j.

Le sequenze si distinguono in base alla mutabilità:

Sequenze immutabili

Un oggetto di una sequenza di tipo immutabile non può cambiare una volta che è stato creato. (Se l'oggetto contiene un riferimento ad un'altro oggetto, quest'ultimo può essere mutabile e può cambiare; comunque, la collezione di oggetti direttamente referenziati da un'oggetto immutabile non può cambiare.)

I seguenti tipi sono sequenze immutabili:

Stringhe

Gli elementi di una stringa sono caratteri. Non c'è un tipo separato per i caratteri; un carattere viene rappresentato da una stringa di un elemento. I caratteri rappresentano (almeno) un byte di 8 bit. Le funzioni built-in chr() e ord() effettuano le conversioni tra i caratteri e degli interi non negativi che rappresentano il valore del byte. I byte con i valori 0-127 rappresentano generalmente i valori ASCII corrispondenti, ma l'interpretazione dei valori viene lasciata al programma. Il tipo di dato stringa viene anche utilizzato per rappresentare array di byte, per esempio, per gestire i dati letti da un file.

(Nei sistemi in cui l'insieme di caratteri nativo non è ASCII, le stringhe possono utilizzare EBCDIC nella loro rappresentazione interna e le funzioni chr() ed ord() implementano una mappa tra ASCII e EBCDIC ed il confronto tra stringhe mantiene l'ordine ASCII. (O forse qualcuno può proporre una regola migliore?)

Unicode

Gli elementi di un oggetto Unicode sono unità di codice Unicode. Un'unità di codice Unicode viene rappresentata da n oggetto unicode di un elemento e può contenere un valore a 16 o 32 bit che rappresenta un ordinale Unicode (il massimo valore per gli ordinali Unicode viene indicato in sys.maxunicode e dipende da come è stato configurato Python al momento della compilazione). Negli oggetti Unicode possono essere presenti delle coppie surrogate e verranno segnalate come due elementi separati. Le funzioni built-in unichr() ed ord() convertono tra le unità di codice ed interi non negativi rappresentanti gli ordinali Unicode, come definito nello Standard Unicode 3.0. Le conversioni da e verso le altre codifiche sono possibili attraverso i metodi di codifica encode degli oggetti Unicode e la funzione built-in unicode()..

Tuple

Gli elementi di una tupla sono oggetti Python arbitrari. Le tuple di due o più elementi vengono formattate in una lista di espressioni separate da virgole. Una tupla di un elemento (un 'singleton') può essere formato aggiungendo una virgola ad un'espressione (un'espressione da sola non crea una tupla, poiché le parentesi devono essere utilizzabili per raggruppare le espressioni). Una tupla vuota può essere resa da una coppia vuota di parentesi.

Sequenze mutabili

Le sequenze mutabili possono essere modificate dopo la loro creazione. Le notazioni subscription e slice possono essere utilizzate come obiettivi di un assegnamento o di un'istruzione del (cancella).

C'è attualmente un solo tipo intrinseco di sequenze mutabili:

Liste: Gli elementi di una lista sono oggetti Python arbitrari. Le liste sono formate da una lista di espressioni separate da virgola in una coppia di parentesi quadre. (Notare che non c'è un caso speciale per le liste di lunghezza 0 o 1).

Il modulo di estensione array fornisce un'esempio aggiuntivo di sequenze mutabili.

Mappe

Rappresentano un insieme finito di oggetti indicizzati da un insieme arbitrario di indici. La notazione di subscription a[k] seleziona l'elemento indicizzato k dalla mappa a; questo può essere utilizzato nelle espressioni come obiettivo di un assegnamento o di un'istruzione del (cancella). La funzione built-in len() restituisce il numero di elementi in una mappa.

C'è attualmente un solo tipo intrinseco di mappe:

Dizionari

Rappresentano un insieme finito di oggetti indicizzati da valori praticamente arbitrari. Gli unici tipi di valori non accettabili come chiavi sono i valori contenenti liste o dizionari o altri oggetti di tipo mutabile che vengono confrontati per valore piuttosto che per identità, la ragione di questo è che l'implementazione efficiente dei dizionari richiede un valore di hash per la chiave costante nel tempo. I tipi numerici utilizzati come chiavi obbediscono alle normali regole per il confronto numerico: se due numeri sono uguali (per esempio 1 e 1.0) possono essere usati in modo intercambiabile per indicizzare lo stesso elemento del dizionario.

I dizionari sono mutabili; possono essere creati con la notazione {...} (si veda la sezione 5.2.5, ``Visualizzazione dei dizionari'').

I moduli di estensione dbm, gdbm, bsddb forniscono esempi aggiuntivi di mappe.

Tipi eseguibili

Sono i tipi a cui si può applicare l'operazione di chiamata a funzione (si veda la sezione 5.3.4, ``Chiamate''):

Funzioni definite dall'utente

Un oggetto funzione definita dall'utente viene creato dalla definizione di funzione (si veda la sezione 7.5, ``Definizioni di funzione''). Deve essere chiamato con una lista di argomenti che contiene lo stesso numero di oggetti della lista formale di parametri ammessi per la funzione.

Attributi speciali: func_doc o __doc__ è la stringa di documentazione (docstring) della funzione, o None se non disponibile; func_name o __name__ è il nome della funzione; __module__ è il nome del modulo in cui la funzione è stata definita o None se non disponibile; func_defaults è una tupla che contiene i valori predefiniti per gli argomenti che hanno un valore predefinito oppure None se nessun argomento ha un valore predefinito; func_code è un oggetto di tipo codice che rappresenta il codice compilato del corpo della funzione; func_globals è (un riferimento a) il dizionario che mantiene le variabili globali della funzione -- questo definisce lo spazio dei nomi globale del modulo in cui la funzione viene definita; func_dict o __dict__ contiene lo spazio dei nomi che sostiene gli attributi arbitrari di funzione; func_closure è None oppure una tupla di celle che contengono le associazioni per le variabili libere della funzione.

Di queste, func_code, func_defaults, func_doc/__doc__ e func_dict/__dict__ possono essere scrivibili; le altre non possono mai cambiare. Informazioni aggiuntive circa la definizione della funzione, possono essere recuperate dal suo oggetto di tipo codice; si veda la descrizione dei tipi interni sotto.

Metodi definiti dall'utente

Un oggetto di tipo metodo definito dall'utente combina una classe, un'istanza di classe (o None) ed un qualunque oggetto chiamabile (normalmente una funzione definita dall'utente).

Attributi speciali in sola lettura: im_self è l'oggetto che rappresenta l'istanza della classe; im_func è l'oggetto che rappresenta la funzione; im_class è la classe di im_self per i metodi associati (bound) o la classe a cui chiedere il metodo per i metodi non associati (unbound); __doc__ è la documentazione del metodo (lo stesso di im_func.__doc__); __name__ è il nome del metodo (lo stesso di im_func.__name__); __module__ è il nome del modulo in cui il metodo è stato definito o None se non disponibile. Modificato nella versione 2.2: im_self referenzia la classe che definisce il metodo.

I metodi supportano anche l'accesso (ma non l'impostazione) agli argomenti arbitrari della funzione nell'oggetto sottostante che rappresenta la funzione.

I metodi definiti dall'utente possono essere creati quando si recupera l'attributo di una classe (forse tramite un'istanza di quella classe), se questo attributo è una funzione definita dall'utente, un metodo definito dall'utente non associato o un metodo di classe. Quando l'attributo è un metodo definito dall'utente, un nuovo oggetto di tipo metodo viene creato solo se la classe da cui viene recuperato è la stessa o deriva dalla stessa classe o dalla classe immagazzinata nel metodo originale; altrimenti viene utilizzato il metodo originale.

Quando un metodo definito dall'utente viene creato recuperando una funzione definita dall'utente da una classe, il suo attributo im_self è None e l'oggetto metodo si dice essere non associato. Quando viene creato tramite una funzione definita dall'utente da una classe attraverso una sua istanza, il suo attributo im_self è l'istanza e l'oggetto metodo si dice essere associato. In entrambi i casi, l'attributo im_class del nuovo metodo è la classe da cui il recupero ha luogo e il suo attributo im_func è l'oggetto funzione originale.

Quando un metodo definito dall'utente viene creato recuperando un'altro metodo da una classe o un'istanza, il comportamento è lo stesso che per un oggetto funzione, ad accezione del fatto che l'attributo im_func della nuova istanza non è l'oggetto che rappresenta il metodo originale, ma il suo attributo im_func.

Quando un metodo definito dall'utente viene creato recuperando un metodo di classe da una classe o un'istanza, il suo attributo im_self è la classe stessa (la stessa dell'attributo im_class) e il suo attributo im_func è l'oggetto funzione sottostante al metodo di classe.

Quando un metodo non associato definito dall'utente viene chiamato, la funzione sottostante (im_func) viene chiamata, con la restrizione che il primo argomento deve essere un'istanza della classe appropriata (im_class) o di un suo tipo derivato.

Quando un metodo associato definito dall'utente viene chiamato, la funzione sottostante (im_func) viene chiamata, inserendo l'istanza di classe (im_self) all'inizio della lista di argomenti. Per esempio, quando C è una classe che contiene una definizione per una funzione f() e x è un'istanza di C, chiamare x.f(1) è equivalente a chiamare C.f(x, 1).

Quando un metodo definito dall'utente deriva da un metodo di classe, ``l'istanza di classe'' memorizzata in im_self sarà la classe stessa, così chiamare x.f(1) o C.f(1) è equivalente a chiamare f(C,1), dove f è la funzione sottostante.

Notate che la trasformazione dalla funzione al metodo (associato o non associato) avviene ogni volta che l'attributo viene recuperato da una classe o un'istanza. In alcuni casi, un'ottimizzazione fruttuosa è assegnare l'attributo ad una variabile locale e chiamare la variabile locale. Notare anche che questa trasformazione avviene solo per una funzione definita dall'utente; gli altri oggetti eseguibili (e tutti gli oggetti non eseguibili) vengono recuperati senza trasformazione. È importante notare che le funzioni definite dall'utente che sono attributi di un'istanza di classe non vengono convertiti in metodi associati; questo avviene solamente quando la funzione è un'attributo della classe.

Funzioni generatore

Una funzione od un metodo che usa l'istruzione yield (vedere la sezione 6.8, ``L'istruzione yield'') viene chiamata funzione generatore. Come una funzione, una volta invocata, restituisce sempre un oggetto iteratore che può essere usato per eseguire il corpo della funzione: attraverso il metodo iteratore next() la funzione verrà eseguita finché continuerà a provvedere un valore usando l'istruzione yield. Quando la funzione esegue un'istruzione return o raggiunge la fine, viene sollevata un'eccezione StopIteration e l'iteratore che avrà raggiunto la fine della serie di valori verrà restituito.

Funzioni built-in

Una funzione built-in è un wrapper per le funzioni C. Esempi di funzioni built-in sono len() e math.sin() (math è un modulo built-in standard). Il numero ed il tipo degli argomenti vengono determinati dalla funzione C. Attributi speciali di sola lettura: __doc__ è la stringa di documentazione della funzione, o None se non è disponibile; __name__ è il nome della funzione; __self__ viene impostato a None (vedere comunque il prossimo paragrafo); __module__ è il nome del modulo nel quale la funzione è stata definita o None se non è disponibile.

Metodi built-in

Questo è il travestimento di una funzione built-in, in questo caso contenente un oggetto passato alla funzione C come un implicito argomento extra. Un esempio di un metodo built-in è alist.append(), assumendo alist come un oggetto lista. In questo caso, l'attributo speciale di sola lettura __self__ viene impostato all'oggetto rappresentato dalla lista, list.

Tipi di classi

Le classi tipo, o ``classi di nuovo stile'', sono invocabili. Questi oggetti agiscono normalmente come generatori di nuove istanze di se stesse, ma sono possibili variazioni per le classi tipo che sovrascrivono __new__(). Gli argomenti della chiamata vengono passati a __new__() e, in casi tipici, a __init__() per l'inizializzazione della nuova istanza.

Classi classiche

Gli oggetti classe vengono descritti di seguito. Quando un oggetto classe viene chiamato, viene creata e restituita una nuova istanza della classe (descritta anch'essa di seguito). Questo implica una chiamata al metodo __init__() della classe, se esiste. Qualsiasi argomento viene passato al metodo __init__(). Se non esiste un metodo __init__(), la classe deve essere invocata senza argomenti.

Istanze di una classe

Le istanze di una classe vengono descritte di seguito. Le istanza di una classe sono invocabili solo quando la classe ha un metodo __call__(); x(argomenti) è una scorciatoia per x.__call__(argomenti).

Moduli

I moduli vengono importati attraverso l'istruzione import (vedere la sezione 6.12, ``L'istruzione import'').Un oggetto modulo ha uno spazio dei nomi implementato come fosse un dizionario (questo è il dizionario referenziato dall'attributo func_globals delle funzioni definite nel modulo). I riferimenti agli attributi vengono tradotti in controlli in questo dizionario, per esempio, m.x è equivalente a m.__dict__["x"]. Un oggetto modulo non contiene il codice oggetto usato per inizializzare il modulo (dato che è già stato inizializzato una volta).

L'assegnamento di attributi aggiorna il dizionario dello spazio dei nomi del modulo, per esempio, "m.x = 1" equivale a "m.__dict__["x"] = 1".

Attributi speciali di sola lettura: __dict__ è il dizionario dello spazio dei nomi del modulo.

Attributi predefiniti (modificabili): __name__ è il nome del modulo; __doc__ è la stringa di documentazione del modulo o None se non è disponibile; __file__ è il percorso del file da cui è stato caricato il modulo, se è stato caricato da un file. L'attributo __file__ non è presente per i moduli C che sono linkati staticamente nell'interprete; per estensioni di moduli caricati dinamicamente da librerie condivise, è il percorso del file della libreria condivisa.

Classi

Gli oggetti classe vengono creati dalla definizione class (vedere la sezione 7.6, ``Definizioni di classe''). Una classe ha uno spazio dei nomi implementato attraverso un dizionario. I riferimenti agli attributi della classe vengono tradotti in controlli in questo dizionario, per esempio, "C.x" viene convertito in "C.__dict__["x"]". Quando l'attributo non viene trovato, la sua ricerca continua nelle classi di base. La ricerca è basata prima sulla profondità, da sinistra a destra e nell'ordine delle occorrenze nella lista delle classi di base.

Quando un riferimento ad un attributo di classe (per una classe C) deve produrre una funzione definita dall'utente o uno slegamento di un metodo definito dall'utente la cui classe associata è sia C che ad una delle sue classi di base, viene trasformato in un metodo slegato definito dall'utente il cui attributo im_class è C. Nel caso dovesse produrre un metodo di classe, viene trasformato in un metodo legato definito dall'utente i cui attributi im_class e im_self sono entrambi C. Mentre nel caso dovesse produrre un metodo statico, viene trasformato in un oggetto wrapped dal metodo statico. Vedere la sezione 3.3.2 per altri modi in cui gli attributi ricevuti da una classe possono differire da quelli attualmente contenuti nel proprio __dict__.

L'assegnamento di attributi di una classe aggiornano il dizionario della classe e mai il dizionario della classe di base.

Un oggetto classe può essere chiamato (vedere sopra) per produrre un'istanza di una classe (vedere di seguito).

Attributi speciali: __name__ è il nome della classe; __module__ è il nome del modulo in cui è definita la classe; __dict__ è il dizionario contenente lo spazio dei nomi della classe; __bases__ è una tupla (forse vuota o un singleton) contenente le classi di base nell'ordine delle loro occorrenze nella lista della classe di base; __doc__ è la stringa di documentazione della classe o None se non è definita.

Istanze di classe

L'istanza di una classe viene creata invocando un oggetto class (vedere sopra). L'istanza di una classe ha uno spazio dei nomi implementato come un dizionario che è anche il primo posto in cui verranno cercati i riferimenti agli attributi. Quando non vi viene trovato un attributo e l'istanza della classe non ha attributi con questo nome, la ricerca continua con gli attributi della classe. Se viene trovato un attributo della classe, cioè una funzione definita dall'utente o un metodo non legato definito dall'utente la cui classe associata è la classe (la si chiami C) dell'instanza per cui il riferimento all'attributo è stato inizializzato o uno delle sue basi, viene trasformato in un metodo legato definito dall'utente il cui metodo im_class è C e l'attributo im_self è l'istanza. Metodi statici o metodi di classe vengono anch'essi trasformati, come se non fossero derivati dalla classe C; vedere ``Classi'' esposto in precedenza. Si veda la sezione 3.3.2 per un altro modo in cui gli attributi di una classe, ritrovati attraverso le loro istanze, possono differire dall'oggetto attualmente memorizzato nel __dict__ della classe. Se non viene trovato nessun attributo della classe e la classe possiede un metodo __getattr__(), questo viene chiamato per soddisfare la ricerca.

L'assegnamento e la rimozione di attributi aggiornano il dizionario dell'istanza e mai il dizionario della classe. Se la classe possiede un metodo __setattr__() o __delattr__(), viene invocato questo metodo invece di aggiornare direttamente il dizionario dell'istanza.

Istanze di classe possono pretendere di essere numeri, sequenze o mappe se hanno metodi con certi nomi speciali. Vedere la sezione 3.3, ``Nomi di metodi speciali''.

Attributi speciali: __dict__ è il dizionario degli attributi; __class__ è l'istanza della classe.

File

Un oggetto file rappresenta un file aperto. Oggetti file vengono creati dalla funzione built-in open() ed anche da os.popen(), os.fdopen() e dal metodo makefile() di oggetti socket (e forse da altre funzioni o metodi forniti da moduli di estensione). Gli oggetti sys.stdin, sys.stdout e sys.stderr vengono inizializzati da oggetti file corrispondenti ai flussi input, output ed error dell'interprete standard. Si veda la Libreria Python di riferimento per la documentazione completa di oggetti file.

Tipi interni

Alcuni tipi usati internamente dall'interprete vengono resi disponibili all'utente. Le loro definizioni possono cambiare in versioni future dell'interprete, ma vengono menzionati per completezza.

Codice oggetto

Il codice oggetto rappresenta il codice Python eseguibile, byte-compilato, o bytecode. La differenza tra codice oggetto ed oggetto funzione è che la funzione contiene un esplicito riferimento alle funzioni globali (il modulo in cui è stata definita), mentre un codice oggetto non contiene del contesto; anche i valori degli argomenti predefiniti vengono memorizzati nella funzione, non nel codice oggetto (dato che i valori rappresentati vengono calcolati al momento dell'esecuzione). A differenza delle funzioni, il codice oggetto è immutabile e non contiene riferimenti (diretti o indiretti) ad oggetti mutabili.

Attributi speciali di sola lettura: co_name fornisce il nome della funzione; co_argcount indica il numero degli argomenti posizionali (inclusi gli argomenti con valori predefiniti); co_nlocals indica il numero delle variabili locali usate per la funzione (inclusi gli argomenti); co_varnames è una tupla contenente i nomi delle variabili locali (partendo con i nomi degli argomenti); co_cellvars è una tupla contenente i nomi delle variabili locali che vengono referenziate da funzioni annidate; co_freevars è una tupla contenente i nomi delle variabili libere; co_code è una stringa che rappresenta la sequenza di istruzioni bytecode; co_consts è una tupla contenente le costanti usate dal bytecode; co_names è una tupla contentente i nomi usati dal bytecode; co_filename è il nome del file da cui è stato compilato il codice; co_firstlineno indica il numero della prima riga della funzione; co_lnotab è una stringa che codifica la mappatura degli offset del bytecode in numeri di riga (per dettagli vedere il codice sorgente dell'interprete); co_stacksize è la dimenszione richiesta dello stack (variabili locali incluse); co_flags è un intero che codifica un numero di flag per l'interprete.

I seguenti bit flag vengono definiti per co_flags: il bit 0x04 viene impostato se la funzione usa la sintassi "*argomenti" per accettare un numero arbitrario di argomenti posizionali; il bit 0x08 viene impostato se la funzione usa la sintassi "**keywords" per accettare parole chiavi arbitrarie; il bit 0x20 viene impostato se la funzione è un generatore.

Anche le dichiarazioni di caratteristiche future ("from __future__ import division") usano bit in co_flags per indicare se un codice oggetto è stato compilato con una particolare caratteristica abilitata: il bit 0x2000 viene impostato se la funzione è stata compilata con la funzionalità division di future abilitata; i bit 0x10 e 0x1000 sono stati usati in precedenti versioni di Python.

Altri bit in co_flags vengono riservati per un uso interno.

Se un codice oggetto rappresenta un funzione, la prima voce in co_consts è la stringa di documentazione della funzione o None se non è definita.

Oggetti frame

Gli oggetti frame rappresentano i frame di esecuzione. Si possono presentare in oggetti traceback (vedere sotto).

Attributi speciali di sola lettura: f_back punta al precedente frame dello stack (riguardo al chiamante), o None se questo è l'ultimo frame dello stack; f_code è il codice oggetto eseguito in questo frame; f_locals è il dizionario usato per cercare le variabili locali; f_globals viene usato per variabili globali; f_builtins viene usato per nomi (reali) built-in; f_restricted è un'opzione che indica se la funzione viene eseguita con talune restrizioni (restricted execution mode); f_lasti fornisce l'istruzione precisa (questo è un indice nella striga bytecode del codice oggetto).

Attributi speciali modificabili: f_trace, se non è None, è una funzione invocabile all'avvio di ogni riga di codice sorgente (usata dal debugger); f_exc_type, f_exc_value, f_exc_traceback rappresentano le eccezioni più recenti sollevate in questo frame; f_lineno è il numero di riga corrente del frame -- se lo si scrive all'interno di una funzione trace si salta alla data riga (solo per gli ultimi frame). Un debugger può implementare un comando Jump (anche conosciuto come Set Next Statement) scrivendo in f_lineno.

Oggetti traceback

Gli oggetti traceback rappresentano lo stack trace di un'eccezione. Un oggetto traceback viene creato quando viene sollevata un'eccezione. Quando la ricerca di un'eccezione tratta lo stack di esecuzione, viene inserito un oggetto traceback davanti al corrente traceback per ogni livello. Quando viene inserito un gestore di eccezioni, la traccia dello stack viene resa disponibile al programma. (Vedere la sezione 7.4, ``L'istruzione try.''). È accessibile come sys.exc_traceback ed anche come il terzo elemento della tupla restituita da sys.exc_info(). Quest'ultima è l'interfaccia preferita dato che funziona correttamente quando il programma sta usando thread multipli. Quando il programma non contiene gestori disponibili, la traccia dello stack viene scritta (formattata con precisione) sullo standard error; se l'interprete è interattivo viene comunque resa disponibile all'utente come sys.last_traceback.

Attributi speciali in sola lettura: tb_next è il prossimo livello nella traccia dello stack (riguardo al frame dove si è verificata l'eccezione), o None se non esiste un ulteriore livello; tb_frame punta al frame in esecuzione del livello corrente; tb_lineno fornisce il numero di riga dove è stata sollevata l'eccezione; tb_lasti indica precisamente l'istruzione. Il numero di riga e l'ultima istruzione del traceback possono differire dal numero di riga del proprio oggetto frame se l'eccezione viene sollevata in un'istruzione try con una clausola except non raggiunta o con una clausola finally.

Oggetti fetta

Gli oggetti fetta vengono usati per rappresentare delle fette quando viene usata una sintassi di affettazione estesa. Questa è una fetta che usa i due punti o fette multiple o ellissi separate da virgole, per esempio, a[i:j:step], a[i:j, k:l] o a[..., i:j]. Vengono anche create dalla funzione built-in slice().

Attributi speciali in sola lettura: start è il legame più basso; stop è il legame più alto; step è il valore del passo; ciascuno di questi valori viene considerato None se omesso. Questi attributi possono essere di qualsiasi tipo.

Gli oggetti fetta supportano un metodo:

indices( self, length): Questo metodo accetta come singolo argomento un intero (length) e calcola l'informazione circa la fetta estesa che l'oggetto fetta dovrebbe descrivere se applicato ad una sequenza di length elementi. Restituisce una tupla di tre interi; rispettivamente questi sono gli indici di start, stop e lo step o la lunghezza del passo della fetta. Indici omessi o più grandi del consentito vengono gestiti in modo consistente con fette regolari. Nuovo nella versione 2.3.

Metodi statici degli oggetti

I metodi statici forniscono un modo per annullare la trasformazione di funzioni in metodi come descritto in precedenza. Un metodo statico è un involucro (wrapper) attorno ad altri oggetti, di solito metodi definiti dall'utente. Quando un metodo statico viene richiesto da una classe o dall'istanza di una classe, l'oggetto attualmente restituito è un oggetto involucro (wrapper), che non è soggetto ad altre trasformazioni. I metodi statici non sono essi stessi invocabili, benché gli oggetti siano essi stessi involucri (wrap). I metodi statici vengono creati dal costruttore built-in staticmethod().

Metodi di classe degli oggetti

Un metodo di classe, come un metodo statico, è un involucro (wrapper) attorno ad un altro oggetto che altera il modo nel quale questo oggetto viene richiamato dalla classe e dalle instanze della classe. Come richiamare un metodo di classe è stato descritto in precedenza, in ``Metodi definiti dall'utente''. I metodi di classe vengono creati dal costruttore built-in classmethod().

Vedete Circa questo documento... per informazioni su modifiche e suggerimenti.