Cesar Systems

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

hora podemos poner nuestra atención en el juego en sí mismo. JuegoDeLaMona es una subclase de JuegoDeCartas con un metodo nuevo denominado jugar que toma una lista de jugadores como parámetro.

Como el metodo __init__ se hereda de JuegoDeCartas, el nuevo objeto JuegoDeLaMona contiene un mazo recientemente mezclado:

Aclass JuegoDeLaMona(JuegoDeCartas):
    def jugar(self, nombres):
        # quitamos la Reina de Treboles
        self.mazo.eliminaCarta(Carta(0,12))
        # construimos una mano para cada jugador
        self.manos = []
        for nombre in nombres :
            self.manos.append(ManoDeLaMona(nombre))
            # repartimos los naipes
            self.mazo.repartir(self.manos)
            print "----- Se han repartido las cartas."
        self.muestraManos()
        # eliminamos las coincidencias iniciales
        emparejadas = self.eliminaTodasLasCoincidencias()
        print "----- Coincidencias eliminadas, el juego comienza."
        self.muestraManos()
        # se juega hasta que se han descartado las 50 cartas
        turno = 0
        cantManos = len(self.manos)
        while emparejadas < 25:
            emparejadas = emparejadas + self.jugarUnTurno(turno)
            turno = (turno + 1) % cantManos
        print "----- El juego termino."
        self.muestraManos()

Algunos de los pasos que componen el juego se han colocado en métodos separados. eliminaTodasLasCoincidencias recorre la lista de manos y llama a eliminaCoincidencias para cada una de ellas:

class JuegoDeLaMona(JuegoDeCartas):
    ...
    def eliminaTodasLasCoincidencias(self):
        cant = 0
        for mano in self.manos:
            cant = cant + mano.eliminaCoincidencias()
        return cant

Como ejercicio, escriba muestraManos, el cual recorre self.manos y muestra cada mano.

cant es un acumulador que va sumando la cantidad de concordancias en cada mano y devuelve el total.

Cuando la cantidad total de coincidencias alcanza a las veinticinco significa que se han eliminado cincuenta cartas de las manos, lo que es lo mismo que decir que solo queda una carta y el juego ha terminado.

La variable turno recuerda el turno de cual jugador se esta jugando. Comienza en cero y se incrementa en uno cada vez; cuando alcanza el valor cantManos, el operador de modulo lo hace volver a cero.

El metodo jugarUnTurno toma un parámetro que indica de quien es el turno. El valor de retorno es la cantidad de concordancias que se han realizado durante ese turno:

class JuegoDeLaMona(JuegoDeCartas):
...
    def jugarUnTurno(self, i):
        if self.manos[i].estaVacio():
            return 0
        vecino = self.encuentraVecino(i)
        cartaElegida = self.manos[vecino].darCarta()
        self.manos[i].agregaCarta(cartaElegida)
        print "Mano", self.manos[i].nombre, "eligi¶o", cartaElegida
        cant = self.manos[i].eliminaCoincidencias()
        self.manos[i].mezclar()
        return cant

Si la mano de un jugador esta vacía, el jugador salió del juego, así que no hace nada y devuelve 0.

Si no, un turno consiste en encontrar el primer jugador a la izquierda que aun tiene cartas, tomar una carta de las que posee, y controlar si hay concordancias.

Antes de volver se mezclan las cartas de la mano, de tal manera que la selección del siguiente jugador sea al azar.

El metodo encuentraVecino comienza con el jugador que esta inmediatamente a la izquierda y continua alrededor del círculo hasta que encuentra un jugador que aun tiene cartas.

class JuegoDeLaMona(JuegoDeCartas):
    ...
    def encuentraVecino(self, i):
        cantManos = len(self.manos)
        for proximo in range(1,cantManos):
            vecino = (i + proximo) % cantManos
            if not self.manos[vecino].estaVacio():
                return vecino

Si por cualquier motivo encuentraVecino llegara a dar la vuelta completa al círculo sin encontrar cartas, devolvería None y eso causaría un error en alguna otra parte del programa.

Afortunadamente podemos probar que eso no va a suceder nunca (siempre y cuando se detecte correctamente el final del juego).

Hemos omitido el metodo muestraManos. Ese puede escribirlo usted mismo.

La siguiente salida proviene de una forma reducida del juego, en la cual solamente se reparten las quince cartas mas altas(desde los dieces hacia arriba) a tres jugadores. Con este mazo mas pequeño, el juego termina tras siete coincidencias, en lugar de veinticinco.

