Cesar Systems

Herramientas Informaticas

Autor: juliocesar20200413 Página 128 de 141

Desarrollador web apasionado y gusto por la buena musica

C.3. Cartas, mazos y juegos Python

por

en julio 28, 2012

en Cursos de programación, Cursos de programación Python, Pensar como programador, Pyhon, ser mejor programador, técnica para programar mejor, Tecnicas para programar mejor

   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

por

en julio 28, 2012

en Cursos de programación, Cursos de programación Python, Pensar como programador, Pyhon, ser mejor programador, técnica para programar mejor, Tecnicas para programar mejor

   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

por

en julio 28, 2012

en Cursos de programación, Cursos de programación Python, Pensar como programador, Pyhon, ser mejor programador, técnica para programar mejor, Tecnicas para programar mejor

   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

por

en julio 28, 2012

en Cursos de programación, Cursos de programación Python, Pensar como programador, Pyhon, ser mejor programador, técnica para programar mejor, Tecnicas para programar mejor

   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

por

en julio 28, 2012

en Cursos de programación, Cursos de programación Python, Pensar como programador, Pyhon, ser mejor programador, técnica para programar mejor, Tecnicas para programar mejor

   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

por

en julio 28, 2012

en Cursos de programación, Cursos de programación Python, Pensar como programador, Pyhon, ser mejor programador, técnica para programar mejor, Tecnicas para programar mejor

   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

por

en julio 28, 2012

en Cursos de programación, Cursos de programación Python, Pensar como programador, Pyhon, ser mejor programador, técnica para programar mejor, Tecnicas para programar mejor

   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')

C.10. Fraction class python

por

en julio 28, 2012

en Cursos de programación, Cursos de programación Python, Pensar como programador, Pyhon, ser mejor programador, técnica para programar mejor, Tecnicas para programar mejor

   1: class Fraccion:
   2:     def __init__(self, numerador, denominador=1):
   3:     m = mcd (numerador, denominador)
   4:     self.numerador = numerador / m
   5:     self.denominador = denominador / m
   6:     def __mul__(self, otro):
   7:     
   8:         if type(otro) == type(5):
   9:         otro = Fraccion(otro)
  10:         return Fraccion(self.numerador * otro.numerador,
  11:    
  12:  
  13:      self.denominador * otro.denominador)
  14:     __rmul__ = __mul__
  15:     def __add__(self, otro):
  16:     
  17:     if type(otro) == type(5):
  18:         otro = Fraccion(otro)
  19:         return Fraccion(self.numerador * otro.denominador +
  20:     
  21:     self.denominador * otro.numerador,
  22:     self.denominador * otro.denominador)
  23:     __radd__ = __add__
  24:     def __cmp__(self, otro):
  25:     if type(otro) == type(5):
  26:         otro = Fraccion(otro)
  27:         dif = (self.numerador * otro.denominador -
  28:         otro.numerador * self.denominador)
  29:         return dif
  30:  
  31:     def __repr__(self):
  32:     return self.__str__()
  33:     def __str__(self):
  34:     return "%d/%d" % (self.numerador, self.denominador)
  35:  
  36:     def mcd(m,n):
  37:         "devuelve el maximo comun denominador de dos enteros"
  38:     if m % n == 0:
  39:         return n
  40:     else:
  41:     return mcd(n,m%n)

Lecturas recomendadas

por

en julio 28, 2012

en Cursos de programación, Cursos de programación Python, Pensar como programador, Pyhon, ser mejor programador, técnica para programar mejor, Tecnicas para programar mejor

