2.1 Funzioni built-in

L'interprete Python ha un numero di funzioni built-in che sono sempre disponibili. Vengono qui elencate in ordine alfabetico.

__import__( name[, globals[, locals[, fromlist]]])

Questa funzione viene invocata dall'istruzione import. Esiste nativamente e potete sostituirla con un'altra funzione che abbia un'interfaccia compatibile, per cambiare la semantica dell'istruzione import. Per gli esempi di cosa potreste fare con questa istruzione, vedete la libreria standard alle voci dei moduli ihooks e rexec. Vedete anche il modulo built-in imp, che definisce alcune utili operazioni al di fuori delle quali potrete costruire le vostre funzioni __import__() personalizzate.

Per esempio, l'istruzione "import spam" risulta nella seguente chiamata: __import__('spam', globals(),, locals(), []); l'istruzione "from spam.ham import eggs" risulta in "__import__('spam.ham', globals(), locals(), ['eggs'])". Notate che anche se locals() e ['eggs'] vengono passate come argomenti, la funzione __import__() non assegna la variabile locale chiamata ['eggs']; questo viene compiuto dal codice successivo, generato per l'istruzione import. (Difatti, l'implementazione standard non usa sempre gli argomenti locals, ed usa i globals solo per determinare il contesto relativo al package dell'istruzione import).

Quando il nome name della variabile è nella forma package.module, normalmente, viene restituito il package di alto livello (il nome che precede il primo punto), non il modulo chiamato da name. Tuttavia, quando viene fornito un argomento fromlist non vuoto, viene restituito il modulo chiamato da name. Questo è stato fatto per mantenere la compatibilità con il bytecode generato per differenti tipologie di istruzioni import; quando si usa "import spam.ham.eggs", il package di alto livello spam deve essere importato nello spazio dei nomi, ma quando si usa "from spam.ham import eggs", il sotto pacchetto spam.ham deve essere usato per cercare la variabile eggs. Per aggirare questo comportamento usate getattr() per estrarre il componente desiderato. Per esempio potreste definire il seguente assistente:

def my_import(name):
    mod = __import__(name)
    components = name.split('.')
    for comp in components[1:]:
        mod = getattr(mod, comp)
    return mod

abs( x): Restituisce il valore assoluto di un numero. L'argomento può essere un numero intero semplice o long, o un numero in virgola mobile. Se l'argomento è un numero complesso, viene restituita la sua grandezza reale.

basestring( ): Questo tipo astratto è la superclasse per str e unicode. Non può essere chiamato o istanziato, ma può essere usato per testare se un oggetto è un'istanza di str o di unicode. isinstance(obj, basestring) è equivalente a isinstance(obj, (str, unicode)). Nuovo nella versione 2.3.

bool( [x]): Converte un valore in un booleano, usando la normale procedura di verifica della verità. Se x è falso o omesso, questa restituisce False (falso); altrimenti restituisce True (vero). bool è anche una classe, sotto classe di int. La classe bool non può contenere altre sotto classi. Le sue uniche istanze sono False e True.
Nuovo nella versione 2.2.1. Modificato nella versione 2.3: Se non viene fornito nessun argomento, questa funzione restituisce False.

callable( object): Restituisce vero se l'argomento oggetto object sembra essere chiamabile, altrimenti restituisce falso. Anche nel caso in cui venga restituito vero, una chiamata a object può comunque non avere successo; se il risultato è falso però, una chiamata a object non potrà mai avere successo. Notate che le classi sono chiamabili se hanno un metodo __call__().

chr( i): Restituisce una stringa di un carattere il cui codice ASCII è l'intero i. Per esempio, chr(97) restituisce la stringa 'a'. Questo è l'inverso di ord(). L'argomento deve essere compreso nell'intervallo [0..255]; Viene sollevata un'eccezione ValueError se i è fuori da questo intervallo.

classmethod( function)

Restituisce un metodo di classe per una funzione function.

Un metodo di classe riceve la classe come primo argomento implicito, proprio come un metodo istanziato riceve l'istanza. Per dichiarare un metodo di una classe, usate questa forma:

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

Può essere chiamato sia su una classe (come C.f()) che su un'istanza (come in C().f()). La chiamata viene ignorata eccetto che per quella classe. Se un metodo della classe viene chiamato per una classe derivata, l'oggetto classe derivata viene passato come primo argomento implicito.

I metodi delle classi sono differenti da quelli del C++ o dai metodi statici di Java. Se li volete, vedete staticmethod() in questa sezione. Nuovo nella versione 2.2.

cmp( x, y): Confronta i due oggetti x e y e restituisce un intero a seconda del risultato. Il valore d'uscita è negativo se x < y, zero se x == y e quindi positivo se x > y.

compile( string, filename, kind[, flags[, dont_inherit]])