>>> import cartas
>>> juego = cartas.JuegoDeLaMona()
>>> juego.jugar(["Allen","Jeff","Chris"])
----- Se han repartido las cartas.
Mano Allen contiene
Rey de Corazones
Sota de Treboles
Reina de Picas
Rey de Picas
10 de Diamantes
Mano Jeff contiene
Reina de Corazones
Sota de Picas
Sota de Corazones
Rey de Diamantes
Reina de Diamantes
Mano Chris contiene
Sota de Diamantes
Rey de Treboles
10 de Picas
10 de Corazones
10 de Treboles
Mano Jeff: Reina de Corazones con Reina de Diamantes
Mano Chris: 10 de Picas con 10 de Treboles
----- Se eliminaron las coincidencias, el juego comienza.
Mano Allen contiene
Rey de Corazones
Sota de Treboles
Reina de Picas
Rey de Picas
10 de Diamantes
Mano Jeff contiene
Sota de Picas
Sota de Corazones
Rey de Diamantes
Mano Chris contiene
Sota de Diamantes
Rey de Treboles
10 de Corazones
Mano Allen: eligio Rey de Diamantes
Mano Allen: Rey de Corazones con Rey de Diamantes
Mano Jeff: eligio 10 de Corazones
Mano Chris: eligio Sota de Treboles
Mano Allen: eligio Sota de Corazones
Mano Jeff: eligio Sota de Diamantes
Mano Chris: eligio Reina de Picas
Mano Allen: eligio Sota de Diamantes
Mano Allen: Sota de Corazones con Sota de Diamantes
Mano Jeff: eligio Rey de Treboles
Mano Chris: eligio Rey de Picas
Mano Allen: eligio 10 de Corazones
Mano Allen: 10 de Diamantes con 10 de Corazones
Mano Jeff: eligio Reina de Picas
Mano Chris: eligio Sota de Picas
Mano Chris: Sota de Treboles con Sota de Picas
Mano Jeff: eligio Rey de Picas
Mano Jeff: Rey de Treboles con Rey de Picas
----- El juego termino.
La mano de Allen esta vac³a.
La mano de Jeff contiene
Reina de Picas
La mano de Chris esta vac³a.
As³ que Je® es quien perdio.

16.8. Glosario

herencia: La capacidad de definir una nueva clase que es una versión modificada de una clase previamente definida.

clase padre: Aquella clase de la cual la clase hija hereda.

clase hija: Una nueva clase creada heredando de una clase existente también se la llama “subclase”.

Capítulo 17

Listas enlazadas

17.1. Referencias incrustadas

Hemos visto ejemplos de atributos que hacen referencia a otros objetos, a los que llamamos referencias incrustadas (véase la Sección 12.8). Una estructura de datos común, la lista enlazada, saca partido de esta característica.

Las listas enlazadas se componen de nodos, donde cada nodo contiene una referencia al próximo nodo de la lista. Además, cada nodo contiene una unidad de datos llamada carga.

Podemos considerar una lista enlazada como una estructura de datos recursiva porque tiene una definición recursiva.

Una lista enlazada puede ser:

la lista vacía, representada por None, o bien un nodo que contiene un objeto de carga y una referencia a una lista enlazada.

Las estructuras recursivas de datos nos llevan a métodos recursivos.

17.2. La clase Nodo

Como es habitual cuando se escribe una clase, comenzaremos con los métodos de inicialización y __str__ , para poder comprobar el mecanismo básico de crear y mostrar el nuevo tipo:

class Nodo:
    def __init__(self, carga=None, siguiente=None):
        self.carga = carga
        self.siguiente = siguiente
    def __str__(self):
        return str(self.carga)

Como es habitual, los parámetros para el metodo de inicialización son opcionales. Por defecto, la carga y el enlace, siguiente, se ponen a None.

La representación alfanumérica de un nodo es únicamente la de la carga. Como se puede pasar cualquier valor a la función str, podemos guardar cualquier valor en una lista.

Para comprobar la implementación en este punto, podemos crear un Nodo e imprimirlo:

>>> nodo = Nodo("prueba")
>>> print nodo
prueba

Para hacerlo más interesante, necesitaremos una lista que contenga más de un nodo:

>>> nodo1 = Nodo(1)
>>> nodo2 = Nodo(2)
>>> nodo3 = Nodo(3)

Este código crea tres nodos, pero aun no tenemos una lista porque los nodos todavía no están enlazados. El diagrama de estados tiene el siguiente aspecto:

Para enlazar los nodos, debemos hacer que el primer nodo haga referencia al segundo, y que este haga referencia al tercero:

   1: >>> nodo1.siguiente = nodo2
   2: >>> nodo2.siguiente = nodo3

La referencia del tercer nodo será None, que indica que es el final de la lista.

Ahora el diagrama de estados tendrá el siguiente aspecto:

Ahora ya sabe como crear nodos y enlazarlos en listas. Lo que podría estar menos claro es por que.

17.3. Listas como colecciones