[Python] - Definizione di classi

[88MIKI88]

Sto leggendo il capitolo sulle classi e mi è sorto un dubbio...il libro per definire una classe procede nel seguente modo

class punto:
   pass

e poi successivamente

p1 = punto()
p1.x=4.0
......

Con pass nn succede niente... invece l'istanzazione a l'inserimento degli attributi avviene solo in un secondo momento.

Non si può quindi fare una cosa del tipo:

class punto:
   p1 = punto()
   p1.x=4.0
...........

Plesase cdimauro / esperto in python datemi delle delucidazioni in merito....secondo me questo capitolo non è tanto chiaro xò boh

[cdimauro]

Originariamente inviato da 88MIKI88

Sto leggendo il capitolo sulle classi e mi è sorto un dubbio...il libro per definire una classe procede nel seguente modo

class punto:
   pass

e poi successivamente

p1 = punto()
p1.x=4.0
......

Con pass nn succede niente... invece l'istanzazione a l'inserimento degli attributi avviene solo in un secondo momento.

Non si può quindi fare una cosa del tipo:

class punto:
   p1 = punto()
   p1.x=4.0
...........

Plesase cdimauro / esperto in python datemi delle delucidazioni in merito....secondo me questo capitolo non è tanto chiaro xò boh

Con Python gli attributi a una classe o anche a una singola instanza li puoi aggiungere e togliere come e quando vuoi.

Se vuoi settare delle variabili di classe, puoi fare così:

class punto:
   x = 4.0
   y = 5.0

Il tuo esempio precedente non è corretto, perché la classe punto non è ancora stata definita.

Se vuoi aggiungere invece degli attributi di istanza, fai così:

class punto:
   def __init__(self):
       self.x = 4.0

p1 = punto()
print p1.x

Questi due esempi simulano quello che avviene con altri linguaggi orientati agli oggetti che hanno una tipizzazione statica e, quindi, richiedono di specificare sempre nella definizione della classe gli attribuiti di classe o d'istanza.

Ma ne puoi fare a meno, se non sono necessari. Io per una questione di leggibilità generalmente li specifico sempre come nei due esempi che ho riportato.

[mad_hhatter]

siccome in Java è possibile una definizione ricorsiva di una classe (cioè è possibile definire una classe avente come membro un'istanza di sè stessa), quale caratteristica del linguaggio permette a Java questo comportamento e lo vieta in python?

grazie per l'aiuto

[cdimauro]

In Python non puoi istanziare immediatamente la classe mentre è in corso la sua definizione, come nell'esempio precedente:

class punto:
   p1 = punto()
   p1.x=4.0

Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 2, in punto
NameError: name 'punto' is not defined

Puoi invece creare tutte le istanze che vuoi di se stessa all'interno dei suoi metodi:

class punto:
  def MySelf(self):
    return punto

>>> p = punto()
>>> p.MySelf()
<class __main__.punto at 0x027E3CF0>
>>> punto
<class __main__.punto at 0x027E3CF0>

Il comportamento come vedi è simile a quello degli altri linguaggi.

[mad_hhatter]

ah ok, mi pareva una limitazione eccessiva, infatti... ma perché all'interno di un metodo è concessa mentre è vietata a livello di membri?

[88MIKI88]

Esercizio:
scrivi una funzione chiamata MuoviRettangolo che prende come parametri un Rettangolo e due valori dx e dy. La funzione deve spostare le coordinate del punto in alto a sinistra sommando alla posizione x il valore dx e alla posizione y il valore dy.

class Rettangolo:
	pass

#a,b,c,d sarebbero i nomi dei punti che compongono il rettangolo
R=Rettangolo()
R.ax=1.0
R.ay=2.0
R.bx=3.0
R.by=4.0
.......
.......


def Muovirettangolo(Rettangolo,dx,dy):
	R.ax=R.ax+dx
	R.ay=R.ay+dy
	print R.ax, R.ay

Secondo voi può andare??

[banryu79]

1] visto che sposti le coordinate del punto in alto a sinistra (ax, ay) di una certa quantità (dx, dy) devi poi aggiornare anche le coordinate del secondo punto (bx, by).
Secondo me potresti definire rettangolo tramite il punto in alto a sinistra (ax, ay) e due valori (larghezza, altezza), invece di specificare il secondo punto (bx, by).
In questo modo poi aggiungerei un metodo che sulla base dei valori dei membri così definiti di rettangolo calcoli il suo secondo punto.

2] per stampare il valore dei due punti del rettangolo farei un metodo a parte che fa solo quello.

[cdimauro]

Originariamente inviato da mad_hhatter

ah ok, mi pareva una limitazione eccessiva, infatti... ma perché all'interno di un metodo è concessa mentre è vietata a livello di membri?

Perché Python differisce dagli altri linguaggi di programmazione "statici" perché quando incontra una definizione di classe, in realtà non la definisce, ma la costruisce, cioé ne esegue il codice che incontra man mano.

Tornando all'esempio di prima:

class punto:
   x = 4.0
   y = 5.0

In questo caso abbiamo punto che ha due variabili di classe, x e y. Cosa fa Python quando incontra questo pezzo di sorgente? Ne... esegue il codice.