Compila la stringa string in un codice oggetto. Il codice oggetto può essere eseguito tramite un'istruzione exec o valutato con una chiamata ad eval(). L'argomento contenente il nome del file, filename, dovrebbe essere il file dal quale viene letto il codice; passate qualche valore riconoscibile se non viene letto da un file ('<string>' viene usato spesso). La tipologia kind, di argomento specifica quale tipo di codice deve essere compilato; può essere 'exec' se la stringa è composta da una sequenza di istruzioni; 'eval' se è composta da una singola espressione, o 'single' se è composta da una singola istruzione interattiva (in quest'ultimo caso l'istruzione valuta che l'espressione abbia un qualsiasi valore, altrimenti viene stampato None).

Quando compilate istruzioni su più righe, adottate due accorgimenti: la fine della riga deve essere rappresentata da un singolo carattere di fine riga ('\n'), e l'input deve essere terminato come minimo da un carattere di fine riga. Se la fine della riga viene rappresentata da '\r\n', usate il metodo delle stringhe replace() per cambiarla in '\n'.

Gli argomenti facoltativi flags e dont_inherit (che sono una novità di Python 2.2) controllano quali istruzioni future (vedete la PEP 236) interesseranno la compilazione della stringa. Se nessuno dei due argomenti è presente (o entrambi sono zero) il codice viene compilato con quelle future istruzioni effettivamente presenti nel codice che si sta chiamando a compilare. Se l'argomento flags è dato e dont_inherit non lo è (o è zero), l'istruzione futura specificata dall'argomento flags viene usata in congiunzione a quelle che sarebbero state comunque utilizzate. Se dont_inherit è un intero diverso da zero, allora l'argomento flags è vero -- le istruzioni future di fatto vengono ignorate dalla chiamata per la compilazione.

Le istruzioni future vengono specificate da bit che possono essere bit per bit or-ed e anche per specificare istruzioni multiple. Il bit-fields richiesto per specificare una data caratteristica può essere trovato come l'attributo compiler_flag nell'istanza _Feature nel modulo __future__.

complex( [real[, imag]]): Crea un numero complesso con il valore reale real più l'immaginario imag*J, o converte una stringa o numero in un numero complesso. Se il primo parametro è una stringa, viene interpretato come un numero complesso, e la funzione deve essere chiamata senza un secondo parametro. Il secondo parametro non può essere una stringa. Ogni argomento può essere di un qualsiasi tipo numerico (inclusi i complessi). Se imag viene omesso, lo si considera zero per definizione, e la funzione serve come una funzione di conversione numerica del genere int(), long() e float(). Se entrambi gli argomenti vengono omessi, restituisce 0j.

delattr( object, name): Questa è simile a setattr(). Gli argomenti sono un oggetto ed una stringa. La stringa deve essere il nome di uno degli attributi dell'oggetto. La funzione cancella gli attributi nominati e provvede ad assegnare l'oggetto. Per esempio delattr(x, 'foobar') è equivalente a del x.foobar.

dict( [mapping-or-sequence])

Restituisce un nuovo dizionario inizializzato da un argomento posizionale facoltativo o da un insieme di argomenti di chiavi. Se non viene dato nessun argomento, restituisce un nuovo dizionario vuoto. Se l'argomento posizionale è un oggetto mappa, restituisce un dizionario che ha le stesse chiavi e gli stessi valori degli oggetti mappa. Altrimenti l'argomento posizionale deve essere una sequenza, un contenitore che supporti l'iterazione, o un oggetto iteratore. Ciascuno degli elementi dell'argomento deve essere inoltre di uno di questi tipi, ed ognuno deve contenere a turno esattamente due oggetti. Il primo viene usato come una chiave in un nuovo dizionario e il secondo come il valore della chiave. Se una chiave data viene vista più di una volta, l'ultimo valore ad essa associato viene conservato nel nuovo dizionario.

Se sono dati gli argomenti chiave, le chiavi stesse con i loro valori associati, vengono aggiunte agli elementi del dizionario. Se una chiave è specificata sia nell'argomento posizionale sia nell'argomento chiave, il valore associato alla chiave viene conservato nel dizionario. Per esempio, tutto questo restituisce un dizionario equivalente a {"uno": 2, "due": 3}:

dict({'uno': 2, 'due': 3})
dict({'uno': 2, 'due': 3}.items())
dict({'uno': 2, 'due': 3}.iteritems())
dict(zip(('uno', 'due'), (2, 3)))
dict([['due', 3], ['uno', 2]])
dict(uno=2, due=3)
dict([(['uno', 'due'][i-2], i) for i in (2, 3)])

Nuovo nella versione 2.2. Modificato nella versione 2.3: Aggiunto il supporto per la costruzione di un dizionario da un argomento chiave.

dir( [object])

Senza argomenti, restituisce l'elenco dei nomi presenti nella locale tavola dei simboli corrente. Con un argomento, cerca di restituire un elenco di attributi validi per quell'oggetto. Questa informazione viene estratta dall'attributo __dict__, se definito, e dalla classe o tipo di oggetto. La lista non è necessariamente completa. Se l'oggetto è un modulo oggetto, la lista contiene i nomi degli attributi dei moduli. Se l'oggetto è un tipo o un oggetto di classe, la lista contiene il nome dei suoi attributi e ricorsivamente degli attributi delle loro basi. Diversamente, la lista contiene il nome degli attributi dell'oggetto, il nome degli attributi della classe e ricorsivamente gli attributi delle classi di base. La lista risultante è ordinata alfabeticamente. Per esempio:

>>> import struct
>>> dir()
['__builtins__', '__doc__', '__name__', 'struct']
>>> dir(struct)
['__doc__', '__name__', 'calcsize', 'error', 'pack', 'unpack']

Note: Siccome dir() viene fornito principalmente per averne il vantaggio nell'uso del prompt interattivo, esso cerca di fornire un utile insieme di nomi, piuttosto che di fornire un voluminoso e rigorosamente definito insieme di nomi, e il suo livello di dettaglio potrà cambiare con successive versioni dell'interprete.

divmod( a, b): Prende come argomenti due numeri (non complessi) e restituisce una coppia di numeri consistenti nel loro quoziente e resto, quando si opera una divisione long. Con tipi di operandi misti, si applicano le regole per l'aritmetica binaria. Per interi long o semplici, il risultato è lo stesso di (a / b, a % b). Per i numeri in virgola mobile il risultato è (q, a % b), dove q è solitamente math.floor(a / b) ma potrebbe essere inferiore di una unità. In ogni caso q * b + a % b è molto vicino ad a, se a % b non è zero e possiede lo stesso segno di b, e 0 <= abs(a % b) < abs(b).
Modificato nella versione 2.3: l'uso di divmod() con numeri complessi è deprecato.

enumerate( iterable): Restituisce un oggetto enumerate. iterable deve essere una sequenza, un iteratore, o qualche altro oggetto che supporti l'iterazione. Il metodo next() dell'oggetto restituito da enumerate(), restituisce a sua volta una tupla contenente un contatore (da 0) e il corrispondente valore ottenuto iterando sull'iterable indicato. enumerate() è utile per ottenere una serie indicizzata: (0, seq[0]), (1, seq[1]), (2, seq[2]), .... Nuovo nella versione 2.3.

eval( expression[, globals[, locals]])

Gli argomenti sono una stringa e due dizionari facoltativi. L'espressione expression viene analizzata e valutata come un'espressione Python (parlando tecnicamente, una lista di condizioni) usando i dizionari globals e locals come spazi dei nomi globali e locali. Se il dizionario globals è presente e manca '__builtins__', quello corrente viene utilizzato prima che expression venga analizzata. Il significato è che normalmente expression ha pieno accesso al modulo standard __builtin__ e l'ambiente soggetto a restrizioni viene propagato. Se il dizionario locals viene omesso, diviene predefinito il dizionario globals. Se entrambi i dizionari vengono omessi, l'espressione viene eseguita nell'ambiente dove eval viene chiamata. Il valore restituito è il risultato dell'espressione valutata. Errori di sintassi vengono riportati come eccezioni. Esempio:

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

Questa funzione può anche impiegarsi per eseguire oggetti di codice arbitrario (come quello creato con compile()). In questo caso, viene passato il codice di un oggetto invece di una stringa. Il codice oggetto deve essere stato compilato passando 'eval' come tipologia (kind) di argomento.

Suggerimento: l'esecuzione dinamica di istruzioni viene supportata dall'istruzione exec. L'esecuzione di istruzioni da un file viene supportata dalla funzione execfile(). Le funzioni globals() e locals() restituiscono rispettivamente i dizionari globali e locali, che potrebbero essere utili per l'uso di eval() o execfile().

execfile( filename[, globals[, locals]])

Questa funzione è simile all'istruzione exec, ma analizza un file invece che una stringa. È differente dall'istruzione import in cui non si usa il modulo administration -- legge il file incondizionatamente e non crea un nuovo modulo.^2.2

Gli argomenti sono il nome di un file e due dizionari facoltativi. Il file viene analizzato e valutato come una sequenza di istruzioni Python (in modo simile ad un modulo), usando i dizionari globals e locals come spazi dei nomi globali e locali. Se il dizionario locals viene omesso, quello predefinito è globals. Se entrambi i dizionari vengono omessi, l'espressione viene eseguita nell'ambiente dove viene chiamato execfile(). Il valore restituito è None.

Le azioni predefinite di locals vengono descritte per le funzioni locals() più avanti: non dovrebbero essere tentate modifiche al dizionario locals predefinito. Passategli un esplicito dizionario locals se avete bisogno di vedere gli effetti del codice sullo spazio dei nomi locale (locals) dopo il risultato della funzione execfile(). execfile() non può essere usato in modo attendibile per modificare le variabili locali di una funzione.

file( filename[, mode[, bufsize]])

Restituisce un nuovo file oggetto (descritto precedentemente nella sezione 2.3.9, ``File oggetto''). I primi due argomenti sono gli stessi, come per stdio fopen(): filename è il nome del file che deve essere aperto, mode indica il modo e la modalità in cui deve aprirsi il file: 'r' per la lettura, 'w' per la scrittura (troncando un file esistente), e 'a' per aggiungere (in alcuni sistemi Unix significa che il testo viene inserito tutto alla fine del file, senza riguardo per la posizione di ricerca).

I modi 'r+', 'w+' ed 'a+' aprono il file per aggiornarlo (notate che 'w+' tronca il file). Aggiungete 'b' al modo per aprire il file in modalità binaria, su sistemi che differenziano tra file binari e file di testo (altrimenti ignorato). Se il file non può essere aperto, viene sollevata un'eccezione IOError.

Un'aggiunta al valore predefinito per fopen(), riguardo alla modalità di apertura mode, potrebbe essere 'U' o 'rU'. Se Python è stato compilato con il supporto universale ai fine riga (predefinito) il file verrà aperto come un file di testo, ma le righe termineranno con un '\n', il carattere di fine riga convenzionale di Unix, '\r' il carattere Macintosh convenzionale o '\r\n', il carattere Windows convenzionale. Tutte queste rappresentazioni vengono viste come '\n' dal programma Python. Se Python è stato compilato senza il supporto universale ai fine riga il mode supportato 'U' è lo stesso del modo testo normale. Notate anche che i file oggetto così aperti hanno anche un attributo chiamato newlines che ha valore None (se nessun fine riga è stato ancora visto), '\n', '\r', '\r\n', o una tupla contenente tutti i caratteri di fine riga visti.

Se mode viene omesso, il valore predefinito è 'r'. Aprendo un file binario, si dovrebbe collegare 'b' al valore della modalità scelta per una migliore la portabilità. (Questo è utile su sistemi che non trattano i file binari e quelli di testo differentemente, dove serve come documentazione). L'argomento facoltativo bufsize specifica la dimensione desiderata del file di buffer: 0 significa non bufferizzato, 1 significa riga bufferizzata, ogni altro valore positivo indica l'uso di un buffer (approssimativamente) di quella misura. Un bufsize negativo significa l'uso predefinito di quello di sistema, che è di solito una riga bufferizzata per i dispositivi tty e completa bufferizzazione per gli altri file. Se omesso, viene adottato il sistema predefinito.^2.3

Il costruttore file() è nuovo in Python 2.2. L'ortografia precedente, open(), viene mantenuta per la compatibilità ed è un alias per file().

filter( function, list): Costruisce una lista dagli elementi di list per i quali la funzione function restituisce vero. list può essere una sequenza, un contenitore che supporta iterazioni, o un iteratore. Se list è una stringa o una tupla, il risultato fornisce lo stesso tipo; altrimenti viene restituita sempre una lista. Se function ha valore None, ne viene assunta l'identità attribuita alla funzione, quindi tutti gli elementi di list che risultino falsi (zero o vuoti) vengono rimossi.
Notate che filter(function, list) è equivalente a [elemento for elemento in list if function(elemento)] se la funzione non è None e se [elemento for elemento in list if elemento] se la funzione è None.

float( [x]): Converte una stringa o un numero in un numero in virgola mobile. Se l'argomento è una stringa, deve contenere un decimale possibilmente indicato o un numero in virgola mobile, possibilmente posizionato tra due spazi vuoti. Altrimenti, l'argomento potrà essere un numero semplice o un intero di tipo long o un numero in virgola mobile, e verrà restituito un numero in virgola mobile con lo stesso valore (entro la precisione in virgola mobile di Python). Se nessun argomento viene fornito, restituisce 0.0.
Note: Quando passati ad una stringa, i valori per NaN ed Infinito possono essere restituiti a seconda della libreria C in uso. Lo specifico insieme di stringhe accettate che causano questi valori dipende interamente dalla libreria C ed è noto che può essere variabile.

frozenset( [iterable]): Restituisce un oggetto frozenset i cui elementi vengono presi da iterable. I frozenset sono insiemi che non hanno metodi di aggiornamento, ma possono mescolarsi ed usarsi come membri di altri insiemi o come chiavi di un dizionario. Gli elementi di un frozenset devono essere essi stessi immutabili. Per rappresentare degli insiemi di insiemi, gli insiemi interni dovrebbero anche essere oggetti frozenset. Se iterable non è specificato, restituisce un nuovo insieme vuoto. frozenset([]). Nuovo nella versione 2.4.

getattr( object, name[, default]): Restituisce il valore dell'attributo con nome di un oggetto object. name deve essere una stringa. Se la stringa è il nome di uno degli attributi dell'oggetto, il risultato è il nome di quell'attributo. Per esempio, getattr(x, 'foobar') è equivalente a x.foobar. Se l'attributo nominato non esiste, viene restituito il valore predefinito, se fornito, altrimenti viene sollevata un'eccezione AttributeError.

globals( ): Restituisce un dizionario rappresentante la corrente tabella dei simboli globale. Questo è sempre il dizionario del modulo corrente (dentro una funzione o metodo, questo è il modulo dove il dizionario viene definito, non il modulo dal quale è stato chiamato).

hasattr( object, name): Gli argomenti sono un oggetto ed una stringa. Il risultato è True se la stringa è il nome, name, di uno degli attributi dell'oggetto, False se non lo è. Questo viene implementato dalla chiamata getattr(object, name) e vedendo se solleva un'eccezione oppure no.

hash( object): Restituisce il valore dell'hash dell'oggetto object (se ne ha uno). I valori degli hash sono degli interi. Vengono usati per confrontare velocemente le chiavi di un dizionario durante la consultazione. I valori numerici che confrontati risultino uguali hanno lo stesso valore di hash (anche se sono di tipi differenti, come nel caso di 1 e 1.0).

help( [object]): Invoca l'aiuto di sistema built-in. (Questa funzione viene intesa per un uso interattivo). Se non vengono forniti argomenti, l'aiuto interattivo di sistema parte sulla console dell'interprete. Se l'argomento è una stringa, questa viene ricercata come il nome di un modulo, funzione, classe, metodo, parola chiave o indice degli argomenti della documentazione, dopodiché viene stampata una pagina di aiuto sulla console. Se l'argomento è un qualsiasi altro tipo di oggetto, viene generata una pagina di aiuto per l'oggetto. Nuovo nella versione 2.2.

hex( x): Converte un numero intero (di qualsiasi dimensione) in una stringa esadecimale. Il risultato è una espressione Python valida. Notate: questo produce sempre una costante senza segno. Per esempio, su una macchina a 32 bit, hex(-1) produce '0xffffffff'. Quando valutato su una macchina con la stessa dimensione della parola, questa costante viene valutata come -1; ad una differente dimensione della parola aumenta il numero positivo o solleva un'eccezione OverflowError.

id( object): Restituisce l'`identità' di un oggetto. Questo è un intero (o un intero long) che viene garantito per essere unico e costante per questo oggetto durante il suo ciclo di vita. Due oggetti che hanno cicli di vita disgiunti possono avere lo stesso valore di id(). (Nota implementativa: questo è l'indirizzo dell'oggetto).

input( [prompt])

Equivalente a eval(raw_input(prompt)). Questa funzione non protegge dagli errori degli utenti! Si aspetta una valida espressione Python come input; se l'input non è sintatticamente valido, verrà sollevata un'eccezione SyntaxError. Altre eccezioni possono essere sollevate se si verifica un errore durante la valutazione. (In altre parole, qualche volta è esattamente quello di cui avete bisogno quando scrivete un veloce script per uso esperto).

Se il modulo readline è stato caricato, allora input() verrà usato per fornire funzionalità per la scrittura su riga di comando, e per la memoria storica dei comandi impartiti.

Considerate l'uso delle funzioni raw_input() per il generale input degli utenti.

int( [x[, radix]]): Converte una stringa o un numero in un intero semplice. Se l'argomento è una stringa, deve contenere un numero decimale rappresentabile come un intero Python, possibilmente posizionato tra due spazi vuoti. Il parametro radix fornisce la base per la conversione e può essere un qualsiasi numero intero nell'intervallo [2,36], o zero. Se radix è zero, la base adeguata viene calcolata in base al contenuto della stringa; l'interpretazione è la stessa utilizzata per gli interi costanti. Se la base radix è specificata e x non è una stringa, viene sollevata un'eccezione di tipo TypeError. Altrimenti, l'argomento può essere un numero intero semplice, un intero di tipo long o un numero in virgola mobile. La conversione di un numero in virgola mobile in un intero tronca il numero (verso lo zero). Se l'argomento è esterno all'intervallo degli interi, al suo posto viene restituito un intero long. Se non ci sono argomenti dati, viene restituito 0.

isinstance( object, classinfo): Restituisce vero se l'argomento object è un'istanza dell'argomento classinfo, o di una (diretta o indiretta) sotto classe di questo. Restituisce ancora vero se classinfo è un tipo di oggetto e object è un oggetto di quel tipo. Se object non è un'istanza di classe o un oggetto del tipo dato, la funzione restituisce sempre falso. Se classinfo non è un oggetto classe o un oggetto tipo, potrebbe essere una tupla della classe o di quel tipo di oggetto, o potrebbe contenere ricorsivamente altre tuple simili (altri tipi di sequenze non vengono accettati). Se classinfo non è una classe, un tipo o una tupla di classi, tipi o tuple, viene sollevata un'eccezione TypeError. Modificato nella versione 2.2: Aggiunto il supporto per tupla di tipi.

issubclass( class, classinfo): Restituisce vero se la classe class è una sotto classe (diretta o indiretta) di classinfo. Una classe viene considerata una sotto classe di sé stessa. classinfo può essere una tupla di oggetti della classe, nel quale caso ogni voce in classinfo verrà controllata. Negli altri casi, verrà sollevata un'eccezione TypeError. Modificato nella versione 2.3: Aggiunto il supporto per una tupla di informazione sui tipi.

iter( o[, sentinel]): Restituisce un oggetto iteratore. Il primo argomento viene interpretato in modo molto differente, a seconda della presenza del secondo argomento. Senza il secondo argomento, o deve essere una collezione di oggetti che supporti il protocolllo iterativo (vedete il metodo __iter__()), o deve supportare il protocollo sequenza (il metodo __getitem__() con numeri interi come argomenti, che iniziano da 0). Se non supporta nessuno di questi protocolli verrà sollevata un'eccezione TypeError. Se il secondo argomento, sentinel, viene dato, allora o deve essere un oggetto chiamabile. L'iteratore creato in questo caso chiamerà o senza argomenti per ogni chiamata al suo metodo next(); se il valore restituito è uguale a sentinel, verrà sollevata l'eccezione StopIteration, altrimenti verrà restituito il valore. Nuovo nella versione 2.2.

len( s): Restituisce la lunghezza (il numero di elementi) di un oggetto. L'argomento deve essere una sequenza (stringa, tupla o lista) o un oggetto mappabile (dizionario).

list( [sequence]): Restituisce una lista i cui elementi sono gli stessi e nello stesso ordine degli elementi della sequenza sequence. sequence può essere una sequenza, un contenitore che supporti le iterazioni, o un oggetto iteratore. Se sequence è già una lista, ne viene fatta una copia e restituita, in modo simile a sequence[:]. Per esempio, list('abc') restituisce ['a', 'b', 'c'] e list( (1, 2, 3) ) restituisce [1, 2, 3]. Se non viene dato alcun argomento, restituisce una nuova lista vuota, [].

locals( ): Aggiorna e restituisce un dizionario rappresentante la locale tabella dei simboli corrente. Il contenuto di questo dizionario non dovrebbe essere modificato; i cambiamenti non possono interessare i valori delle variabili locali usate dall'interprete.

long( [x[, radix]]): Converte una stringa o un numero in un intero long. Se l'argomento è una stringa, deve contenere un numero reale di dimensione arbitraria, possibilmente posizionato tra due spazi vuoti. L'argomento radix viene interpretato allo stesso modo di int() e può essere fornito soltanto quando x è una stringa. Altrimenti, l'argomento può essere un numero semplice, un intero long o un numero in virgola mobile, e viene restituito un intero long di uguale valore. La conversione di numeri in virgola mobile in interi tronca (verso zero) il numero. Se non vengono forniti argomenti restituisce 0L.

map( function, list, ...): Applica la funzione function ad ogni elemento della lista list e restituisce una lista dei risultati. Se vengono passati ulteriori argomenti di list, function deve prendere quegli argomenti ed applicarli agli elementi di tutte le liste in parallelo; se una lista è più corta di un'altra, viene estesa con elementi None. Se la function è None, viene assunta la sua funzione identità; se ci sono molteplici liste di argomenti, map() restituisce una lista consistente in tuple, contenenti i corrispondenti elementi di tutte le liste (una sorta di operazione di trasposizione). Gli argomenti di list possono essere ogni tipo di sequenza; il risultato è sempre una lista.

max( s[, args...]): Con il singolo argomento s, restituisce il più grande elemento di una sequenza non vuota (come una stringa, una tupla o una lista). Con più di un argomento, restituisce il più grande degli argomenti.

min( s[, args...]): Con il singolo argomento s, restituisce il più piccolo elemento di una sequenza non vuota (come una stringa, una tupla o una lista). Con più di un argomento, restituisce il più piccolo degli argomenti.

object( ): Restituisce un nuovo oggetto privo di caratteristiche. object() è la base per tutti i nuovi stili di classi. Ha i metodi che sono comuni a tutte le istanze di nuovi stili di classi. Nuovo nella versione 2.2.
Modificato nella versione 2.3: Questa funzione non accetta nessun argomento. Precedentemente accettava argomenti ma li ignorava.

oct( x): Converte un numero intero (di qualsiasi dimensione) in una stringa ottale. Il risultato è un'espressione Python valida. Notate: questo restituisce sempre una costante senza segno. Per esempio, su una macchina a 32 bit, oct(-1) restituisce '037777777777'. Quando viene valutata su una macchina con la stessa dimensione della parola, questa costante viene valutata -1; ad una differente dimensione della parola, può diventare un grande numero positivo o sollevare un'eccezione OverflowError.

open( filename[, mode[, bufsize]]): Un alias per la funzione file() descritta precedentemente.

ord( c): Restituisce il valore ASCII di una stringa di un carattere, o di un carattere Unicode. E.g., ord('a') restituisce l'intero 97, ord(u'\u2020') restituisce 8224. Questo è il contrario di chr() per le stringhe e di unichr() per i caratteri Unicode.

pow( x, y[, z]): Restituisce x elevato alla potenza y; se z è presente, restituisce x elevato a y, modulo z (una computazione più efficiente di pow(x, y) % z). Gli argomenti devono avere tipi numerici. Con tipi di operandi misti, vengono applicate le regole coercitive per gli operatori binari aritmetici. Per gli operandi int e long int, il risultato ha lo stesso tipo dell'operando (dopo la coercizione) a meno che il secondo argomento risulti negativo; in quel caso, tutti gli argomenti vengono convertiti in float e viene restituito un risultato float. Per esempio, 10**2 restituisce 100, ma 10**-2 restituisce 0.01. (Quest'ultima caratteristica è stata aggiunta in Python 2.2. In Python 2.1 e precedenti, se entrambi gli argomenti erano di tipo intero ed il secondo argomento era negativo, veniva sollevata un'eccezione). Se il secondo argomento è negativo, il terzo argomento deve essere omesso. Se z è presente, x e y devono essere di tipo intero, e y non deve essere negativo. (Questa restrizione è stata aggiunta in Python 2.2. In Python 2.1 e precedenti, i tre argomenti floating di pow() restituivano, dipendentemente dalla piattaforma, un numero in virgola mobile, variabile a seconda dell'arrotondamento in virgola mobile).

