Herramientas Informaticas

Categoría: Cursos de programación Python Página 5 de 6

B.6. Glosario

Máximo común divisor (MCD): El mayor entero positivo que divide al numerador y al denominador de una fracción sin que quede un resto.
Reducir: Cambiar la fracción a su forma equivalente con un MCD igual a 1.
Negación unitaria: Operación que computa el elemento simétrico aditivo, normalmente denotada con un signo menos delante. Se denomina unitaria” en contraste con la operación binaria menos, que es la resta.

C.1. Clase Punto Python

   1: class Punto:
   2:     def __init__(self, x=0, y=0):
   3:         self.x = x
   4:         self.y = y
   5:         def __str__(self):
   6:         return '(' + str(self.x) + ', ' + str(self.y) + ')'
   7:     def __add__(self, otro):
   8:         return Punto(self.x + otro.x, self.y + otro.y)
   9:     def __sub__(self, otro):
  10:         return Punto(self.x - otro.x, self.y - otro.y)
  11:     def __mul__(self, otro):
  12:         return self.x * otro.x + self.y * otro.y
  13:     def __rmul__(self, otro):
  14:         return Punto(otro * self.x, otro * self.y)
  15:     def reverse(self):
  16:         self.x, self.y = self.y, self.x
  17:     def delDerechoYDelReves(derecho):
  18:         from copy import copy
  19:         reves = copy(derecho)
  20:         reves.reverse()
  21:         print str(derecho) + str(reves)

DESCARGAR CODIGO FUENTE

C.2. Clase Hora Python

   1: class Hora:
   2:     def __init__(self, horas=0, minutos=0, segundos=0):
   3:         self.horas = horas
   4:         self.minutos = minutos
   5:         self.segundos = segundos
   6:     def __str__(self):
   7:         return str(self.horas) + ":" + str(self.minutos) 
   8:         + ":" + str(self.segundos)
   9:     def convierteASegundos(self):
  10:         minutos = self.horas * 60 + self.minutos
  11:         segundos = self.minutos * 60 + self.segundos
  12:         return segundos
  13:     def incrementa(self, segs):
  14:         segs = segs + self.segundos
  15:         self.horas = self.horas + segs/3600
  16:         segs = segs % 3600
  17:         self.minutos = self.minutos + segs/60
  18:         segs = segs % 60
  19:         self.segundos = segs
  20:     def haceHora(segs):
  21:         hora = Hora()
  22:         hora.horas = segs/3600
  23:         segs = segs - hora.horas * 3600
  24:         hora.minutos = segs/60
  25:         segs = segs - hora.minutos * 60
  26:         hora.segundos = segs
  27:         return hora

DESCARGAR CODIGO FUENTE

