Re: Come stabilisce la compatiblita' comportamentale python?

jacopo mondi wrote:
> Nonostante il Sub altisonante la domanda e' semplice...
> Alla base della tipizzazione dinamica ci sta la capacita' di pyhon di
> instanziare una forma di compatibilita' comportamentale tra tipi
> differenti, a me interesserebbe capire come cio' viene realizzato.
> A livello di implementazione della "macchina python" cio' e' possibile
> in quanto i riferimenti agli oggetti non sono altro che puntatori C
> (giusto?) percui e' possibile assegnarvi un oggetto di qualunque tipo,
> ma run-time non mi e' chiara come venga appunto stabilita la
> compatibilita'.
> Ho pensato che forse vengono utlizzati i cosidetti metodi "under the
> hood", oppure quella magnifica invenzione che e' il metodo dir proprio
> dell'interprete, ma volevo sapere se qualcuno ha informazioni piu'
> dettagliate, anche perche' sono sicuro che il tutto sia piu' raffinato
> di come ho esposto io.

è tutto molto più semplice, e anche altamente raffinato nella sua
semplicità: in Python i blocchi di codice sono delle sequenze in cui si
inviano dei messaggi agli oggetti; i messaggi sono del tipo
"leggi/scrivi/elimina questo attributo", "qual'è la tua lunghezza?", ecc.

Quando i blocchi di codice sono eseguiti a runtime, l'interprete non fa
altro che chiedere all'oggetto di rispondere a quei messaggi; l'oggetto
ha la facoltà di rispondere sollevando una eccezione, nel caso in cui
non sia in grado di rispondere adeguatamente.

Ovviamente, ci deve essere un protocollo condiviso grazie al quale
l'interprete può chiedere agli oggetti di rispondere ad un determinato
messaggio; dal punto di vista implementativo, in CPython esiste una
struttura chiamata PyObject la quale viene ereditata[1] da tutti gli
oggetti; questa struttura contiene tutto il necessario per far si che
l'interprete possa inviare i vari messaggi ad un qualunque oggetto.

[1] essendo scritto in C, non esiste un meccanismo built-in di
ereditarietà come in C++; l'ereditarietà viene implementata
semplicemente includendo un campo di tipo PyObject in testa ad ogni
struttura che rappresenta un oggetto; questi oggetti verranno poi
passati in giro con tipo PyObject*.


In PyPy, la tecnica implementativa è simile anche se non identica;
RPython, il linguaggio in cui è scritto l'interprete python di PyPy,
supporta nativamente classi ed ereditarietà, quindi possiamo usare
quelle per modellare i nostri oggetti. La classe base da cui ereditano
tutti gli oggetti è W_Root; l'interprete manda messaggi agli oggetti
passando attraverso quello che chiamiamo un "object space", che non è
altro che una entità il cui scopo è proprio quello di fare da ponte tra
interprete ed oggetti; mandare un messaggio ad un oggetto significa
chiamare un determinato metodo sull'object space, come ad esempio add.

Dal punto di vista didattico, secondo me è molto istruttivo entrare
"dentro l'interprete" ed esplorarlo per vedere come funziona.

1) scarica pypy seguendo queste istruzioni (preferibilmente la versione
in svn): http://codespeak.net/pypy/dist/pypy/doc/getting-started.html

2) esegui il file bin/py.py, che avvia l'interprete Python; l'interprete
sarà molto lento (sul mio pc ci mette circa 20 secondi a partire) perché
non è ancora stato compilato, ma proprio per questo è possibile
esplorarlo in profondità

3) nota che il prompt è composto da quattro segni di maggiore, a
differenza degli usuali tre; questo per aiutarci a distinguere quando
siamo in py.py o cpython

4) esegui alcune linee di codice, come "a = 40" e "b = 2", poi premi
CTRL-C: questa combinazione di tasti ti fa entrare nella
"interpeter-level console", da cui possiamo esaminare quello che sta
succedendo sotto i nostri piedi:

>>>> a = 40
>>>> b = 2
>>>> <premi CTRL-C>
Python 2.4.4 (#1, Jun 22 2008, 17:00:16)
[GCC 4.1.2 (Gentoo 4.1.2 p1.0.1)] on linux2
*** Entering interpreter-level console ***
>>> space
StdObjSpace
>>> w_a
W_IntObject(40)
>>> w_a.intval
40
>>> w_b
W_IntObject(2)
>>> type(w_a)
<class 'pypy.objspace.std.intobject.W_IntObject'>
>>> type(w_a).__bases__
(<class 'pypy.objspace.std.model.W_Object'>,)
>>> type(w_a).__bases__[0].__bases__
(<class 'pypy.interpreter.baseobjspace.W_Root'>,)
>>> space.add(w_a, w_b)
W_IntObject(42)
>>>

come puoi vedere, una volta nella interpreter-level console abbiamo a
disposizione delle variabili nel nostro namespace globale:

   - space rappresenta l'object space

   - w_a e w_b contengono gli oggetti a basso livello tramite cui sono
implementati gli oggetti ad alto livello a e b; in generale, per ogni
nome x definito al prompt di py.py, troviamo un nome w_x nella
interpreter-level console

come puoi vedere, w_a e w_b sono istanze della classe W_IntObject;
questa classe definisce un campo "intval" che contiene il valore vero e
proprio del nostro oggetto intero.  La classe base di W_IntObject è
W_Object, che a sua volta eredita da W_Root, come avevo detto in precedenza.

Per eseguire una addizione, chiamiamo il metodo "add" sull'oggetto
space; come puoi vedere, il metodo add si occupa di fare la somma vera e
propria, e poi costruisce un altro oggetto di tipo W_IntObject il cui
campo intval è il risultato.

CPython opera in modo simile, ma essendo scritto in C non è possibile
ammirare quello che fa in tempo reale.

Dopo aver scritto tutta questa pappardella non sono sicuro di aver
risposto alla tua domanda, spero di non essere andato off-topic :-).

ciao,
Anto
--
Antonio Cuni
http://pythonsandladders.blogspot.com/