Mes: agosto 2012 Página 16 de 22

Otro metodo que podría ser útil para la clase Mazo es eliminaCarta, que toma un naipe como parámetro, lo elimina, y retorna verdadero (1) si el naipe estaba en el mazo, y falso (0) si no estaba:

class Mazo:
    ...
    def eliminaCarta(self, carta):
        if carta in self.cartas:
            self.cartas.remove(carta)
            return 1
        else:
            return 0

El operador in retorna verdadero si el primer operando esta en el segundo, el cual debe ser una lista o tupla. Si el primer operando es un objeto, Python usa el metodo __cmp__ del objeto para determinar la igualdad entre los elementos de la lista. Como el __cmp__ en la clase Carta verifica la igualdad en profundidad, el metodo eliminaCarta también verifica igualdad en profundidad.

Para repartir los naipes, queremos eliminar y devolver el naipe que ocupa la posición superior en el mazo. El metodo pop de las listas proporciona una manera conveniente de realizar esto:

class Mazo:
    ...
    def darCarta(self):
        return self.cartas.pop()

En realidad, pop elimina el ultimo naipe en la lista, así que en efecto estamos repartiendo desde el extremo inferior del mazo.
Otra operación mas que es muy probable necesitemos es la función booleana estaVacio, la cual devuelve verdadero si el mazo no contiene ningún naipe:

class Deck:
    ...
    def estaVacio(self):
        return (len(self.cartas) == 0)

15.9. Glosario

codificar: Representar un conjunto de valores utilizando otro conjunto de valores, entre los cuales se construye una correspondencia.

atributo de clase: Una variable que se define dentro de la definición de un clase pero fuera de cualquiera de sus métodos. Los atributos de clase son accesibles desde cualquier metodo de la clase y están compartidos por todas las instancias de la misma.

acumulador: Una variable que se usa en un bucle para acumular una serie de valores, por ejemplo concatenándolos dentro de una cadena de caracteres o adicionándolos a una suma.

Herencia

16.1. Herencia

La característica de un lenguaje que mas se asocia con la programación orientada a objetos es la herencia. La herencia es la capacidad de definir una nueva clase que es una versión modificada de otra ya existente.

La principal ventaja de esta característica es que se pueden agregar nuevos métodos a una clase sin modificar la clase existente. Se denomina “herencia” porque la nueva clase hereda todos los métodos de la clase existente. Si extendemos
esta metáfora, a la clase existente a veces se la denomina clase padre. La nueva clase puede denominarse clase hija, o también “subclase”.

La herencia es una característica poderosa. Ciertos programas que serían complicados sin herencia pueden escribirse de manera simple y concisa gracias a ella.

Además, la herencia puede facilitar la reutilización del código, pues se puede adaptar el comportamiento de la clase padre sin tener que modificarla. En algunos casos, la estructura de la herencia refleja la propia estructura del problema, Lo que hace que el programa sea mas fácil de comprender.

Por otro lado, la herencia pude hacer que los programas sean difíciles de leer.

Cuando se llama a un metodo, a veces no esta claro donde debe uno encontrar su definición. El código relevante puede estar diseminado por varios módulos.

Además, muchas de las cosas que se hacen mediante el uso de la herencia, se pueden lograr de forma igualmente (incluso mas) elegante sin ella. Si la estructura general del problema no nos gu³a hacia la herencia, dicho estilo de programación
puede hacer mas mal que bien.

16.2. Una mano de cartas

Para casi cualquier juego de naipes, necesitamos representar una mano de cartas.

Una mano es similar a un mazo, por supuesto. Ambos están compuestos de un conjunto de naipes, y ambos requieren de operaciones tales como agregar y eliminar una carta. Además, necesitaremos la capacidad de mezclar tanto un
mazo como una mano de cartas.

Una mano es diferente de un mazo en ciertos aspectos. Según el juego al que se este jugando, podemos querer realizar ciertas operaciones sobre una mano que no tienen sentido sobre un mazo. Por ejemplo, en el póker queremos clasificar una mano (straight (consecutiva), flush (de un solo palo), etc.) y compararla con otra. En bridge necesitaremos calcular el puntaje para la mano para as³ poder hacer la subasta.

Esta situación sugiere el uso de la herencia. Si Mano es una subclase de Mazo, entonces tendrá todos los métodos de Mazo y le podremos agregar otros métodos nuevos.

En la definición de clase, el nombre de la clase padre aparece entre paréntesis:

   1: class Mano(Mazo):
   2:     pass