C.3. Cartas, mazos y juegos Python

   1: import random
   2: class Carta:
   3:     listaDePalos = ["Tr¶eboles", "Diamantes", "Corazones",
   4:     "Picas"]
   5:     listaDeValores = ["nada", "As", "2", "3", "4", "5", "6", "7",
   6:     "8", "9", "10", "Sota", "Reina", "Rey"]
   7:     
   8:     def __init__(self, palo=0, valor=0):
   9:         self.palo = palo
  10:         self.valor = valor
  11:     def __str__(self):
  12:         return (self.listaDeValores[self.valor] + " de " +
  13:         self.listaDePalos[self.palo])
  14:     def __cmp__(self, otro):
  15:         # controlar el palo
  16:         if self.palo > otro.palo: return 1
  17:         if self.palo < otro.palo: return -1
  18:         # si son del mismo palo, controlar el valor
  19:         if self.valor > otro.valor: return 1
  20:         if self.valor < otro.valor: return -1
  21:         # los valores son iguales, es un empate
  22:         return 0
  23:  
  24: class Mazo:
  25:     def __init__(self):
  26:         self.cartas = []
  27:         for palo in range(4):
  28:             for valor in range(1, 14):
  29:                 self.cartas.append(Carta(palo, valor))
  30:  
  31:     def muestraMazo(self):
  32:         for carta in self.cartas:
  33:             print carta
  34:     def __str__(self):
  35:         s = ""
  36:         for i in range(len(self.cartas)):
  37:             s = s + " "*i + str(self.cartas[i]) + "n"
  38:             return s
  39:     def mezclar(self):
  40:         import random
  41:         nCartas = len(self.cartas)
  42:         for i in range(nCartas):
  43:         j = random.randrange(i, nCartas)
  44:         self.cartas[i], self.cartas[j] =
  45:         self.cartas[j], self.cartas[i]
  46:     def eliminaCarta(self, carta):
  47:         if carta in self.cartas:
  48:             self.cartas.remove(carta)
  49:             return 1
  50:         else: return 0
  51:     def darCarta(self):
  52:         return self.cartas.pop()
  53:     def estaVacio(self):
  54:         return (len(self.cartas) == 0)
  55:     def repartir(self, manos, nCartas=999):
  56:         nManos = len(manos)
  57:         for i in range(nCartas):
  58:         if self.estaVacio(): break # fin si se acaban las cartas
  59:             carta = self.darCarta() # da la carta superior
  60:             mano = manos[i % nManos] # a qui¶en le toca?
  61:             mano.agregaCarta(carta) # agrega la carta a la mano
  62:  
  63: class Mano(Mazo):
  64:     def __init__(self, nombre=""):
  65:         self.cartas = []
  66:         self.nombre = nombre
  67:     def agregaCarta(self,carta) :
  68:         self.cartas.append(carta)
  69:     def __str__(self):
  70:         s = "La mano de " + self.nombre
  71:         if self.estaVacio():
  72:             s = s + " est¶a vac¶³an"
  73:         else:
  74:             s = s + " contienen"
  75:     return s + Mazo.__str__(self)
  76:  
  77: class JuegoDeCartas:
  78:     def __init__(self):
  79:         self.mazo = Mazo()
  80:         self.mazo.mezclar()
  81:  
  82: class ManoDeLaMona(Mano):
  83:     def eliminaCoincidencias(self):
  84:         cant = 0
  85:         cartasOriginales = self.cartas[:]
  86:         for carta in cartasOriginales:
  87:             empareja = Carta(3 - carta.palo, carta.valor)
  88:             if empareja in self.cartas:
  89:             self.cartas.remove(carta)
  90:             self.cartas.remove(empareja)
  91:             print "Mano %s: %s con %s" % (self.nombre,carta,empareja)
  92:             cant = cant + 1
  93:             return cant
  94:  
  95: class JuegoDeLaMona(JuegoDeCartas):
  96:     def jugar(self, nombres):
  97:     # quitamos la Reina de Tr¶eboles
  98:     self.mazo.eliminaCarta(Carta(0,12))
  99:         # construimos una mano para cada jugador
 100:     self.manos = []
 101:     for nombre in nombres :
 102:         self.manos.append(ManoDeLaMona(nombre))
 103:         # repartimos los naipes
 104:         self.mazo.repartir(self.manos)
 105:         print "----- Se han repartido las cartas."
 106:         self.muestraManos()
 107:         # eliminamos las coincidencias iniciales
 108:         emparejadas = self.eliminaTodasLasCoincidencias()
 109:         print "----- Coincidencias eliminadas, el juego comienza."
 110:         self.muestraManos()
 111:         # se juega hasta que se han descartado las 50 cartas
 112:         turno = 0
 113:         cantManos = len(self.manos)
 114:         while emparejadas < 25:
 115:         emparejadas = emparejadas + self.jugarUnTurno(turno)
 116:             turno = (turno + 1) % cantManos
 117:             print "----- El juego termin¶o."
 118:             self.muestraManos()
 119:     def eliminaTodasLasCoincidencias(self):
 120:     cant = 0
 121:     for mano in self.manos:
 122:         cant = cant + mano.eliminaCoincidencias()
 123:         return cant
 124:     def jugarUnTurno(self, i):
 125:     if self.manos[i].estaVacio():
 126:         return 0
 127:         vecino = self.encuentraVecino(i)
 128:     cartaElegida = self.manos[vecino].darCarta()
 129:     self.manos[i].agregaCarta(cartaElegida)
 130:     print "Mano", self.manos[i].nombre, "eligi¶o", cartaElegida
 131:     cant = self.manos[i].eliminaCoincidencias()
 132:     self.manos[i].mezclar()
 133:     return cant
 134:  
 135:     def encuentraVecino(self, i):
 136:     cantManos = len(self.manos)
 137:     for proximo in range(1,cantManos):
 138:         vecino = (i + proximo) % cantManos
 139:         if not self.manos[vecino].estaVacio():
 140:             return vecino
 141:     def muestraManos(self) :
 142:     for mano in self.manos :
 143:         print mano