Quindi sa che deve creare un oggetto (perché la classe punto è a tutti gli effetti un oggetto; in Python qualunque cosa è un oggetto) che dovrà chiamare punto e dovrà inserirlo nel namespace dello scope attuale (nel caso in questione si tratta del global scope del modulo in cui ha incontrato questa istruzione) e comincia a eseguirne il codice.

All'inizio crea un nuovo oggetto di tipo classe (o type, che è uguale; non c'è differenza fra tipi e classi in Python, perché entrambi permettono di creare nuove istanze di "se stessi"), lo chiama internamente "punto" (il binding con lo scope attuale si verifica soltanto alla fine dell'istruzione class) e imposta come scope quello della classe (quindi tutti i binding che ci saranno da adesso alla fine dell'istruzione riguarderanno il name space dell'oggetto "punto").

Poi continua e incontra l'istruzione x = 4.0. La esegue. Questa crea un oggetto float con valore 4.0 e crea anche una variabile di nome "x" nello scope attuale (che è quello dell'oggetto "punto"), assegnadoglielo.
Idem per y = 5.0.

Alla chiusura dell'istruzione class abbiamo che l'oggetto "punto" ha nel suo namespace due variabili ("x" e "y") coi rispettivi valori. Infine viene rimosso lo scope dell'istruzione class, tornando a quello precedente, al quale viene effettuato il binding a "punto".

Per funzioni e metodi la situazione è la stessa: l'istruzione def non definisce una funzione o un metodo, ma si passa ad eseguire l'istruzione def.

class punto:
   def __init__(self):
       self.x = 4.0

In questo caso però è più semplice. Quando viene eseguita la def __init__ viene creato sempre un nuovo oggetto di tipo funzione a cui viene associato il nome "__init__" (il binding con lo scope attuale verrà effettuato alla fine, al solito).

Vengono poi annotati il numero e il tipo di parametri (se sono con valore di default oppure no), e infine viene semplicemente creato il bytecode delle istruzioni presenti dentro l'istruzione def.

Quindi NON viene eseguito il codice di self.x = 4.0, soltanto generato il suo bytecode e memorizzato all'interno di "__init__".

Alla fine viene effettuato il binding di "__init__" allo scope attuale, cioé quello di "punto".

In buona sostanza, definire classi e funzioni in Python equivale a tutti gli effetti a eseguire del codice (a seconda del tipo di istruzione) e a creare sempre degli oggetti.

In questo modo si spiega perché una variabile di classe NON può memorizzare istanze di sé stessa: perché in quel preciso momento nello scope non esiste nessuna variabile "punto" da poter istanziare, perché il binding, appunto, avviene alla fine.

Un metodo può, invece, effettuare quest'operazione, perché nel momento in cui viene eseguito l'oggetto "punto" è stato già completamente definito, per cui è presente nello scope e, quindi, lo si può "chiamare" (ebbene sì: la creazione di un'istanza equivale, in Python, a una chiamata a funzione che restituisce un nuovo oggetto, ovviamente del tipo della classe).

In alternativa si può potrebbe completare la creazione dell'oggetto "punto" e inizializzare poi le sue variabili di classe:

class punto:
  pass

punto.p1 = punto()

E' molto diverso da ciò che avviene con gli altri linguaggi "statici" (d'altra parte Python non a caso è... dinamico ), per cui non dovesse essere chiaro chiedi pure.

Originariamente inviato da 88MIKI88

Esercizio:
scrivi una funzione chiamata MuoviRettangolo che prende come parametri un Rettangolo e due valori dx e dy. La funzione deve spostare le coordinate del punto in alto a sinistra sommando alla posizione x il valore dx e alla posizione y il valore dy.

class Rettangolo:
	pass

#a,b,c,d sarebbero i nomi dei punti che compongono il rettangolo
R=Rettangolo()
R.ax=1.0
R.ay=2.0
R.bx=3.0
R.by=4.0
.......
.......


def Muovirettangolo(Rettangolo,dx,dy):
	R.ax=R.ax+dx
	R.ay=R.ay+dy
	print R.ax, R.ay

Secondo voi può andare??

Sì, ma non basta (vedi banryu). Ma poi devi proprio stampare i valori dentro Muovirettangolo?

[mad_hhatter]

ti ringrazio cdimauro, sei stato chiarissimo

[88MIKI88]

Sì, ma non basta (vedi banryu). Ma poi devi proprio stampare i valori dentro Muovirettangolo?

La stampa l'ho messa io tanto x vedere se il programma funzionava...mmm ok forse ho capito come procedere diciamo che dopo aver cambiato le coordinate di A faccio partire una funzione che mi calcoli in automatico in base ai parametri che passerò il punto B (quello in alto a dx) giusto??

[banryu79]

Grazie cdimauro per la chiara spiegazione, ho imparato qualcosa di nuovo (avevo immaginato si trattasse appunto del fatto che Python è un linguaggio dinamico, ma non conoscevo i dettagli del meccanismo, molto interessante).

La stampa l'ho messa io tanto x vedere se il programma funzionava