Esta sentencia indica que la nueva clase Mano hereda de la clase existente Mazo.

El constructor de Mano inicializa los atributos para la mano, que son nombre y cartas. La cadena de caracteres nombre identifica a esta mano, probablemente mediante el nombre del jugador que la sostiene. El nombre es un parámetro opcional con un valor por omisión de cadena vacía. cartas es la lista de cartas de la mano, inicializada como lista vacía.

class Mano(Mazo):
    def __init__(self, nombre=""):
        self.cartas = []
        self.nombre = nombre

Casi para cualquier juego de naipes, es necesario agregar y quitar cartas del mazo. La eliminación de cartas ya ha sido resuelta, pues Mano hereda eliminaCarta de Mazo. Pero deberemos escribir agregaCarta:

lass Mano(Mazo):
    ...
    def agregaCarta(self,carta) :
    self.cartas.append(carta)

De nuevo, los puntos suspensivos indican que hemos omitido los otros métodos.

El metodo de lista append agrega la nueva carta al final de la lista de cartas.

16.3. El reparto de los naipes

Ahora que ya tenemos la clase Mano, queremos repartir las cartas del Mazo en manos. No es claramente obvio si este metodo debe ir en la clase Mano o en la clase Mazo, pero como opera sobre un mazo único y (posiblemente) sobre varias manos, es mas natural ponerlo en el Mazo. repartir debe ser bastante general, pues los diferentes juegos tienen distintos requerimientos.

Puede que necesitemos repartir todo el mazo de una vez, o que agreguemos una carta a cada mano.
Repartir toma dos parámetros, una lista (o tupla) de manos y la cantidad total de naipes a repartir. Si no hay suficientes cartas en el mazo, el metodo reparte todas las cartas y se detiene:

class Mazo :
    ...
    def repartir(self, manos, nCartas=999):
    nManos = len(manos)
        for i in range(nCartas):
        if self.estaVacio(): break # fin si se acaban las cartas
        carta = self.darCarta() # da la carta superior
        mano = manos[i % nManos] # a qui¶en le toca?
        mano.agregaCarta(carta) # agrega la carta a la mano

El segundo parámetro, nCartas es opcional; el valor por omisión es un numero muy grande, lo cual es lo mismo que decir que se repartirán todos los naipes del mazo.

La variable de bucle i va desde 0 hasta nCartas-1. A cada paso a través del bucle, se elimina una carta del mazo mediante el metodo de lista pop, que quita y devuelve el ultimo elemento de la lista.

El operador modulo ( %) permite que podamos repartir las cartas de una en una (una carta cada vez para cada mano). Cuando i es igual a la cantidad de manos en la lista, la expresión i % nManos salta hacia el comienzo de la lista (el índice
es 0).

16.4. Mostremos la mano

Para mostrar el contenido de una mano, podemos sacar partido de la existencia de los métodos muestraMazo y __str__ que se heredan de Mazo. Por ejemplo:

>>> mazo = Mazo()
>>> mazo.mezclar()
>>> mano = Mano("hugo")
>>> mazo.repartir([mano], 5)
>>> print mano
La mano de hugo contiene
2 de Picas
3 de Picas
4 de Picas
As de Corazones
9 de Treboles

No es una gran mano, pero tiene lo necesario como para disponer de una escalera de color.

Aunque es conveniente usar la herencia de los métodos existentes, existe información adicional en una Mano que desearíamos mostrar al imprimirla. Para ello, podemos proporcionar a la clase Mano un metodo str que reemplace al de
la clase Mazo:

class Mano(Mazo)
    ...
    def __str__(self):
        s = "La mano de " + self.nombre
        if self.estaVacio():
            s = s + " est¶a vac¶³an"
        else:
            s = s + " contienen"
        return s + Mazo.__str__(self)

Al principio s es una cadena de caracteres que identifica a la mano. Si la mano esta vacía, el programa agrega las palabras esta vacía y devuelve s.

En caso contrario, el programa agrega la palabra contiene y la representación como cadena de caracteres del Mazo, que se obtiene llamando al metodo __str__ de la clase Mazo sobre la instancia self.

Puede parecer extra~no que enviemos a self, que se requiere a la Mano actual, como argumento de un metodo de la clase Mazo, hasta que nos damos cuenta de que una Mano es un tipo de Mazo. Los objetos Mano pueden hacer cualquier cosa que pueda hacer un objeto Mazo, y por ello es legal que pasemos una Mano a un metodo de Mazo.

En general, siempre es legal usar una instancia de una subclase en el lugar de una instancia de una clase padre.

