random.randrange(0, len(self.Carte))
Un modo utile per mescolare un mazzo `e scambiare ogni carta con un’altra scelta a caso. `E possibile che la carta possa essere scambiata con se stessa ma questa situazione `e perfettamente accettabile. Infatti se escludessimo questa possibilit`a l’ordine delle carte sarebbe meno casuale:
class Mazzo: ... def Mescola(self): import random NumCarte = len(self.Carte) for i in range(NumCarte): j = random.randrange(i, NumCarte)
self.Carte[i], self.Carte[j] = self.Carte[j], self.Carte[i] Piuttosto che partire dal presupposto che le carte del mazzo siano sempre 52 abbiamo scelto di ricavare la lunghezza della lista e memorizzarla in NumCarte. Per ogni carta del mazzo abbiamo scelto casualmente una carta tra quelle non ancora mescolate. Poi abbiamo scambiato la carta corrente (i) con la carta selezionata (j). Per scambiare le due carte abbiamo usato un’assegnazione di una tupla, come si `e gi`a visto nella sezione 9.2:
self.Carte[i], self.Carte[j] = self.Carte[j], self.Carte[i] Esercizio: riscrivi questa riga di codice senza usare un’assegnazione di una tupla.
15.8 Rimuovere e distribuire le carte
Un altro metodo utile per la classe Mazzo `e RimuoviCarta che permette di rimuovere una carta dal mazzo ritornando vero (1) se la carta era presente e falso (0) in caso contrario:
class Mazzo: ...
def RimuoviCarta(self, Carta): if Carta in self.Carte:
self.Carte.remove(Carta) return 1
else: return 0
L’operatore in ritorna vero se il primo operando `e contenuto nel secondo. Que-st’ultimo deve essere una lista o una tupla. Se il primo operando `e un oggetto, Python usa il metodo cmp dell’oggetto per determinare l’uguaglianza tra gli elementi della lista. Dato che cmp nella classe Carta controlla l’uguaglianza forte il metodo RimuoviCarta usa anch’esso l’uguaglianza forte.
Per distribuire le carte si deve poter rimuovere la prima carta del mazzo e il metodo delle liste pop fornisce un ottimo sistema per farlo:
class Mazzo: ...
def PrimaCarta(self): return self.Carte.pop()
In realt`a pop rimuove l’ultima carta della lista, cos`ı stiamo in effetti togliendo dal fondo del mazzo, ma dal nostro punto di vista questa anomalia `e indifferente. Una operazione che pu`o essere utile `e la funzione booleana EVuoto che ritorna vero (1) se il mazzo non contiene pi`u carte:
class Mazzo: ...
def EVuoto(self):
return (len(self.Carte) == 0)
15.9 Glossario
Mappare: rappresentare un insieme di valori usando un altro insieme di valori e costruendo una mappa di corrispondenza tra i due insiemi.
Codificare: in campo informatico sinonimo di mappare.
Attributo di classe: variabile definita all’interno di una definizione di classe ma al di fuori di qualsiasi metodo. Gli attributi di classe sono accessibili da ognuno dei metodi della classe e sono condivisi da tutte le istanze della classe.
Accumulatore: variabile usata in un ciclo per accumulare una serie di valori, concatenati sotto forma di stringa o sommati per ottenere un valore totale.
Capitolo 16
Ereditariet`a
16.1 Ereditariet`a
La caratteristica pi`u frequentemente associata alla programmazione ad oggetti `e l’ereditariet`a che `e la capacit`a di definire una nuova classe come versione modificata di una classe gi`a esistente.
Il vantaggio principale dell’ereditariet`a `e che si possono aggiungere nuovi metodi ad una classe senza dover modificare la definizione originale. `E chiamata “ere-ditariet`a” perch´e la nuova classe “eredita” tutti i metodi della classe originale. Estendendo questa metafora la classe originale `e spesso definita “genitore” e la classe derivata “figlia” o “sottoclasse”.
L’ereditariet`a `e una caratteristica potente e alcuni programmi possono essere scritti in modo molto pi`u semplice e conciso grazie ad essa, dando inoltre la possibilit`a di personalizzare il comportamento di una classe senza modificare l’originale. Il fatto stesso che la struttura dell’ereditariet`a possa riflettere quella del problema pu`o rendere in qualche caso il programma pi`u semplice da capire. D’altro canto l’ereditariet`a pu`o rendere pi`u difficile la lettura del programma, visto che quando si invoca un metodo non `e sempre chiaro dove questo sia stato definito (se all’interno del genitore o delle classi da questo derivate) con il codice che deve essere rintracciato all’interno di pi`u moduli invece che essere in un unico posto ben definito. Molte delle cose che possono essere fatte con l’ereditariet`a possono essere di solito gestite elegantemente anche senza di essa, ed `e quindi il caso di usarla solo se la struttura del problema la richiede: se usata nel momento sbagliato pu`o arrecare pi`u danni che apportare benefici. In questo capitolo mostreremo l’uso dell’ereditariet`a come parte di un program-ma che gioca a Old Maid, un gioco di carte piuttosto meccanico e semplice. Anche se implementeremo un gioco particolare uno dei nostri scopi `e quello di scrivere del codice che possa essere riutilizzato per implementare altri tipi di giochi di carte.
16.2 Una mano
Per la maggior parte dei giochi di carte abbiamo la necessit`a di rappresentare una mano di carte. La mano `e simile al mazzo, dato che entrambi sono insiemi di carte e richiedono metodi per aggiungere e rimuovere carte. Inoltre abbiamo bisogno sia per la mano che per il mazzo di poter mescolare le carte.
La mano si differenzia dal mazzo perch´e, a seconda del gioco, possiamo avere la necessit`a di effettuare su una mano alcuni tipi di operazioni che per un mazzo non avrebbero senso: nel poker posso avere l’esigenza di classificare una mano (full, colore, ecc.) o confrontarla con un’altra mano mentre nel bridge devo poter calcolare il punteggio di una mano per poter effettuare una puntata. Questa situazione suggerisce l’uso dell’ereditariet`a: se creiamo Mano come sot-toclasse di Mazzo avremo immediatamente disponibili tutti i metodi di Mazzo con la possibilit`a di riscriverli o di aggiungerne altri.
Nella definizione della classe figlia il nome del genitore compare tra parentesi: class Mano(Mazzo):
pass
Questa istruzione indica che la nuova classe Mano eredita dalla classe gi`a esistente Mazzo.
Il costruttore Mano inizializza gli attributi della mano, che sono il Nome e le Carte. La stringa Nome identifica la mano ed `e probabilmente il nome del giocatore che la sta giocando: `e un parametro opzionale che per default `e una stringa vuota. Carte `e la lista delle carte nella mano, inizializzata come lista vuota:
class Mano(Mazzo):
def __init__(self, Nome=""): self.Carte = []
self.Nome = Nome
In quasi tutti i giochi di carte `e necessario poter aggiungere e rimuovere carte dal-la mano. Deldal-la rimozione ce ne siamo gi`a occupati, dato che Mano eredita imme-diatamente RimuoviCarta da Mazzo. Dobbiamo invece scrivere AggiungeCarta: class Mano(Mazzo):
def __init__(self, Nome=""): self.Carte = []
self.Nome = Nome
def AggiungeCarta(self,Carta) : self.Carte.append(Carta)
16.3 Distribuire le carte 151
16.3 Distribuire le carte
Ora che abbiamo una classe Mano vogliamo poter spostare delle carte dal Mazzo alle singole mani. Non `e immediatamente ovvio se questo metodo debba essere inserito nella classe Mano o nella classe Mazzo ma dato che opera su un mazzo singolo e (probabilmente) su pi`u mani `e pi`u naturale inserirlo in Mazzo. Il metodo Distribuisci dovrebbe essere abbastanza generale da poter essere usato in vari giochi e deve permettere la distribuzione tanto dell’intero mazzo che di una singola carta.
Distribuisci prende due argomenti: una lista (o tupla) di mani e il numero totale di carte da distribuire. Se non ci sono carte sufficienti per la distribuzione il metodo distribuisce quelle in suo possesso e poi si ferma:
class Mazzo: ...
def Distribuisci(self, ListaMani, NumCarte=999): NumMani = len(ListaMani)
for i in range(NumCarte):
if self.EVuoto(): break # si ferma se non ci sono # ulteriori carte
Carta = self.PrimaCarta() # prende la carta superiore # del mazzo
Mano = ListaMani[i % NumMani] # di chi e’ il prossimo # turno?
Mano.AggiungeCarta(Carta) # aggiungi la carta alla # mano
Il secondo parametro, NumCarte, `e opzionale; il valore di default `e molto grande per essere certi che vengano distribuite tutte le carte del mazzo.
La variabile del ciclo i va da 0 a NumCarte-1. Ogni volta che viene eseguito il corpo del ciclo, la prima carta del mazzo viene rimossa usando il metodo di lista pop che rimuove e ritorna l’ultimo valore di una lista.
L’operatore modulo (%) ci permette di distribuire le carte in modo corretto, una carta alla volta per ogni mano: quando i `e uguale al numero delle mani nella lista l’espressione i % NumMani restituisce 0 permettendo di ricominciare dal primo elemento della lista delle mani.
16.4 Stampa di una mano
Per stampare il contenuto di una mano possiamo avvantaggiarci dei metodi StampaMazzoe str ereditati da Mazzo. Per esempio:
>>> Mazzo1 = Mazzo() >>> Mazzo1.Mescola() >>> Mano1 = Mano("pippo")
>>> Mazzo1.Distribuisci([Mano1], 5) >>> print Mano1
2 di Picche 3 di Picche
4 di Picche Asso di Cuori
9 di Fiori
Anche se `e comodo ereditare da metodi esistenti pu`o essere necessario modifi-care il metodo str nella classe Mano per aggiungere qualche informazione, ridefinendo il metodo omonimo ereditato dalla classe Mazzo:
class Mano(Mazzo) ...
def __str__(self):
s = "La mano di " + self.Nome if self.EVuoto():
s = s + " e’ vuota\n" else:
s = s + " contiene queste carte:\n" return s + Mazzo.__str__(self)
s `e una stringa che inizialmente indica chi `e il proprietario della mano. Se la mano `e vuota vengono aggiunte ad s le parole "e’ vuota" e viene ritornata s. IN caso contrario vengono aggiunte le parole "contiene queste carte" e la rappresentazione della mano sotto forma di stringa gi`a vista in Mazzo, elaborata invocando il metodo str della classe Mazzo su self.
Potrebbe sembrarti strano il fatto di usare self, che si riferisce alla mano cor-rente, con un metodo appartenente alla classe Mazzo: ricorda che Mano `e un tipo di Mazzo. Gli oggetti Mano possono fare qualsiasi cosa di cui `e capace Mazzo e cos`ı `e legale invocare un metodo Mazzo con la mano self.
In genere `e sempre legale usare un’istanza di una sottoclasse invece di un’istanza della classe genitore.
16.5 La classe GiocoDiCarte
La classe GiocoDiCarte si occupa delle operazioni comuni in tutti i giochi di carte, quali possono essere la creazione del mazzo ed il mescolamento delle sue carte:
class GiocoDiCarte: def __init__(self):
self.Mazzo = Mazzo() self.Mazzo.Mescola()
In questo primo caso abbiamo visto come il metodo di inizializzazione non si limiti ad assegnare dei valori agli attributi, ma esegua una elaborazione significativa.
Per implementare dei giochi specifici possiamo successivamente ereditare da GiocoDiCarte e aggiungere a questa classe le caratteristiche del nuovo gioco. Per fare un esempio scriveremo una simulazione di Old Maid.
16.6 Classe ManoOldMaid 153
L’obiettivo di Old Maid `e quello di riuscire a sbarazzarsi di tutte le carte che si hanno in mano. Questo viene fatto eliminando coppie di carte che hanno lo stesso rango e colore: il 4 di fiori viene eliminato con il 4 di picche perch´e entrambi i segni sono neri; il jack di cuori con il jack di quadri perch´e entrambi sono rossi.
Per iniziare il gioco la Regina di Fiori `e tolta dal mazzo per fare in modo che la Regina di Picche non possa essere eliminata durante la partita. Le 51 carte sono poi tutte distribuite una alla volta in senso orario ai giocatori e dopo la distribuzione tutti i giocatori scartano immediatamente quante pi`u carte possibili eliminando le coppie presenti nella mano appena distribuita.
Quando non si possono pi`u scartare carte il gioco ha inizio. A turno ogni giocatore pesca senza guardarla una carta dal giocatore che, in senso orario, ha ancora delle carte in mano. Se la carta scelta elimina una carta in mano la coppia viene rimossa. In caso contrario la carta scelta rimane in mano.
Alla fine della partita tutte le eliminazioni saranno state fatte ed il perdente `e chi rimane con la Regina di Picche in mano.
Nella nostra simulazione del gioco il computer giocher`a tutte le mani. Sfortuna-tamente alcune sottigliezze del gioco verranno perse: nel gioco reale chi si trova in mano la Regina di Picche far`a di tutto per fare in modo che questa venga scelta da un vicino, disponendola in modo da facilitare un successo in tal senso. Il computer invece sceglier`a le carte completamente a caso.
16.6 Classe ManoOldMaid
Una mano per giocare a Old Maid richiede alcune capacit`a che vanno oltre rispetto a quelle fornite da Mano. Sar`a opportuno quindi definire una nuova classe ManoOldMaid, che erediter`a i metodi da Mano e a questi metodi ne verr`a aggiunto uno (RimuoveCoppie) per rimuovere le coppie di carte:
class ManoOldMaid(Mano): def RimuoveCoppie(self):
Conteggio = 0
CarteOriginali = self.Carte[:] for CartaOrig in CarteOriginali:
CartaDaCercare = Carta(3-CartaOrig.Seme, CartaOrig.Rango) if CartaDaCercare in self.Carte:
self.Carte.remove(CartaOrig) self.Carte.remove(CartaDaCercare) print "Mano di %s : %s elimina %s" %
(self.Nome,CartaOrig,CartaDaCercare) Conteggio = Conteggio + 1
return Conteggio
Iniziamo facendo una copia della lista di carte, cos`ı da poter attraversare la copia finch´e non rimuoviamo l’originale: dato che self.Carte viene modificata
durante l’attraversamento, non possiamo di certo usarla per controllare tutti i suoi elementi. Python potrebbe essere confuso dal fatto di veder cambiare la lista che sta attraversando!
Per ogni carta della mano andiamo a controllare se quella che la elimina `e presente nella stessa mano. La carta “eliminante” ha lo stesso rango e l’altro seme dello stesso colore di quella “eliminabile”: l’espressione 3-Carta.Seme serve proprio a trasformare una carta di Fiori (seme 0) in Picche (seme 3) e viceversa; una carta di Quadri (seme 1) in Cuori (seme 2) e viceversa.
Se entrambe le carte sono presenti sono rimosse con RimuoveCoppie:
>>> Partita = GiocoDiCarte() >>> Mano1 = ManoOldMaid("Franco") >>> Partita.Mazzo.Mescola([Mano1], 13) >>> print Mano1
La mano di Franco contiene queste carte: Asso di Picche 2 di Quadri 7 di Picche 8 di Fiori 6 di Cuori 8 di Picche 7 di Fiori Regina di Fiori 7 di Quadri 5 di Fiori Jack di Quadri 10 di Quadri 10 di Cuori >>> Mano1.RimuoveCoppie()
Mano di Franco: 7 di Picche elimina 7 di Fiori Mano di Franco: 8 di Picche elimina 8 di Fiori Mano di Franco: 10 di Quadri elimina 10 di Cuori >>> print Mano1
La mano di Franco contiene queste carte: Asso di Picche 2 di Quadri 6 di Cuori Regina di Fiori 7 di Quadri 5 di Fiori Jack di Quadri
Nota che non c’`e un metodo di inizializzazione init per la classe ManoOldMaiddato che l’abbiamo ereditato da Mano.
16.7 Classe GiocoOldMaid 155
16.7 Classe GiocoOldMaid
Ora possiamo dedicarci al gioco vero e proprio: GiocoOldMaid `e una sottoclasse di GiocoDiCarte con un metodo Giocatori che prende una lista di giocatori come parametro.
Dato che init `e ereditato da GiocoDiCarte un nuovo oggetto GiocoOldMaid contiene un mazzo gi`a mescolato:
class GiocoOldMaid(GiocoDiCarte): def Partita(self, Nomi):
# rimozione della regina di fiori self.Mazzo.RimuoviCarta(Carta(0,12)) # creazione di una mano per ogni giocatore self.Mani = []
for Nome in Nomi:
self.Mani.append(ManoOldMaid(Nome)) # distribuzione delle carte
self.Mazzo.Distribuisci(self.Mani)
print "--- Le carte sono state distribuite" self.StampaMani()
# toglie le coppie iniziali
NumCoppie = self.RimuoveTutteLeCoppie()
print "--- Coppie scartate, inizia la partita" self.StampaMani()
# gioca finche’ non sono state fatte 25 coppie Turno = 0
NumMani = len(self.Mani) while NumCoppie < 25:
NumCoppie = NumCoppie + self.GiocaUnTurno(Turno) Turno = (Turno + 1) % NumMani
print "--- La partita e’ finita" self.StampaMani()
Alcuni dei passi della partita sono stati separati in metodi singoli per ragioni di chiarezza anche se dal punto di vista del programma questo non era strettamente necessario.
RimuoveTutteLeCoppieattraversa la lista di mani e invoca RimuoveCoppie su ognuna:
class GiocoOldMaid(GiocoDiCarte): ...
Conteggio = 0
for Mano in self.Mani:
Conteggio = Conteggio + Mano.RimuoveCoppie() return Conteggio
Esercizio: scrivi StampaMani che attraversa self.Mani e stampa ciascuna mano.
Conteggio `e un accumulatore che tiene traccia del numero di coppie rimosse dall’inizio della partita: quando il numero totale di coppie raggiunge 25 sono state rimosse dalle mani esattamente 50 carte, e ci`o significa che `e rimasta solo una carta (la Regina di Picche) ed il gioco `e finito.
La variabile Turno tiene traccia di quale giocatore debba giocare. Parte da 0 e viene incrementata di 1 ad ogni mano. Quando arriva a NumMani l’operatore modulo % la riporta a 0.
Il metodo GiocaUnTurno prende un parametro dal giocatore che sta giocando. Il valore ritornato `e il numero di coppie rimosse durante il turno:
class GiocoOldMaid(GiocoDiCarte): ...
def GiocaUnTurno(self, Giocatore): if self.Mani[Giocatore].EVuoto():
return 0
Vicino = self.TrovaVicino(Giocatore)
CartaScelta = self.Mani[Vicino].PrimaCarta() self.Mani[Giocatore].AggiungeCarta(CartaScelta) print "Mano di", self.Mani[Giocatore].Nome, \
": scelta", CartaScelta
Conteggio = self.Mani[Giocatore].RimuoveCoppie() self.Mani[Giocatore].Mescola()
return Conteggio
Se la mano di un giocatore `e vuota quel giocatore `e fuori dal gioco e non fa nulla. Il valore di ritorno in questo caso `e 0.
In caso contrario un turno consiste nel trovare il primo giocatore in senso orario che abbia delle carte in mano, prendergli una carta e cercare coppie da rimuovere dopo avere aggiunto la carta scelta alla mano. Prima di tornare le carte in mano devono essere mescolate cos`ı che la scelta del prossimo giocatore sia ancora una volta casuale.
Il metodo TrovaVicino inizia con il giocatore all’immediata sinistra e continua in senso orario finch´e non trova qualcuno che ha ancora carte in mano:
class GiocoOldMaid(GiocoDiCarte): ...
def TrovaVicino(self, Giocatore): NumMani = len(self.Mani)
for Prossimo in range(1,NumMani):
16.7 Classe GiocoOldMaid 157
if not self.Mani[Vicino].EVuoto(): return Vicino
Se TrovaVicino dovesse effettuare un giro completo dei giocatori senza trovare qualcuno con delle carte in mano tornerebbe None e causerebbe un errore da qualche parte del programma. Fortunatamente possiamo provare che questo non succeder`a mai, sempre che la condizione di fine partita sia riconosciuta correttamente.
Abbiamo omesso il metodo StampaMani dato che puoi scriverlo tu senza proble-mi.
La stampa che mostriamo in seguito mostra una partita effettuata usando le sole quindici carte di valore pi`u elevato (i 10, i jack, le regine ed i re), ed `e stata ridotta per questioni di spazio. La partita ha visto come protagonisti tre giocatori: Allen, Jeff e Chris. Con un mazzo cos`ı piccolo il gioco si ferma dopo aver rimosso 7 coppie invece delle consuete 25.
>>> import Carte
>>> Gioco = Carte.GiocoOldMaid()
>>> Gioco.Partita(["Allen","Jeff","Chris"]) --- Le carte sono state distribuite La mano di Allen contiene queste carte: Re di Cuori
Jack di Fiori Regina di Picche
Re di Picche 10 di Quadri
La mano di Jeff contiene queste carte: Regina di Cuori
Jack di Picche Jack di Cuori Re di Quadri
Regina di Quadri
La mano di Chris contiene queste carte: Jack di Quadri
Re di Fiori 10 di Picche
10 di Cuori 10 di Fiori
Mano di Jeff: Regina di Cuori elimina Regina di Quadri Mano di Chris: 10 di Picche elimina 10 di Fiori
--- Coppie scartate, inizia la partita La mano di Allen contiene queste carte: Re di Cuori
Jack di Fiori Regina di Picche
10 di Quadri
La mano di Jeff contiene queste carte: Jack di Picche
Jack di Cuori Re di Quadri
La mano di Chris contiene queste carte: Jack di Quadri
Re di Fiori 10 di Cuori
Mano di Allen: scelta Re di Quadri
Mano di Allen: Re di Cuori elimina Re di Quadri Mano di Jeff: scelta 10 di Cuori
Mano di Chris: scelta Jack di Fiori Mano di Allen: scelta Jack di Cuori Mano di Jeff: scelta Jack di Quadri Mano di Chris: scelta Regina di Picche Mano di Allen: scelta Jack di Quadri
Mano di Allen: Jack di Cuori elimina Jack di Quadri Mano di Jeff: scelta Re di Fiori
Mano di Chris: scelta Re di Picche Mano di Allen: scelta 10 di Cuori
Mano di Allen: 10 di Quadri elimina 10 di Cuori Mano di Jeff: scelta Regina di Picche
Mano di Chris: scelta Jack di Picche
Mano di Chris: Jack di Fiori elimina Jack di Picche Mano di Jeff: scelta Re di Picche
Mano di Jeff: Re di Fiori elimina Re di Picche --- La partita e’ finita
La mano di Allen e’ vuota
La mano di Jack contiene queste carte: Regina di Picche
La mano di Chris e’ vuota
Cos`ı Jeff ha perso.