Y ahora, hacia donde ir desde aquí? Hay muchas direcciones en las que seguir, ampliando sus conocimientos de Python especialmente y de informática en general.
Los ejemplos en este libro han sido deliberadamente simples, por lo que pueden no haber mostrado las capacidades mas excitantes de Python. A continuación exponemos una muestra de las extensiones de Python y sugerencias sobre sus usos.
La programación de GUIs (interfaces graficas de usuario, graphic user interface en ingles) permite que su programa utilice un entorno de ventanas para interactuar con el usuario y mostrar gráficos.
El primer paquete que ha tenido Python para esto es Tkinter, basado en los lenguajes interpretados Tcl y Tk de Jon Ousterhout. Tkinter esta incluido en la distribución de Python.
Otra plataforma popular es wxPython, que es esencialmente un enchapado sobre wxWindows, un paquete de C++ que implementa ventanas utilizando la interfaces nativas las plataformas Windows y Unix (incluido Linux). Las ventanas y los controles con wxPython tienen una apariencia mas nativa que Tkinter y son un poco mas sencillos de programar.
Cualquier tipo de programación de GUIs le llevara a programación basada en eventos, donde es el usuario y no el programador quien determina el flujo de la ejecución. Este estilo de programación requiere de algo de tiempo para acostumbrarse, y a veces le forzara a replantearse toda la estructura del programa.
La programación web integra Python en la Internet. Por ejemplo, puede construir programas de cliente web que abran y lean una pagina remota (casi) tan fácilmente como si fuera un ¯chero en disco. También hay módulos de Python que le permiten acceder a ¯cheros remotamente v³a ftp, y módulos que le permiten enviar y recibir correos electrónicos. Python también es ampliamente utilizado en el lado del servidor de la programación web para manejar los datos de entrada de los formularios. Las bases de datos son un poco como superficheros en donde los datos están almacenados en esquemas predefinidos, y las relaciones entre los datos le permiten acceder a ellos de varias maneras. Python tiene varios módulos para permitir a los usuarios conectarse a varios motores de bases de datos, tanto Open Source como comerciales.
La programación multi-procesos (multi-hilos) le permite ejecutar varios procesos (hilos) de ejecución dentro de un único programa. Si ha tenido la experiencia de usar un navegador web para desplazarse por una pagina web mientras el navegador continua cargando el resto de la misma, entonces tiene una idea de lo que los hilos pueden hacer.
Cuando la velocidad es mas importante se pueden escribir extensiones para Python en un lenguaje compilado como C o C++. Tales extensiones forman la base de la mayor³a de módulos en la librer³a de Python.
El mecanismo de enlazar funciones y datos es un poco complejo. SWIG(Simpli¯ed Wrapper and Interface Generator) es una herramienta para hacer este proceso mucho mas sencillo.

D.1. Libros y sitios web sobre Python

por

en julio 28, 2012

en Cursos de programación, Cursos de programación Python, Pensar como programador, Pyhon, ser mejor programador, técnica para programar mejor, Tecnicas para programar mejor

Aquí tiene las recomendaciones de los autores sobre recursos para Python en la
web:
  • La pagina de inicio de Python en www.python.org es el lugar para empezar su búsqueda de material sobre Python. Encontrara ayuda, documentación, enlaces a otros libros y listas de correo de SIGs (Special Interest Group)
    a las que se puede unir.
  • El proyecto Open Book Project www.ibiblio.com/obp contiene no solo este libro en línea sino también otros libros similares para Java y C++ de Allen Downey. Además esta Lessons in Electric Circuits de Tony R. Kuphaldt, Getting down with …, un conjunto de tutoriales de varios temas sobre informática, escritos y editados por estudiantes de instituto, Python for Fun, un conjunto de estudios de casos en Python de Chris Meyers, y The  Linux Cookbook de Michael Stultz, con 300 paginas de trucos y tecnicas.
  • Finalmente si acude a Google y busca con la cadena pitón -snake – monty” obtendrá cerca de 750.000 resultados. Y aquí algunos libros que contienen mas material sobre el lenguaje Python:
    • Core Python Programming de Wesley Chun es un libro largo, mas de 750 paginas. La primera parte del libro cubre las características básicas del lenguaje Python. La segunda parte proporciona una introducción paso a paso a temas mas avanzados incluyendo muchos de los mencionados anteriormente.
    • Python Essential Reference de David M. Beazley es un libro peque~no, pero contiene información sobre el lenguaje en si mismo y los módulos de la librería estándar. También esta muy bien indexado.
    • Python Pocket Reference de Mark Lutz realmente cabe en el bolsillo. Aunque no es tan extensivo como Python Essential Reference es una referencia útil para los módulos y funciones mas comúnmente usadas.
    • Mark Lutz también es autor de Programming Python, uno de los primeros (y mas largos) libros de Python y no esta dirigido al programador principiante.
    • Su siguiente libro Learning Python es mas pequeño y mas accesible.
    • Python Programming on Win32 de Mark Hammond y Andy Robinson es un libro que debe tener” cualquiera que que utilice seriamente Python para desarrollar aplicaciones para Windows. Entre otras cosas cubre la integración de Python y COM, construye una pequeña aplicación con wxPython, e incluso utiliza Python para escribir scripts para aplicaciones tales como Word y Excel.

Página 128 de 141

Anterior

Siguiente

Creado con WordPress & Tema de Anders Norén