Python Giovanni Aglialoro slide tratte anche dalle presentazioni di Marco Barisione, Antonio Cuni, Marco Tozzi. Guido van Rossum I Monty Python

Python: introduzione ► È un linguaggio di programmazione:  interpretato  di altissimo livello  semplice da usare  potente e produttivo  permette programm. procedurale e a oggetti  ottimo anche come primo linguaggio (molto simile allo pseudocodice) ► Inoltre  è open source (  è multipiattaforma  è facilmente integrabile con C/C++ e Java

Python: introduzione (2) È veramente usato da qualcuno? È veramente usato da qualcuno? ► RedHat Linux e altre distribuzioni tool di configurazione grafici, applicazioni varie tool di configurazione grafici, applicazioni varie ► per costruire siti web: CMS, framework Django, Zope ► NASA ► ► Industrial Light and Magic (quelli che fanno gli effetti speciali per Star Wars...) ► … e molti altri

Python: introduzione (3) manuali, documentazione, esercizi (ove scaricare la versione …)

Python: introduzione (4) codice sorgente estrazione dell’istruzione traduzione (interpretazione) Esecuzione in ling. macchina codice sorgente traduzione del programma esecuzione del programma in ling. macchina interpretati Linguaggi (semplificando…) compilati (Basic, Perl, PHP, Python, Ruby, Java) (C/C++, Pascal, Delphi, Java)

Python: l’interprete interattivo Python dispone di un interprete interattivo molto comodo e potente:  Avvio: digitare python al prompt di una shell appare ora il prompt >>> pronto a ricevere comandi  Possiamo ora inserire qualsiasi costrutto del linguaggio e vedere immediatamente l’output: >>> >>> print "Hello world!" Hello world! L’ istruzione print stampa a video il risultato di un’espressione

Python come calcolatrice ► Possiamo usare l’interprete interattivo come calcolatrice: >>> (6+3) / 2 4 >>> 3/2 1 >>> 3/ ► Per usare una variabile basta assegnarle un valore; c’e‘ anche l’operatore ** che rappresenta l’elevamento a potenza: >>> x = 3+5 >>> x 8 >>> x**2 64

alcune caratteristiche ► per delimitare i cicli non usiamo né { } né begin/end: il blocco e‘ delimitato solo ed esclusivamente dall’ indentazione. ► assegnamento multiplo ► per delimitare le istruzioni non serve il ; ► sembrerebbe che Python non abbia tipi in realtà è strongly typed:  Ogni oggetto ha un tipo che non può cambiare mai  Le variabili (references) sono come delle “etichette” che si “appiccicano” agli oggetti

input e output ► Si può formattare l’output come il c: >>> x=18; y=15 >>> print "x=%d y=%d\n" % (x,y) x=18 y=15 ► Per leggere un numero si usa input() >>> x=input(‘Scrivi un numero: ’) darà errore se non si inserisce un numero. darà errore se non si inserisce un numero. ► Per leggere una stringa si usa raw_input() >>> x=raw_input(‘Scrivi il tuo nome: ’)

variabili ► I nomi di variabili sono composti da lettere, numeri e underscore, il primo carattere non può essere un numero (come in C)  Sono validi: “x”, “ciao”, “x13”, “x1_y”, “_”, “_ciao12” “x”, “ciao”, “x13”, “x1_y”, “_”, “_ciao12”  Non sono validi: “1x”, “x-y”, “$a”, “àñÿô” “1x”, “x-y”, “$a”, “àñÿô” ► Le variabili non devono essere dichiarate (tipizzazione dinamica) ► Una variabile non può essere utilizzata prima che le venga assegnato un valore ► Ogni variabile può riferirsi ad un oggetto di qualsiasi tipo

moduli ► Per importare moduli (funzioni matematiche e altro): import math import random... ► Per usarli: math.sqrt(2), math.log(5), random.choice(‘ATCG’), random.randint(1,50) random.choice(‘ATCG’), random.randint(1,50) ecc. ecc.

if La sintassi di “if” è: if condizione: if condizione: elif condizione_altern.:......else: ► Sia la parte “elif” sia la parte “else” sono facoltative ► Può esserci un numero qualsiasi di “elif” ► Non sono necessarie le parentesi intorno all’espresisone booleana ► Non sono possibili assegnamenti all’interno della condizione a=float(input("dividendo = ")) b=float(input("divisore = ")) quoz=a/b resto=a%b if resto!=0: print"risultato = ",int(quoz) print"resto = ",int(resto) else: print"risultato = ",int(quoz) print"resto = 0"

for Il costrutto for sembra molto limitato perché, a differenza di altri linguaggi di programmazione, permette di operare solamente sulle liste. In realtà questa piccola limitazione viene facilmente superata utilizzando la funzione range Il costrutto for sembra molto limitato perché, a differenza di altri linguaggi di programmazione, permette di operare solamente sulle liste. In realtà questa piccola limitazione viene facilmente superata utilizzando la funzione range Tutto quello che si fa con i cicli for potete farlo anche con while ma grazie ai cicli è più semplice scorrere tra tutti gli elementi di una lista o compiere un'azione un determinato numero di volte Tutto quello che si fa con i cicli for potete farlo anche con while ma grazie ai cicli for è più semplice scorrere tra tutti gli elementi di una lista o compiere un'azione un determinato numero di volte for i in range(-8, 20, 2): print i, i*i one_to_ten = range(1,11) for count in one_to_ten: print count

while (c’è anche assegnamento multiplo e funzione) es.: calcoliamo i numeri di Fibonacci # Serie di Fibonacci: # Ogni numero e‘ la somma # dei due numeri precedenti a, b = 0, 1 while b < 1000: print b print b a, b = b, a+b a, b = b, a+b # Fibonacci series up to n # def fib(n): a,b = 0,1 while a<n: print a, a,b = b,a+b fib(5000)

Python: manipolazione di stringhe ► Per indicare una stringa bisogna racchiuderla tra virgolette a differenza di molti altri linguaggi, possiamo usare sia le virgolette singole che quelle doppie >>> print "ciao" ciao >>> print ’Ho detto "ciao"’ Ho detto "ciao" >>> print "ecco l’apice" ecco l’apice ► Possiamo creare delle stringhe multilinea usando le triple virgolette (sia ’’’ che """): >>> frase = """questa e‘ una... stringa che occupa... tre righe""" >>> print frase questa e‘ una stringa che occupa tre righe

Python: stringhe (2) ► Possiamo concatenare due stringhe usando l’operatore +: >>> print ’ciao ’ + ’ciao’ ciao ciao ► Possiamo ripetere una stringa usando l’operatore *: >>> print ’-’ * >>> print ’ciao ’ * 3 ciao ciao ciao ► Per accedere ai singoli caratteri di una stringa, usiamo l’operatore []; l’indice puo‘ anche essere negativo: >>> ’ciao’[0] ’c’ >>> ’ciao’[1] ’i’ >>> ’ciao’[-1] ’o’

Python: stringhe(3) ► Le stringhe in Python, come in Java, sono immutabili: non e‘ possibile assegnare un nuovo valore ai singoli caratteri. ► Sottostringhe e slices: usiamo una variante dell’operatore [] chiamata slice notation: >>> ’una stringa’[0:3] ’una’ >>> ’una stringa’[1:-1] ’na string’

Python: slices mystring[i:j] restituisce tutti i caratteri compresi tra gli indici i (compreso) e j (escluso): ► Se il primo indice viene omesso, la slice parte dal primo carattere della stringa: >>> ’una stringa’[:3] ’una’ ► Se il secondo indice viene omesso, la slice arriva sino all’ulitmo carattere della stringa: >>> ’una stringa’[4:] ’stringa’

Python: metodi delle stringhe ► Le stringhe sono oggetti a tutti gli effetti. Alcuni esempi: >>> ’Ciao’.upper() ’CIAO’ >>> ’Ciao’.lower() ’ciao’ >>> ’ciao anto’.replace(’anto’, ’marco’) ’ciao marco’ ► Per ottenere la lunghezza c’è la funzione len(): >>> len(’ciao’) 4 Attenzione! Attenzione! len() è una funzione, si applica anche ad altre sequenze

Python: liste ► Una lista e‘ un oggetto composto simile per molti versi agli array presenti in altri linguaggi. ► Possiamo creare una lista racchiudendone gli elementi tra parentesi quadre e separandoli con una virgola (gli elementi possono anche avere tipi diversi): >>> mylist = [0, 100, ’ciao’, 15.4] >>> mylist [0, 100, ’ciao’, 15.4] ► Per accedere agli elementi di una lista usiamo la stessa notazione usata per le stringhe: >>> mylist[1] 100 >>> mylist[:2] [0, 100]

Python: liste (2) ► Le liste sono oggetti mutabili: possiamo modificarne la composizione >>> mylist[1] = ’salve’ >>> mylist [0, ’salve’, ’ciao’, 15.4] ► Come per le stringhe, anche le liste hanno dei metodi: >>> mylist [0, ’salve’, ’ciao’, 15.4] >>> mylist.append(1) >>> mylist [0, ’salve’, ’ciao’, 15.4, 1]

Python: liste (3) ► Per aggiungere un elemento in una posizione qualunque, usiamo il metodo insert(): >>> mylist.insert(1, 100) >>> mylist [0, 100, ’salve’, ’ciao’, 15.4, 1] ► Possiamo ordinare una lista usando il metodo sort(), ed invertirla con il metodo reverse(): >>> mylist = [1, 5, 7, 4, 10] >>> mylist.sort() >>> mylist [1, 4, 5, 7, 10] >>> mylist.reverse() >>> mylist [10, 7, 5, 4, 1]

Python: tuple Un altro tipo di sequenza questa volta immutabile ► In genere sono racchiuse tra parentesi tonde: >>> mytuple = (1, ’ciao’, 100) >>> mytuple (1, ’ciao’, 100) ► Possiamo usare una tupla quando in altri linguaggi siamo costretti a ricorrere a costrutti più complessi (es: struct del C) es: >>> mypoint = (4, 6) ► possiamo assegnare in un sol colpo ogni elemento ad una variabile diversa: >>> mypoint (4, 6) >>> x, y = mypoint >>> x 4 >>> y 6

Python: dizionari Python offre anche un supporto nativo per le hash table, chiamate dizionari. ► espresso come sequenza di coppie chiave:valore racchiuse tra parentesi graffe e separate da virgole: >>> voti = {’programmazione’: 18, ’LP’: 26, ’Implementazione’: 30} >>> voti {’programmazione’: 18, ’Implementazione’: 30, ’LP’: 26} ► per accedere ai singoli elementi: >>> voti[’LP’] 26 >>> voti[’Info Gen’] = 20 >>> voti {’programmazione’: 18, ’Implementazione’: 30, ’Info Gen’: 20, ’LP’: 26}

Python funzioni ► La keyword def introduce una definizione di funzione … ► Proviamo a scrivere una funzione che calcoli i numeri di fibonacci: >>>def fib(n):... “””Stampa la serie di Fibonacci fino a n”””... a, b = 0, 1... while b < n:... print b,... a, b = b, a+b... >>> fib(2000) ► Il primo statement può essere una docstring usata da tools che producono documentazione

Python funzioni (2) ► Gli argomenti sono passati tramite call by value (value è un object reference quindi call by object reference) ► L’esecuzione di una funzione introduce una nuova symbol table per le variabili locali (look up: local,global,built-in table) ► Function name è introdotto nella symbol table corrente  Il nome ha un tipo riconosciuto come user-defined function e un valore  Può essere assegnato ad un altro nome (es: rinomina) >>> fib >>> f = fib >>> f(100)

Python funzioni (3) ► Si possono specificare argomenti di default, quindi le chiamate possono anche non specificarli tutti: >>> def info(cognome, nome='Marco'):... print cognome, nome... >>> info('Tozzi') Tozzi Marco ► Possono essere invocate usando gli argomenti come keywords : >>> info(cognome='Cuni', nome='Antonio') Cuni Antonio ► Funzioni possono avere una lista arbitraria di argomenti: def foo(*arg, **keywords): def foo(*arg, **keywords): *arg è una tupla contenente i parametri posizionali **keywords è un dizionario dei keyword arguments a cui non corrisponde un parametro formale

Python Classi ► Definizione: class ClassName: … ► Successivamente ad una definizione di classe si crea un class object ► I class object supportano due operazioni:  Riferimento agli attributi: >>> class MyClass:... i = def f(self):... return 'hello world'... >>> MyClass.i >>> MyClass.f

Python Classi (2) ► Instanziazione (come una chiamata di funzione senza parametri che restituisce un’istanza): x = MyClass() ► Per inserire uno stato iniziale bisogna definire il metodo __init__: >>> class Complex:... def __init__(self, realpart, imagpart):... self.r = realpart... self.i = imagpart... >>> x = Complex(3.0, -4.5) >>> x.r, x.i (3.0, -4.5) ► Gli attributi sono creati la prima volta che gli viene assegnato un valore ► La chiamata di metodo passa implicitamente l’istanza dell’oggetto come primo argomento: x.f() è perfettamente equivalente a MyClass.f(x)

Python Class Inheritance ► Sintassi: class DerivedClassName(BaseClassName): … … ► Se BaseClass non è nello stesso modulo: class DerivedClassName(modname.BaseClassName): ► super(type,[object-or-type]) ritorna la superclasse di type: class C(B): def meth(self, arg): def meth(self, arg): super(C, self).meth(arg) super(C, self).meth(arg) ► Supporta ereditarietà multipla: class DerivedClassName(Base1, Base2, Base3): risoluzione attributi depht-first, left-to-right

Gli oggetti in Python

Oggetti e nomi ► In Python ogni oggetto risiede in un “universo” di oggetti e ha una identità distinta. ► Noi ci riferiamo agli oggetti dei nomi che si riferiscono ad essi. ► I nomi degli oggetti sono raggruppati in namespaces. ► Quando un oggetto non è più riferito da alcun nome, viene raccolto dal garbage collector. x z y w Universo degli oggetti Namespace dei nomi

Binding di un oggetto ► Il binding è quel meccanismo che associa un nome ad un oggetto. ► Esso è realizzato dall’operatore = ► Quando assegniamo un valore ad una variabile, in realtà stiamo legando un nome ad un oggetto. x y ‘ciao’ ‘salve’ x = ‘ciao’ y = x x = ‘salve’

Tutto è un oggetto ► Tutto quello a cui ci possiamo riferire con un nome è un oggetto:  Numeri, stringhe, liste, funzioni, classi, ecc. sono tutti oggetti. ► Tutti gli oggetti sono first class value: ad esempio possono essere passati come argomenti alle funzioni. >>> def somma(a, b): return a + b... >>> def applica(funzione, a, b):... return funzione(a,b)... >>> applica(somma, 3, 5) 8

Proprietà di un oggetto ► Da un punto di vista astratto, un oggetto possiede due proprietà:  Uno stato, che rappresenta il valore attuale assunto dall’oggetto.  Un tipo, che identifica le operazioni che possono essere compiute sull’oggetto. ► Alcuni tipi sono immutabili: questo significa che un oggetto di tale tipo non potrà mai cambiare stato. Es.: numeri, stringhe, tuple ► Altri tipi sono mutabili, ovvero lo stato dei rispettivi oggetti può cambiare. Es.: liste, dizionari

Layout degli oggetti ► La principale implementazione di Python è scritta in C ed è chiamata CPython. ► Ogni oggetto di Python è rappresentato da una struct del C. ► Tali struct sono composte da una serie di campi; ad esempio:  Reference count (per la gestione della memoria)  Puntatore al tipo dell’oggetto (che a sua volta sarà rappresentato da una struct.  Campi che memorizzano lo stato.

Esempio ► Segue la definizione della struttura PyIntObject, che rappresenta un numero intero. typedef struct { int ob_refcnt; int ob_refcnt; struct _typeobject *ob_type; struct _typeobject *ob_type; long ob_ival; long ob_ival; } PyIntObject; ► Possiamo notare la presenza di tre campi:  ob_refcnt memorizza il reference count;  ob_type punta al tipo (che sarà PyInt_Type);  ob_ival memorizza il valore vero e proprio del numero.

Layout dei tipi ► In Python anche i tipi sono oggetti ed anch’essi sono rappresentati da una struct. ► Oltre ai campi precedenti, le struct dei tipi contengono anche una serie di puntatori a funzione che identificano alcune operazioni “standard”. ► Ad esempio le struct dei tipi numerici contengono puntatori a funzioni che servono a fare addizioni, sottrazioni, ecc.

Attributi degli oggetti ► La maggior parte degli oggetti possiede anche un dizionario, che mappa la corrispondenza tra i nomi e i valori degli attributi. ► Esempio: class MiaClasse: def __init__(self): def __init__(self): self.x = ‘ciao’ self.x = ‘ciao’ def saluta(self): def saluta(self): print self.x print self.x mioOggetto = MiaClasse()

Esempio struct PyTypeObject { char* tp_name = “MiaClasse”; PyObject* tp_dict;... } PyDictObject: ‘__init__’ ‘saluta’ ‘__dict__’ PyMethodObject: self.x = ‘ciao’ PyMethodObject: print self.x struct PyInstanceObject { PyObject* in_type; PyObject* in_dict;... } PyDictObject: ‘__class__’ ‘x’ ‘__dict__’ PyStringObject: ‘ciao’ class MiaClasse: mioOggetto = MiaClasse()

Lookup degli attributi ► Il meccanismo di lookup degli attributi è il concetto centrale degli oggetti di Python. ► Esso è progettato in modo tale che alcune idee centrali del mondo OO diventano quasi automatiche:  Differenza tra campi (che si riferiscono ad un oggetto) e metodi (che si riferiscono al suo tipo o classe).  Ereditarietà singola e multipla  Polimorfismo  Metodi e attributi statici e di classe.  Proprietà

Regole di lookup (semplificate) ► Supponiamo di avere un oggetto obj e di voler accedere ad un attributo di nome “x”: 1.Controllo il nome “x” è presente nel dizionario di obj (obj.__dict__). 2.Se non c’è controllo se “x” è presente nel dizionario del tipo di obj (obj.__class__.__dict__) 3.Se non c’è controllo il dizionario di tutte le classi base (le basi di una classe C sono elencate nell’attributo C.__bases__).

Regole di lookup: esempio class Base: def __init__(self, nome): def __init__(self, nome): self.nome = nome self.nome = nome def saluta(self): def saluta(self): print ‘ciao’, self.nome print ‘ciao’, self.nome class Derivata(Base): def saluta(self): def saluta(self): print ‘Buongiorno’, self.nome print ‘Buongiorno’, self.nome obj = Derivata(‘anto’)

Regole di lookup: esempio Base __bases__ __init__ saluta Derivata __bases__ saluta obj __class__ name Lookup di obj.X  Controllo obj.__dict__  Controllo obj.__class__.__dict__  Controllo tutte le classi in obj.__class__.__bases__ Lookup di obj.nameLookup di obj.name Lookup di obj.salutaLookup di obj.saluta Lookup di obj.__init__Lookup di obj.__init__

Funzioni e metodi ► Abbiamo visto che le classi possono avere dei metodi. ► Internamente i metodi sono memorizzati come normalissime funzioni, ma con una differenza: il primo parametro (self) è passato automaticamente. ► Esempio class MiaClasse: def mioMetodo(self, a): def mioMetodo(self, a): print a print a obj = MiaClasse() obj.mioMetodo(‘ciao’) ► Al momento della chiamata passo un solo argomento a mioMetodo, ma l’interprete ne aggiunge automaticamente uno (il self).

Bound methods ► Questo è possibile perché quando la procedura di lookup si accorge di aver trovato una funzione, la trasforma in un bound method. ► I bound method sono delle funzioni che “si ricordano” a quale oggetto fanno riferimento: quando sono chiamati aggiungono automaticamente tale oggetto in cima alla lista degli argomenti. ► L’effetto finale è che quando chiamiamo un metodo su un oggetto il parametro self è passato in modo automatico. ► I bound method sono oggetti come gli altri: posso anche memorizzarli in una variabile e chiamarli più tardi. >>> obj = MiaClasse() >>> obj.mioMetodo # nota: non è chiamato! > > >>> xxx = obj.mioMetodo >>> xxx(‘ciao’) >>> xxx(‘ciao’)ciao

Ereditarietà singola ► Abbiamo visto che se la procedura di lookup non trova un attributo cerca ricorsivamente nelle classi base. ► Questo ci consente di implementare “gratis” l’ereditarietà: tutto quel che dobbiamo fare è memorizzare nell’attributo __bases__ la nostra classe base, e la procedura di lookup farà il resto.

Ereditarietà multipla ► In presenza di ereditarietà multipla le cose sono più complicate. ► Seguendo le regole appena descritte l’ordine di lookup di un attributo su uno StudenteLavoratore sarebbe:  StudenteLavoratore, Studente, Persona, Lavoratore, Persona Persona LavoratoreStudente StudenteLavoratore In genere non è questo che vogliamo, perché altrimenti i metodi di Persona sovrascritti da Lavoratore non verrebbero mai chiamati.In genere non è questo che vogliamo, perché altrimenti i metodi di Persona sovrascritti da Lavoratore non verrebbero mai chiamati. Inoltre la classe Persona sarebbe controllata due volte.Inoltre la classe Persona sarebbe controllata due volte. Al momento della creazione della classe viene calcolato un ordine di lookup seguendo una visita in ampiezza del grafo di ereditarietà.Al momento della creazione della classe viene calcolato un ordine di lookup seguendo una visita in ampiezza del grafo di ereditarietà. Tale ordine è memorizzato nell’attributo __mro__ (Method Resolution Order) della classe, che viene usato dalla procedura di lookup per controllare le classi base.Tale ordine è memorizzato nell’attributo __mro__ (Method Resolution Order) della classe, che viene usato dalla procedura di lookup per controllare le classi base. Il MRO di StudenteLavoratore è:Il MRO di StudenteLavoratore è: StudenteLavoratore, Studente, Lavoratore, PersonaStudenteLavoratore, Studente, Lavoratore, Persona

Polimorfismo ► Python supporta un tipo particolare di polimorfismo, detto polimorfismo basato su signature. ► Quando il programmatore utilizza un oggetto, non si deve preoccupare di quale sia il suo tipo, ma deve limitarsi a pensare a quali operazioni esso supporta. ► L’insieme delle operazioni supportate da un oggetto costituisce la sua signature. ► Se due oggetti hanno la stessa signature, posso usarli intercambiabilmente senza che il codice debba essere modificato, anche se non hanno alcuna relazione di tipo. ► Questo tipo di polimorfismo è simile a quello che il C++ offre con i template, con la differenza che in Python avviene a runtime. ► Il polimorfismo basato su signature offre numerosi vantaggi, tra cui il fatto che il codice scritto è intrisecamente generico, cioè può operare su qualsiasi oggetto, anche se di tipo diverso. ► Altri comuni linguaggi (es. C++, Java, C#) offrono invece un polimorfismo basato su interfaccia: questo significa che una funzione può operare solo su oggetti di un certo tipo o di un tipo derivato da esso.

Esempio di polimorfismo >>> class Classe1:... def saluta(self): print 'ciao'... >>> class Classe2:... def saluta(self): print 'salve'... >>> def miaFunzione(obj):... obj.saluta()... >>> c1 = Classe1() >>> c2 = Classe2() >>> >>> miaFunzione(c1) ciao >>> miaFunzione(c2) salve

Creazione delle classi ► In Python tutto, comprese le classi, è un oggetto. ► Il tipo di una generica classe è type. ► Quando definiamo una classe non facciamo altro che creare una istanza di type! ► Il costruttore di type vuole tre parametri: il nome della classe, l’elenco delle sue basi e il dizionario dei suoi attributi. ► Il dizionario degli attributi non è altro che un normalissimo dizionario in cui ad ogni nome di attributo corrisponde il suo valore (normalmente sarà una funzione). Nell’esempio a fianco:Nell’esempio a fianco: Il nome della classe è la stringa ‘A’Il nome della classe è la stringa ‘A’ L’elenco delle basi è la tupla (B,C)L’elenco delle basi è la tupla (B,C) Il dizionario degli attributi contiene le chiavi ‘metodo1’ e ‘metodo2’Il dizionario degli attributi contiene le chiavi ‘metodo1’ e ‘metodo2’ class A(B,C): def metodo1(self): def metodo1(self): print ‘ciao’ print ‘ciao’ def metodo2(self): def metodo2(self): print ‘salve’ print ‘salve’ A = type(‘A’, (B,C), {‘metodo1’: …,‘metodo2’:… })A = type(‘A’, (B,C), {‘metodo1’: …,‘metodo2’:… })

Creazione delle classi >>> def __init__(self, nome):... self.nome = nome... >>> def saluta(self):... print ‘ciao’, self.nome... >>> attributi = {'__init__': __init__, 'saluta': saluta} >>> MiaClasse = type('MiaClasse', (), attributi) >>> >>> obj = MiaClasse('anto') >>> obj.saluta() ciao anto

Implementazione del lookup ► L’interprete Python è basato su una macchina astratta. ► Per vedere come è implementato il meccanismo di lookup possiamo iniziare ad esaminare il bytecode eseguito da tale macchina. ► Il modulo standard dis serve a disassemblare il bytecode. >>> import dis >>> def prova(x):... return x.attributo... >>> dis.dis(prova) 0 SET_LINENO 1 0 SET_LINENO 1 3 SET_LINENO 2 3 SET_LINENO 2 6 LOAD_FAST 0 (x) 6 LOAD_FAST 0 (x) 9 LOAD_ATTR 1 (attributo) 9 LOAD_ATTR 1 (attributo) 12 RETURN_VALUE 12 RETURN_VALUE

L’opcode LOAD_ATTR ► L’opcode della macchina che si occupa di eseguire un lookup è LOAD_ATTR. ► Esaminiamo il sorgente C della macchina virtuale; questo è il main loop: switch (opcode) { case LOAD_FAST:... case LOAD_CONST:... case LOAD_ATTR: w = GETITEM(names, oparg); v = TOP(); x = PyObject_GetAttr(v, w); Py_DECREF(v);SET_TOP(x); if (x != NULL) continue; break;...}

PyObject_GetAttr ► A questo punto possiamo esaminare la funzione PyObject_GetAttr, definita in Objects/object.c: PyObject * PyObject_GetAttr(PyObject *v, PyObject *name) { PyTypeObject *tp = v->ob_type;... if (tp->tp_getattro != NULL) return (*tp->tp_getattro)(v, name);...}

Il campo tp_getattro ► Esaminando il codice precedente possiamo notare una cosa importante: la funzione che esegue il lookup vero e proprio non è univoca, ma dipende dal tipo dell’oggetto. ► Ogni tipo ha un campo tp_getattro che contiene un puntatore ad una funzione che esegue il lookup. ► Questo significa che se quella di default non ci soddisfa possiamo anche definire una nostra politica di lookup. ► Il campo tp_getattro della struct PyType_Type punta alla funzione type_getattro, definita in Objects/typeobject.c: tale funzione implementa la politica di lookup vista in precedenza. ► Ai margini è interessante notare come, in pratica, gli sviluppatori di Python hanno implementato in C un meccanismo di dispatching simile a quello delle funzioni virtuali presenti in altri linguaggi.

Cenni sul descriptor protocol ► In realtà l’implementazione di Python è leggermente più complessa di quanto abbiamo visto fin’ora. ► Prima di continuare, definiamo un nuovo termine:  Un descrittore è un oggetto che possiede un metodo __get__ (e opzionalmente un metodo __set__) ► Durante il lookup di un attributo, prima di restituire l’oggetto corrispondente controlliamo se quest’ultimo è un descrittore. ► Se l’oggetto è un descrittore, chiamiamo il suo metodo __get__ (o __set__, a seconda dei casi) e restituiamo il risultato. ► Questo meccanismo consente agli oggetti di controllare la modalità con cui possono essere acceduti.

Esempio di descrittore ► Senza saperlo, abbiamo già visto un esempio di descrittore: le funzioni. ► Le funzioni hanno un metodo __get__: se esso si accorge che stiamo facendo il lookup su una istanza di classe, costruisce al volo un bound method e lo restituisce. ► In genere il metodo __get__ viene chiamato automaticamente dall’interprete, ma possiamo anche farlo “a mano”: >>> def somma(a, b): return a+b... >>> dummyMethod = somma.__get__(3) >>> dummyMethod >>> dummyMethod(5) 8 ► In questo esempio abbiamo “fatto credere” a somma di essere un metodo dell’oggetto 3. Quando richiamiamo il metodo il primo parametro (3) è aggiunto automaticamente.

Altri descrittori utili ► Il descriptor protocol è un meccanismo fondamentale per implementare alcuni costrutti OO; ecco alcuni esempi:  staticmethod: è un tipo il cui costruttore prende una funzione e restituisce un descrittore che, al contrario delle normali funzioni, non le trasforma in bound method. Questo consente di ottenere dei metodi statici.  classmethod: è un tipo il cui costruttore prende una funzione e restituisce un descrittore che, quando acceduto, lega una funzione alla classe dell’istanza di provenienza. Questo consente di ottenere dei metodi di classe.  property: questo tipo accetta come parametri due funzioni: un “getter” e un “setter”: restituisce un oggetto che quando viene acceduto inoltra la richiesta al getter o al setter, a seconda dei casi. Questo consente di implementare le proprietà: agli occhi dell’utente appaiono come normali attributi, ma in realtà quando vengono accedute vengono automaticamente chiamate dei metodi “trigger”.

Metaclassi ► Come tutti gli oggetti, anche le classi hanno un tipo: esso è chiamato metaclasse (la “classe della classe”). ► Abbiamo visto che quando definiamo una classe, l’interprete crea una istanza di type: in questo caso, type è proprio la metaclasse. ► Possiamo anche definire delle metaclassi alternative da usare al posto di type: con esse possiamo alterare il normale funzionamento delle istanze. ► Ecco alcuni esempi di possibili metaclassi:  readonly: le classi istanziate potranno avere solo attributi read-only  interface: tutti i metodi delle classi istanziati dovranno essere astratti  monitor: le classi istanziate si comporteranno come un monitor ► Per determinare la metaclasse da usare, l’interprete guarda se nel dizionario è presente l’attributo __metaclass__; altrimenti usa la metaclasse di default. ► Abbiamo barato ! In tutti gli esempi che abbiamo fatto fin’ora, abbiamo assunto che la metaclasse di default fosse proprio type. ► In realtà questo non è vero, per ragioni di compatibilità con versioni di Python precedenti alla 2.2.