Certo, solo non è molto logico farla fare dentro un metodo il cui scopo è "Muovirettangolo". Diciamo che sarebbe meglio dall'esterno chiamare "MuoviRettangolo" su un oggetto Rettangolo e subito dopo chiamare, per esempio, "Stamparettangolo".
Ancora meglio, mi sembra un pleonasma includere nel nome dei metodi di Rettangolo il nome della classe, io cioè li chiamerei semplicemente "Muovi" e "Stampa".

mmm ok forse ho capito come procedere diciamo che dopo aver cambiato le coordinate di A faccio partire una funzione che mi calcoli in automatico in base ai parametri che passerò il punto B (quello in alto a dx) giusto??

Esatto.

[cdimauro]

Grazie. Comunque non ho voluto allungare troppo il discorso, ma il comportamento di Python nella creazione di classi e funzioni è utilissimo quando poi si cominciano a usare le metaclassi (per le classi soltanto) e i decoratori (per entrambe).

Tanto per rendere l'idea del perché sia utile questo comportamento, supponiamo di voler loggare le chiamate a tutti i metodi di una classe.

E' sufficiente creare una metaclasse, oppure un class decorator (disponibile a partire da Python 2.6) che verrà "applicata" all'istanza appena creata (quindi è terminata l'istruzione class, ma non è ancora stato effettuato il binding del suo nome nello scope) che "rovista" fra tutti i metodi della classe li sostituisce uno per uno con degli opportuni wrapper.

Supponendo che Log sia una funzione che prende in input un elenco variabile di argomenti e li scriva su un file, e che logmethods sia un class decorator che esegue il lavoro di cui sopra, basta questo:

@logmethods(Log)
class Test:
  def Somma(self, x, y):
    return x + y
  def Prodotto(self, x, y):
    return x + y

per loggare automaticamente tutte le chiamate a Somma e Prodotto (e volendo anche il loro risultato; a seconda di com'è implementato logmethods).

Comunque si tratta di argomenti avanzati e anche un po' complicati, ma davvero molto utili una volta che sono entrati a far parte del proprio bagaglio culturale.

[banryu79]

Ora non sono sicuro perchè non ho approfondito fino a questo punto, ma anche in SmallTalk si possono ottenere dei risultati simili in potenza a quello da te descritto, con la scusa che tutto è un oggetto, anche le classi stesse (ci sono le metaclassi).

Questo per dire che non è una novità ma fa certamente piacere sapere che in un linguaggio dinamico e recente (e suppongo anche più "di produzione" che SmallTalk) hanno incluso questa potenzialità.

[cdimauro]

Come giustamente hai riportato, il concetto di metaclasse non è affatto nuovo e infatti lo ritroviamo in SmallTalk.

Python però lo implementa in maniera diversa e con uno stile particolarmente semplice e funzionale (in tutti i sensi ).

[banryu79]

Originariamente inviato da cdimauro

Come giustamente hai riportato, il concetto di metaclasse non è affatto nuovo e infatti lo ritroviamo in SmallTalk.

Python però lo implementa in maniera diversa e con uno stile particolarmente semplice e funzionale (in tutti i sensi ).

Ti prendo in parola perchè in questo momento non posso andare a rivedermi l'implementazione delle metaclassi in SmallTalk, ho rogne più rognose in ufficio da sbrigare

Però mi interesserebbe un piccolo confrontro per capire le diverse filosofie

[~FullSyst3m~]

Non ho capito un azz

[~FullSyst3m~]

Originariamente inviato da banryu79

1] visto che sposti le coordinate del punto in alto a sinistra (ax, ay) di una certa quantità (dx, dy) devi poi aggiornare anche le coordinate del secondo punto (bx, by).
Secondo me potresti definire rettangolo tramite il punto in alto a sinistra (ax, ay) e due valori (larghezza, altezza), invece di specificare il secondo punto (bx, by).
In questo modo poi aggiungerei un metodo che sulla base dei valori dei membri così definiti di rettangolo calcoli il suo secondo punto.

2] per stampare il valore dei due punti del rettangolo farei un metodo a parte che fa solo quello.

Un metodo a parte solo per stampare un valore?

[banryu79]

Originariamente inviato da ~FullSyst3m~

Un metodo a parte solo per stampare un valore?

Certo, anzi, forse sarebbe meglio un metodo che faccia l'equivalente del toString() in Java.
Poi sarà il chiamante esterno a decidere se e dove stampare.

[~FullSyst3m~]

Originariamente inviato da banryu79

Certo, anzi, forse sarebbe meglio un metodo che faccia l'equivalente del toString() in Java.
Poi sarà il chiamante esterno a decidere se e dove stampare.

Non è più comodo inserire un print quando serve?

[~FullSyst3m~]

class Rettangolo:
    pass
R = Rettangolo()
R.AltoSx = 00.0
R.AltoSy = 00.0

def MuoviRettangolo(Rettangolo, dx, dy):
    SpostaSx = R.AltoSx + dx
    SpostaSy = R.AltoSy + dy
    return SpostaSx, SpostaSy

Io l'ho risolto cosi, ma vorrei capire cosa voleva dire banryu