DESCARGAR CODIGO FUENTE

C.4. Listas Enlazadas Python

   1: def imprimeLista(nodo):
   2:     while nodo:
   3:         print nodo,
   4:         nodo = nodo.siguiente
   5:         print
   6: def imprimeAlReves(lista):
   7:     if lista == None: return
   8:     cabeza = lista
   9:     cola = lista.siguiente
  10:     imprimeAlReves(cola)
  11:     print cabeza,
  12: def imprimeAlRevesBonito(lista) :
  13:     print "[",
  14:     if lista != None :
  15:         cabeza = lista
  16:         cola = lista.siguiente
  17:  
  18: imprimeAlReves(cola)
  19: print cabeza,
  20: print "]",
  21:  
  22: def eliminaSegundo(lista):
  23:     if lista == None: return
  24:         primero = lista
  25:         segundo = lista.siguiente
  26:         primero.siguiente = segundo.siguiente
  27:         segundo.siguiente = None
  28:         return segundo
  29:  
  30: class Nodo:
  31:     def __init__(self, carga=None, siguiente=None):
  32:         self.carga = carga
  33:         self.siguiente = siguiente
  34:  
  35:     def __str__(self):
  36:         return str(self.carga)
  37:  
  38:     def imprimeAlReves(self):
  39:         if self.siguiente != None:
  40:             cola = self.siguiente
  41:             cola.imprimeAlReves()
  42:             print self.carga,
  43:  
  44: class ListaEnlazada :
  45:     def __init__(self) :
  46:         self.longitud = 0
  47:         self.cabeza = None
  48:     def imprimeAlReves(self):
  49:         print "[",
  50:         if self.cabeza != None:
  51:         self.cabeza.imprimeAlReves()
  52:         print "]",
  53:     def agregaPrimero(self, carga):
  54:         nodo = Nodo(carga)
  55:         nodo.siguiente = self.cabeza
  56:         self.cabeza = nodo
  57:         self.longitud = self.longitud + 1 

C.5. Clase Pila Python

   1: class Pila : # implem. con listas de Python
   2:     def __init__(self) :
   3:         self.elementos = []
   4:     def push(self, elemento) :
   5:         self.elementos.append(elemento)
   6:     def pop(self) :
   7:         return self.elementos.pop()
   8:     def isEmpty(self) :
   9:         return (self.elementos == [])
  10:     def evalPostfijo(expr):
  11:         import re
  12:         listaTokens = re.split("([^0-9])", expr)
  13:         pila = Pila()
  14:         for token in listaTokens:
  15:         if token == '' or token == ' ':
  16:             continue
  17:         if token == '+':
  18:             suma = pila.pop() + pila.pop()
  19:             pila.push(suma)
  20:             elif token == '*':
  21:             producto = pila.pop() * pila.pop()
  22:             pila.push(producto)
  23:         else:
  24:             pila.push(int(token))
  25:         return pila.pop()

