Implentazione degli oggetti in Python

1. Implentazione degli oggetti in Python Antonio Cuni Marco Tozzi Seminario IL

2. Sommario • Panoramica sui linguaggi di scripting • Panoramica su Python • Implementazione degli oggetti in Python Seminario IL

3. 1. Panoramica sui linguaggi di scripting Seminario IL

4. Linguaggi di scripting • Che cos’è uno script? • Un piccolo programma per automatizzare un lavoro ripetitivo e noioso • Una serie di comandi inviati ad un “ambiente esterno” che li interpreta e esegue • Ambiente Esterno: • SO tramite shell • Programma applicativo es: MS Office Con l’aumento della complessità la distinzione tra script e programmi è sempre più sfumata Seminario IL

5. Linguaggi di scripting (2) • Che cos’è un linguaggio di scripting? • Supporto per scrivere velocemente e facilmente script • Programmazione ad alto livello, consente di tralasciare dettagli di basso livello (es: gestione della memoria) • Alcuni sono talmente potenti da consentire lo sviluppo di intere applicazioni Seminario IL

6. Linguaggi di scripting: esempi • Specializzati in compiti specifici: • awk elaborazione di testo organizzato in righe e colonne • sed elaborazione di testo arbitrario • Che consentono di controllare un’applicazione ospitante: • Visual Basic for Applications (MS Office) • Javascript (web browser) • Emacs Lisp (Emacs) • General purpouse adatti per applicazioni più complesse: • Python • Perl • Ruby Seminario IL

7. Linguaggi interpretati • Non richiedono alcuna compilazione esplicita • In realtà in molti casi (Python, Perl,Emacs Lisp) c’è un compilatore che produce byte-code interpretato da una VM Nota:stessa architettura usata da Java e .NET solo che in questi è il programmatore a chiedere la compilazione Seminario IL

8. Tipizzazione forte VS debole Abbiamo spesso (non sempre!) che: • Linguaggi di script tipizzazione debole Es: sommiamo un numero ad una stringa • Javascript • 3+"3" == "33" • 3-"3" == 0 • PHP • 3+"3" == 6 • 3+"ciao" == 3 Seminario IL

9. Tipizzazione forte VS debole (2) • Debole: comoda per script semplici e brevi • A lungo andare può portare a bug molto insidiosi e difficili da trovare • Es di linguaggio con tipizzazione forte: Python avrebbe generato un errore negli esempi precedenti Seminario IL

10. Tipizzazione statica VS dinamica • Tipizzazione statica: • eseguibili più efficienti • intercettare alcuni (pochi!) errori a compile-time • In quasi tutti i linguaggi di scripting abbiamo tipizzazione dinamica: • Tipo determinato a run-time e può variare durante l’esecuzione • Notevole flessibilità Seminario IL

11. 2. Introduzione a Python Seminario IL

12. Python: introduzione • È un linguaggio di programmazione: • Interpretato • Di altissimo livello • Semplice da imparare e usare • Potente e produttivo • Ottimo anche come primo linguaggio (molto simile allo pseudocodice) • Inoltre • È open source (www.python.org) • È multipiattaforma • È facilmente integrabile con C/C++ e Java Seminario IL

13. Python: introduzione (2) È veramente usato da qualcuno? • RedHat anaconda (installazione), tool di configurazione grafici, log viewer • NASA • www.google.com • Industrial Light and Magic quelli che fanno gli effetti speciali per Star Wars... • E molti altri … Seminario IL

14. 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: >>> 3+5 8 >>> print "Hello world!" Hello world! L’ istruzione print stampa a video il risultato di un’espressione Seminario IL

15. Python come calcolatrice • Possiamo usare l’interprete interattivo come calcolatrice: >>> (6+3) / 2 4 >>> 3/2 1 >>> 3/2.0 1.5 • 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 Seminario IL

16. 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 Seminario IL

17. Python: stringhe (2) • Possiamo concatenare due stringhe usando l’operatore +: >>> print ’ciao ’ + ’ciao’ ciao ciao • Possiamo ripetere una stringa usando l’operatore *: >>> print ’-’ * 20 -------------------- >>> 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’ Seminario IL

18. 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’ Seminario IL

19. 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’ Seminario IL

20. 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! len() è una funzione, si applica anche ad altre sequenze Seminario IL

21. 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] Seminario IL

22. 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] Seminario IL

23. 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] Seminario IL

24. 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 Seminario IL

25. 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} Seminario IL

26. Python: esempio di algoritmo • Calcoliamo i numeri di Fibonacci: >>> # Serie di Fibonacci: ... # Ogni numero e‘ la somma ... # dei due numeri precedenti ... a, b = 0, 1 >>> while b < 10: ...print b ...a, b = b, a+b ... 1 1 2 3 5 8 Seminario IL

27. Osservazioni • per delimitare il ciclo 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 Seminario IL

28. 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) 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 • Il primo statement può essere una docstring usata da tools che producono documentazione Seminario IL

29. 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 <function object at 10042ed0> >>> f = fib >>> f(100) 1 1 2 3 5 8 13 21 34 55 89 Seminario IL

30. 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): *arg è una tupla contenente i parametri posizionali **keywords è un dizionario dei keyword arguments a cui non corrisponde un parametro formale Seminario IL

31. Python Classi • Definizione: class ClassName: <statement-1> … <statement-N> • Successivamente ad una definizione di classe si crea un class object • I class object supportano due operazioni: • Riferimento agli attributi: >>> class MyClass: ... i = 12345 ... def f(self): ... return 'hello world' ... >>> MyClass.i 12345 >>> MyClass.f <unbound method MyClass.f> Seminario IL

32. 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) Seminario IL

33. Python Class Inheritance • Sintassi: class DerivedClassName(BaseClassName): <statement-1> … <statement-N> • 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): super(C, self).meth(arg) • Supporta ereditarietà multipla: class DerivedClassName(Base1, Base2, Base3): risoluzione attributi depht-first, left-to-right Seminario IL

34. 3. Implementazione degli oggetti in Python Seminario IL

35. x y z w Universo degli oggetti Namespace dei nomi 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. Seminario IL

36. 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’ Seminario IL

37. 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 Seminario IL

38. 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 Seminario IL

39. 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. Seminario IL

40. 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. Seminario IL

41. 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. Seminario IL

42. 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() Seminario IL

43. class MiaClasse: ... Esempio 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’ Seminario IL

44. 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à Seminario IL

45. 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__). Seminario IL

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

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

48. 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). Seminario IL

49. 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 Seminario IL

50. 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. Seminario IL