Programmazione ad Oggetti in Python Parte 2a Programmazione ad Oggetti in Python Giovanni Aglialoro slide tratte anche dalle presentazioni di Marco Barisione, Antonio Cuni, Marco Tozzi. www.python.org

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 = ‘ciao’ x ‘ciao’ y = x ‘salve’ y 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; struct _typeobject *ob_type; 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): self.x = ‘ciao’ def saluta(self): print self.x mioOggetto = MiaClasse()

Esempio class MiaClasse: ... mioOggetto = MiaClasse() 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’

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”: Controllo il nome “x” è presente nel dizionario di obj (obj.__dict__). Se non c’è controllo se “x” è presente nel dizionario del tipo di obj (obj.__class__.__dict__) 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): self.nome = nome def saluta(self): print ‘ciao’, self.nome class Derivata(Base): print ‘Buongiorno’, self.nome obj = Derivata(‘anto’)

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

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): 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! <bound method MiaClasse.MioMetodo of <__main__.MiaClasse instance at 0x0082CAD8>> >>> xxx = obj.mioMetodo >>> 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 Lavoratore Studente StudenteLavoratore 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. 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. Il MRO di StudenteLavoratore è: StudenteLavoratore, 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). class A(B,C): def metodo1(self): print ‘ciao’ def metodo2(self): print ‘salve’ Nell’esempio a fianco: Il nome della classe è la stringa ‘A’ L’elenco delle basi è la tupla (B,C) Il dizionario degli attributi contiene le chiavi ‘metodo1’ e ‘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 3 SET_LINENO 2 6 LOAD_FAST 0 (x) 9 LOAD_ATTR 1 (attributo) 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 <bound method ?.somma of 3> >>> 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.