C.6. Colas y colas priorizadas en Python

   1: class Cola :
   2:     def __init__(self) :
   3:         self.longitud = 0
   4:         self.cabeza = None
   5:  
   6:     def vacia(self) :
   7:         return (self.longitud == 0)
   8:  
   9:     def inserta(self, carga) :
  10:         nodo = Nodo(carga)
  11:         nodo.siguiente = None
  12:             if self.cabeza == None :
  13:             # Si la lista esta vac³a nuestro nuevo nodo es el primero
  14:             self.cabeza = nodo
  15:         
  16:             else :
  17:             # Encuentra el ultimo nodo de la lista
  18:             ultimo = self.cabeza
  19:             while ultimo.siguiente : ultimo = ultimo.siguiente
  20:                 # Añada el nuevo nodo
  21:                 ultimo.siguiente = nodo
  22:                 self.longitud = self.longitud + 1
  23:  
  24:     def quita(self) :
  25:         carga = self.cabeza.carga
  26:         self.cabeza = self.cabeza.next
  27:         self.longitud = self.longitud - 1
  28:         return carga
  29: class ColaMejorada :
  30:     def __init__(self) :
  31:     self.longitud = 0
  32:     self.cabeza = None
  33:     self.ultimo = None
  34:  
  35:  
  36:     def vacia(self) :
  37:         return (self.longitud == 0)
  38:  
  39:     def inserta(self, carga) :
  40:         nodo = Nodo(carga)
  41:         nodo.siguiente = None
  42:             if self.longitud == 0 :
  43:             # Si la lista esta vac³a nuestro nuevo nodo es el primero
  44:             self.cabeza = self.ultimo = nodo
  45:             
  46:             else :
  47:                 # Encuentra el ultimo nodo de la lista
  48:                 ultimo = self.ultimo
  49:                 # Añade nuestro nodo nuevo
  50:                 ultimo.siguiente = nodo
  51:                 self.ultimo = nodo
  52:                 self.longitud = self.longitud + 1
  53:     def quita(self) :
  54:         carga = self.cabeza.carga
  55:         self.cabeza = self.cabeza.siguiente
  56:         self.longitud = self.longitud - 1
  57:             if self.longitud == 0 : self.ultimo = None
  58:                 return carga
  59: class ColaPriorizada :
  60:     def __init__(self) :
  61:         self.elementos = []
  62:     def vacia(self) :
  63:         return self.elementos == []
  64:     def inserta(self, elemento) :
  65:         self.elementos.append(elemento)
  66:     def quita(self) :
  67:         maxi = 0
  68:         for i in range(1,len(self.elementos)) :
  69:         if self.elementos[i] > self.elementos[maxi] :
  70:             maxi = i
  71:             elemento = self.elementos[maxi]
  72:             self.elementos[maxi:maxi+1] = []
  73:             return elemento
  74: class Golfista :
  75:     def __init__(self, nombre, puntos) :
  76:         self.nombre = nombre
  77:         self.puntos = puntos
  78:     def __str__(self) :
  79:         return "%-15s: %d" % (self.nombre, self.puntos)
  80:     def __cmp__(self, otro) :
  81:         if self.puntos < otro.puntos : return 1 # menos es mas
  82:         if self.puntos > otro.puntos : return -1
  83:             return 0

C.7. Árboles en Python

   1: class Arbol :
   2: def __init__(self, carga, izquierda=None, derecha=None) :
   3:     self.carga = carga
   4:     self.izquierda = izquierda
   5:     self.derecha = derecha
   6:  
   7: def __str__(self) :
   8:     return str(self.carga)
   9:  
  10: def tomaCarga(self): return self.carga
  11: def tomaIzquierda(self): return self.izquierda
  12: def tomaDerecha(self): return self.derecha
  13: def ajustaCarga(self, carga): self.carga = carga
  14: def ajustaIzquierda (self, izquierda): self.left = izquierda
  15: def ajustaDerecha(self, derecha): self.derecha = derecha
  16:  
  17: def total(arbol) :
  18:     if arbol == None : return 0
  19:     return total(arbol.izquierda) + total(arbol.derecha) + arbol.carga
  20:  
  21: def imprimeArbol(arbol):
  22:     if arbol == None: return
  23:     print arbol.carga,
  24:     imprimeArbol(arbol.izquierda)
  25:     imprimeArbol(arbol.derecha)
  26:  
  27: def imprimeArbolPosfijo(arbol):
  28:     if arbol == None: return
  29:     imprimeArbolPosfijo(arbol.izquierda)
  30:     imprimeArbolPosfijo(arbol.derecha)
  31:     print arbol.carga,
  32:  
  33: def imprimeArbolInfijo(arbol):
  34:     if arbol == None: return
  35:     imprimeArbolInfijo(arbol.izquierda)
  36:     print arbol.carga,
  37:     imprimeArbolInfijo(arbol.derecha)
  38:  
  39: def imprimeArbolSangrado(arbol, nivel=0):
  40:     if arbol == None: return
  41:     imprimeArbolSangrado(arbol.derecha, nivel+1)
  42:     print ' '*nivel + str(arbol.carga)
  43:     imprimeArbolSangrado(arbol.izquierda, nivel+1)