16.5. La clase JuegoDeCartas

La clase JuegoDeCartas asume la responsabilidad sobre algunas obligaciones básicas comunes a todos los juegos, tales como la creación del mazo y la mezcla de los naipes:

class JuegoDeCartas:
    def __init__(self):
        self.mazo = Mazo()
        self.mazo.mezclar()

Esta es la primera vez que vemos que un metodo de inicialización realiza una actividad computacional significativa, mas allá de la inicialización de atributos.

Para implementar juegos específicos, debemos heredar de JuegoDeCartas y agregar las características del nuevo juego.

Como ejemplo, escribiremos una simulación para La Mona.

La meta de La Mona es desembarazarse de las cartas que uno tiene en la mano.

Uno se saca las cartas de encima emparejándolas por valor y color. Por ejemplo, el 4 de Tréboles se empareja con el 4 de

Picas porque ambos palos son negros.

La Sota de Corazones se empareja con la Sota de Diamantes porque ambos son rojos.

Para iniciar el juego, se elimina la Reina de Tréboles del mazo, de manera que la Reina de Picas no tiene con quien emparejarse. Las cincuenta y una cartas restantes se reparten entre los jugadores, de una en una. Luego del reparto, todos los jugadores emparejan y descartan tantas cartas como sea posible.

Cuando no se pueden realizar mas concordancias, el juego comienza. Por turnos, cada jugador toma una carta (sin mirarla) del vecino mas cercano de la izquierda que aun tiene cartas. Si la carta elegida concuerda con una de la mano del
jugador, se elimina dicho par. Si no, la carta se agrega a la mano del jugador.

Llega el momento en el que se realizan todas las concordancias posibles, con lo que queda solo la Reina de Picas en la mano del perdedor.

En nuestra simulación informática del juego, la computadora juega todas las

manos. Desafortunadamente, se pierden algunos de los matices del juego real.

En una partida real, el jugador que tiene la Mona realiza ciertos esfuerzos para que su vecino la tome, por ejemplo mostrándola prominentemente o al contrario, errando al intentar mostrarla abiertamente, o incluso puede fallar al tratar de errar en su intento de mostrarla prominentemente. La computadora simplemente toma una carta al azar de su vecino.

16.6. La clase ManoDeLaMona

Una mano para jugar a La Mona requiere ciertas capacidades que están mas allá de las que posee una Mano. Definiremos una nueva clase ManoDeLaMona, que hereda de Mano y nos proporciona un metodo adicional denominado eliminaCoincidencias:

class ManoDeLaMona(Mano):
    def eliminaCoincidencias(self):
        cant = 0
        cartasOriginales = self.cartas[:]
        for carta in cartasOriginales:
            empareja = Carta(3 - carta.palo, carta.valor)
            if empareja in self.cartas:
                self.cartas.remove(carta)
                self.cartas.remove(empareja)
                print "Mano %s: %s con %s" % (self.nombre,carta,empareja)
                cant = cant + 1
        return cant

Comenzamos por hacer una copia de la lista de las cartas, de tal manera que podamos recorrer la copia mientras vamos quitando cartas de la lista original.

Como self.cartas se modifica en el bucle, no vamos a querer usarla para controlar el recorrido. ¡Python puede quedar realmente confundido si se recorre una lista que esta cambiando!

Para cada carta de la mano, averiguamos cual es la carta que concordara con ella y la buscamos. La carta que concuerda tiene el mismo valor y el otro palo del mismo color. La expresión 3 – carta.palo transforma un Trébol (palo 0) en una Pica (palo 3) y un Diamante (palo 1) en un Corazón (palo 2). Verifique por su cuenta que las operaciones opuestas también funcionan. Si la carta que concuerda esta en la mano, ambas se eliminan.

El siguiente ejemplo demuestra el uso de eliminaCoincidencias:

>>> print mano
La mano de hugo contiene
As de Picas
2 de Diamantes
7 de Picas
8 de Treboles
6 de Corazones
8 de Picas
7 de Treboles
Raina de Treboles
7 de Diamantes
5 de Treboles
Sota de Diamantes
10 de Diamantes
10 de Corazones
>>> mano.eliminaCoincidencias()
Mano hugo: 7 de Picas con 7 de Treboles
Mano hugo: 8 de Picas con 8 de Treboles
Mano hugo: 10 de Diamantes con 10 de Corazones

Debe usted notar que no existe un metodo __init__ para la clase ManoDeLaMona.

Lo heredamos de Mano.

16.7. La clase JuegoDeLaMona