property( [fget[, fset[, fdel[, doc]]]])

Restituisce la proprietà dell'attributo per le classi di nuovo stile (classi che derivano da object).

fget è una funzione per ottenere il valore di un attributo, allo stesso modo fset è una funzione per assegnare un valore e fdel è una funzione per cancellare un attributo. Un uso tipico è quello di definite l'attributo gestito x:

class C(object):
    def getx(self): return self.__x
    def setx(self, value): self.__x = value
    def delx(self): del self.__x
    x = property(getx, setx, delx, "Io sono la proprietà di 'x'.")

Nuovo nella versione 2.2.

range( [start,] stop[, step])

Questa è una versatile funzione per creare liste contenenti progressioni aritmetiche. Viene soprattutto utilizzata nei cicli for. Gli argomenti devono essere degli interi semplici. Se l'argomento relativo al passo step viene omesso, il suo valore predefinito viene assunto uguale a 1. Se l'argomento start viene omesso, il suo valore predefinito viene assunto uguale a 0. La forma completa restituisce una lista di interi semplici

[start, start + step,
  start + 2 * step, ...]

. Se step è positivo, l'ultimo elemento è il più grande start + i * step minore di stop; se step è negativo, l'ultimo elemento è il più grande start + i * step più grande di stop. step non deve essere zero (altrimenti viene sollevata un'eccezione ValueError). Esempio:

>>> range(10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> range(1, 11)
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> range(0, 30, 5)
[0, 5, 10, 15, 20, 25]
>>> range(0, 10, 3)
[0, 3, 6, 9]
>>> range(0, -10, -1)
[0, -1, -2, -3, -4, -5, -6, -7, -8, -9]
>>> range(0)
[]
>>> range(1, 0)
[]

raw_input( [prompt])

Se l'argomento prompt è presente, viene scritto sullo standard output, senza il carattere di fine riga. La funzione quindi legge una riga dall'input, la converte in una stringa (togliendo il carattere di nuova riga ) e la restituisce. Quando viene letta la EOF, viene sollevata un'eccezione EOFError. Esempio:

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

Se il modulo readline viene caricato, raw_input() lo userà per elaborare le righe inserite e le funzionalità dello storico dei comandi.

reduce( function, sequence[, initializer]): Applica la funzione function, che richiede contemporaneamente due argomenti, agli elementi della sequenza sequence, da sinistra verso destra, così da ridurre la sequenza ad un singolo valore. Per esempio, reduce(lambda x, y: x+y, [1, 2, 3, 4, 5]) calcola ((((1+2)+3)+4)+5). L'argomento di sinistra, x, è il valore accumulato e l'argomento di destra, y, il valore aggiornato dalla sequenza. Se l'inizializzatore facoltativo initializer è presente, viene posizionato prima degli elementi nella sequenza di calcolo, e serve da valore predefinito quando la sequenza è vuota. Se initializer non viene dato e sequence contiene solo un elemento, viene restituito il primo elemento.

reload( module)

Ricarica il modulo module precedentemente importato. L'argomento deve essere un modulo oggetto, che deve essere stato importato con successo precedentemente. Questo è utile se avete modificato il file sorgente del modulo usando un editor esterno e volete provare la nuova versione senza lasciare l'interprete Python. Il valore restituito è il modulo oggetto (lo stesso dell'argomento module).

Quando reload(module) viene eseguito:

Il codice del modulo Python viene ricompilato e quindi eseguito nuovamente il codice a livello di modulo, definendo un insieme di oggetti che legano i nomi ai dizionari relativi ai moduli. La funzione init dei moduli di estensione non viene chiamata in un secondo tempo.
Come con gli altri oggetti, in Python i vecchi oggetti vengono bonificati dopo che i conteggi dei loro riferimenti raggiungono il valore zero.
I nomi, nello spazio dei nomi del modulo vengono aggiornati per puntare agli oggetti nuovi o modificati.
Altri riferimenti ai vecchi oggetti (così come a nomi esterni al modulo) non devono essere ricollegati ai riferimenti dei nuovi oggetti e devono essere aggiornati in ogni spazio dei nomi, dove avvenga e se questo comportamento è desiderato.

Esistono alcuni altri avvertimenti:

Se il modulo è sintatticamente corretto ma la sua inizializzazione fallisce, la prima istruzione import che lo riguarda potrebbe non collegare il suo nome localmente, ma immagazzinarlo in un modulo oggetto (parzialmente inizializzato), sys.modules. Per ricaricare il modulo dovete eseguire nuovamente un import (questo collegherà il nome al modulo oggetto parzialmente inizializzato) prima di poterlo ricaricare con reload()).

Quando un modulo viene ricaricato, il suo dizionario (contenente le variabili globali del modulo) viene mantenuto. La ridefinizione dei nomi sovrascriverà le vecchie definizioni, quindi questo non è in generale un problema. Se la nuova versione del modulo non definisce un nome che invece era definito nella vecchia versione, ressta la vecchia definizione. Questa caratteristica può essere usata a vantaggio del modulo se mantiene una tabella globale o una cache degli oggetti -- con una istruzione try esso può valutare la presenza della tabella, e saltare la sua inizializzazione se lo si desidera.

try:
    cache
except NameError:
    cache = {}

Non è generalmente molto utile ricaricare il built-in o i moduli dinamicamente, ad eccezione che per sys, __main__ e __builtin__. In molti casi, comunque, i moduli di estensione non sono destinati ad essere inizializzati più di una volta, e potrebbero fallire in modo arbitrario quando ricaricati.

Se un modulo importa oggetti da un altro modulo usando from ... import ..., la chiamata reload() per l'altro modulo non ridefinisce gli oggetti importati da esso -- un modo per aggirare questo comportamento consiste nel rieseguire l'istruzione from, un'altro consiste nell' utilizzare import e dei nomi qualificati (module.name) al suo posto.

Se il modulo istanzia le istanze di una classe, il ricaricamento del modulo che definisce la classe non influenza il metodo di definizione delle istanze -- queste continuano ad usare la vecchia definizione di classe. È vero anche per le classi derivate.

repr( object): Restituisce una stringa contenente la rappresentazione stampabile di un oggetto. Questo è lo stesso valore reso dalle conversioni (apici inversi). È utile qualche volta potere accedere a questa operazione come ad una funzione ordinaria. Per molti tipi di dati, questa funzione tenta di restituire una stringa con lo stesso valore di un oggetto, una volta passata ad eval().

reversed( seq): Restituisce un iteratore inverso. seq deve essere un oggetto che supporti il protocollo sequenza (il metodo __len__() e il metodo __getitem__() con argomenti interi partendo da 0). Nuovo nella versione 2.4.

round( x[, n]): Restituisce un valore in virgola mobile x arrotondato a n cifre dopo il punto decimale. Se n è omesso, per definizione viene impostato a zero. Il risultato è un numero in virgola mobile. I valori vengono arrotondati al più vicino multiplo di 10 della potenza n, a cui viene attribuito segno negativo: se due multipli sono ugualmente vicini, l'arrotondamento viene fatto partendo da 0 (così, per esempio round(0.5) è 1.0 e round(-0.5) è -1.0).

set( [iterable]): Restituisce un insieme di elementi presi da iterable. Gli elementi devono essere immutabili. Per rappresentare insiemi di insiemi, l'insieme interno dovrebbe essere un insieme di oggetti frozenset. Se iterable non viene specificato, restituisce un nuovo insieme vuoto, set([]). Nuovo nella versione 2.4.

setattr( object, name, value): Questo è la controparte di getattr(). Gli argomenti sono un oggetto, una stringa ed un valore arbitrario. La stringa può chiamare un attributo esistente o un nuovo attributo. La funzione assegna il valore all'attributo, se l'oggetto lo permette. Per esempio, setattr(x, 'foobar', 123) è equivalente a x.foobar = 123.

slice( [start,] stop[, step]): Restituisce un oggetto fetta rappresentante l'insieme degli indici specificati da range(start, stop, step). Gli argomenti start e step per definizione sono None. Gli oggetti fetta hanno attributi in sola lettura start, stop e step, che semplicemente restituiscono i valori degli argomenti (o i loro predefiniti). Non hanno altre funzionalità esplicite; tuttavia vengono usati da Numerical Python ed altre estensioni di terze parti. Gli oggetti fetta vengono generati anche quando viene usata una sintassi indicizzata. Per esempio: "a[start:stop:step]" o "a[start:stop, i]".

sorted( iterable[, cmp[, key[, reverse]]]): Restituisce una nuova lista ordinata dagli elementi in iterable. Gli argomenti facoltativi cmp, key e reverse hanno lo stesso significato di quelli del metodo list.sort(). Nuovo nella versione 2.4.

staticmethod( function)

Restituisce un metodo statico per la funzione function.

Un metodo statico non riceve un primo argomento implicito. Per dichiarare un metodo statico usate la forma:

class C:
    def f(arg1, arg2, ...): ...
    f = staticmethod(f)

Può essere chiamato sia nella classe (come in C.f() che in una istanza (come in C().f()). L'istanza viene ignorata eccetto che per la sua classe.

I metodi statici in Python sono simili a quelli trovati in Java o in C++. Per concetti più avanzati, vedete classmethod() in questa sezione. Nuovo nella versione 2.2.

str( [object]): Restituisce una stringa contenente una rappresentazione stampabile di un oggetto. Per le stringhe, questa funzione restituisce la stringa stessa. La differenza con repr(object) è che str(object) non sempre tenta di restituire una stringa che sia accettabile da eval(); il suo obiettivo è restituire una stringa stampabile. Se non vengono forniti argomenti, restituisce la stringa vuota, ''.

sum( sequence[, start]): Somma gli elementi della sequenza sequence cominciando da start, da sinistra a destra, e restituisce il totale. Il valore predefinito di start è 0. Gli elementi della sequenza sequence sono normalmente numeri e non è consentito che siano stringhe. Il veloce e corretto sistema per concatenare una sequenza di stringhe è chiamare ''.join(sequence). Notate che sum(range(n), m) è equivalente a reduce(operator.add, range(n), m). Nuovo nella versione 2.3.

super( type[, object-or-type])

Restituisce una superclasse di type. Se il secondo argomento viene omesso, il super oggetto restituito è slegato. Se il secondo argomento è un oggetto, isinstance(object, type) deve essere vero. Se il secondo argomento è un tipo, issubclass(type2, type) deve essere vero. super() lavora solo con le classi di nuovo stile.

Un uso tipico per chiamare un metodo cooperativo di superclasse è:

class C(B):
    def meth(self, arg):
        super(C, self).meth(arg)

Nuovo nella versione 2.2.

tuple( [sequence]): Restituisce una tupla i cui elementi sono gli stessi e nello stesso ordine degli elementi della sequenza sequence. sequence può essere una sequenza, un contenitore che supporta l'iterazione, o un oggetto iteratore. Se sequence è già una tupla, viene restituita immutata. Per esempio, tuple('abc') restituisce ('a', 'b', 'c') e tuple([1, 2, 3]) restituisce (1, 2, 3). Se non vengono forniti argomenti, viene restituita una nuova tupla vuota, ().

type( object)

Restituisce il tipo dell'oggetto object. Il valore restituito è un tipo di oggetto. Il modulo standard types definisce nomi per tutti i tipi built-in che non abbiano già dei nomi built-in. Per esempio:

>>> import types
>>> x = 'abc'
>>> if type(x) is str: print "Una stringa"
...
Una stringa
>>> def f(): pass
...
>>> if type(f) is types.FunctionType: print "Una funzione"
...
Una funzione

La funzione built-in isinstance() è raccomandata per testare il tipo di un oggetto.

unichr( i): Restituisce la stringa Unicode di un carattere il cui codice Unicode è l'intero i. Per esempio, unichr(97) restituisce la stringa u'a'. Questo è l'inverso di ord() per le stringhe Unicode. L'argomento deve appartenere all'intervallo [0..65535]. Diversamente viene sollevata un'eccezione ValueError. Nuovo nella versione 2.0.

unicode( [object[, encoding[, errors]]])

Restituisce una stringa in versione Unicode dell'oggetto object usando uno dei seguenti modi:

Se sono forniti encoding e/o errors, unicode() decodifica l'oggetto, che può essere sia una stringa a 8 bit che un buffer di caratteri, usando il codec per la codifica encoding. Il parametro encoding è una stringa che fornisce il nome di una codifica; se la codifica non è conosciuta, viene sollevata un'eccezione LookupError. La gestione degli errori viene fatta in accordo con errors; questo specifica il trattamento di caratteri che hanno una codifica di input non valida. Se errors è 'strict' (predefinito) viene sollevata un'eccezione ValueError sugli errori, mentre un valore 'ignore' fa in modo che gli errori vengano ignorati silenziosamente, e un valore 'replace' fa in modo che il carattere di sostituzione ufficiale Unicode, U+FFFD, venga usato per sostituire caratteri di input che non possono essere decodificati. Vedete anche il modulo codecs.

Se nessun parametro facoltativo viene fornito, unicode() imiterà il comportamento di str(), salvo restituire stringhe Unicode anziché stringhe a 8-bit. Più precisamente, se l'oggetto object è una stringa Unicode o una sua sotto classe, restituirà quella stringa Unicode senza applicare nessuna decodifica.

Per gli oggetti che forniscono un metodo __unicode__(), chiamerà questo metodo senza argomenti per creare una stringa Unicode. Per tutti gli altri oggetti, la versione della stringa a 8 bit o una rappresentazione di questa viene richiesta e quindi convertita in una stringa Unicode usando il codec per la codifica predefinita 'strict'.

Nuovo nella versione 2.0. Modificato nella versione 2.2: Aggiunto il supporto per __unicode__().

vars( [object]): Senza argomenti, restituisce un dizionario corrispondente alla tavola dei simboli locale. Con un modulo, classe o un oggetto istanza di classe come argomento (o qualsiasi altra cosa che ha come attributo __dict__), restituisce un dizionario corrispondente alla tavola dei simboli degli oggetti. Il dizionario restituito non dovrebbe essere modificato: gli effetti sulla corrispondente tavola dei simboli sono indefiniti.^2.4

xrange( [start,] stop[, step]): Questa funzione è molto simile a range(), ma restituisce un ``oggetto xrange'' invece di una lista. Questo è un tipo oscuro di sequenza che produce gli stessi valori della lista corrispondente, senza memorizzarli realmente tutti insieme. Il vantaggio di xrange() su range() è minimo (poiché xrange() deve tuttavia creare dei valori quando vengono richiesti) eccetto quando un intervallo molto ampio di valori viene usato su una macchina con poca memoria o quando tutti gli elementi dell'intervallo non vengono mai usati (come quando un loop è di solito terminato con break).

zip( [seq1, ...]): Questa funzione restituisce una lista di tuple, dove la tupla i-esima contiene l'elemento i-esimo da ognuno degli argomenti in sequenza. La lista restituita viene troncata in lunghezza, al valore del più corto argomento della sequenza. Quando esistono sequenze multiple di argomenti che hanno tutte la stessa lunghezza, zip() è simile a map() con un argomento iniziale None. Con una sequenza di un singolo argomento, viene restituita una lista di 1-tupla. Senza argomenti restituisce una lista vuota. Nuovo nella versione 2.0.
Modificato nella versione 2.4: Precedentemente, zip() richiedeva almeno un argomento e zip() sollevava un'eccezione TypeError invece di restituire una lista vuota..

Footnotes

... modulo.^2.2: Viene usato piuttosto raramente, da non garantire che faccia parte di una istruzione.
... predefinito.^2.3: Specificare la dimensione del buffer attualmente non ha effetto sui sistemi che non hanno setvbuf(). L'interfaccia per specificare la dimensione del buffer non è stata fatta usando il metodo chiamato setvbuf(), perché questo potrebbe causare un dump core dopo che ogni chiamata di I/O è stata effettuata, e non esiste un modo certo per determinare se questo sia il caso.
... indefiniti.^2.4: Nella corrente implementazione, le variabili locali collegate non possono normalmente essere influenzate in questa maniera, ma le variabili possono essere richiamate da altri ambiti (come i moduli). Questo potrebbe cambiare.

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