C.8. Árboles de expresión Python

   1: def tomaToken(listaToken, esperado):
   2:     if listaToken[0] == esperado:
   3:         listaToken[0:1] = [] # quita el token
   4:         return 1
   5:     else:
   6:         return 0
   7: def obtieneProducto(listaToken) :
   8:  
   9: a = obtieneNumero(listaToken)
  10:     if tomaToken(listaToken, '*') :
  11:         b = obtieneProducto(listaToken)
  12:         return Arbol('*', a, b)
  13:     else :
  14:         return a
  15:  
  16: def obtieneSuma(listaToken) :
  17: a = obtieneProducto(listaToken)
  18:     if tomaToken(listaToken, '+') :
  19:         b = obtieneSuma(listaToken)
  20:         return Arbol('+', a, b)
  21:     else :
  22:         return a
  23:  
  24: def obtieneNumero(listaToken):
  25:     
  26:     if tomaToken(listaToken, '(') :
  27:         x = obtieneSuma(listaToken) # obtiene subexpresion
  28:         tomaToken(listaToken, ')') # se come el cierre de parentesis
  29:         return x
  30:     else :
  31:         x = listaToken[0]
  32:  
  33:     if type(x) != type(0) : return None
  34:         listaToken[0:1] = [] # quita el token
  35:         return Arbol(x, None, None) # devuelve una hoja sin el numero

C.9. Adivina el animal Python

   1: def animal():
   2:  
   3: # empezar con un nodo suelto
   4: raiz = Arbol("pajaro")
   5: # bucle hasta que el usuario salga
   6: while 1:
   7: print
   8:  
   9:     if not si("Estas pensando en un animal? "): break
  10:         # recorrer el arbol
  11:         arbol = raiz
  12:         while arbol.tomaIzquierda() != None:
  13:         indicador = arbol.tomaCarga() + "? "
  14:     
  15:     if si(indicador):
  16:         arbol = arbol.tomaDerecha()
  17:     else:
  18:         arbol = arbol.tomaIzquierda()
  19:     
  20: # intentar adivinar
  21: adivina = arbol.tomaCarga()
  22: indicador = "Es un " + adivina + "? "
  23:  
  24:     if si(indicador):
  25:         print "^A<Soy el mas grande!"
  26:         continue
  27:  
  28: # obtener informacion nueva
  29: indicador = "Como se llama el animal? "
  30: animal = raw_input(indicador)
  31: indicador = "Que pregunta distinguir³a a un %s de un %s? "
  32: pregunta = raw_input(indicador % (animal,adivina))
  33:  
  34: # a~nadir informacion nueva al arbol
  35: arbol.ponCarga(pregunta)
  36: indicador = "Si el animal fuera un %s, cual ser³a la respuesta? "
  37:     if si(indicador % animal):
  38:         arbol.ponIzquierda(Arbol(adivina))
  39:     arbol.ponDerecha(Arbol(animal))
  40:     
  41:     else:
  42:         arbol.ponIzquierda(Arbol(animal))
  43:         arbol.ponDerecha(Arbol(adivina))
  44:     
  45:     def si(preg):
  46:         from string import lower
  47:         resp = lower(raw_input(preg))
  48:         return (resp[0:1] == 's')

Página 5 de 6

Creado con WordPress & Tema de Anders Norén