UNIDADES = (
    '',
    'UN ',
    'DOS ',
    'TRES ',
    'CUATRO ',
    'CINCO ',
    'SEIS ',
    'SIETE ',
    'OCHO ',
    'NUEVE ',
    'DIEZ ',
    'ONCE ',
    'DOCE ',
    'TRECE ',
    'CATORCE ',
    'QUINCE ',
    'DIECISEIS ',
    'DIECISIETE ',
    'DIECIOCHO ',
    'DIECINUEVE ',
    'VEINTE '
)
DECENAS = (
    'VENTI',
    'TREINTA ',
    'CUARENTA ',
    'CINCUENTA ',
    'SESENTA ',
    'SETENTA ',
    'OCHENTA ',
    'NOVENTA ',
    'CIEN '
)
CENTENAS = (
    'CIENTO ',
    'DOSCIENTOS ',
    'TRESCIENTOS ',
    'CUATROCIENTOS ',
    'QUINIENTOS ',
    'SEISCIENTOS ',
    'SETECIENTOS ',
    'OCHOCIENTOS ',
    'NOVECIENTOS '
)
 
def toWord(number):
 
    """
    Converts a number into string representation
    """
    converted = ''
 
    if not (0 < number < 999999999):
 
        return 'No es posible convertir el numero a letras'
 
    number_str = str(number).zfill(9)
    millones = number_str[:3]
    miles = number_str[3:6]
    cientos = number_str[6:]
 
    if(millones):
        if(millones == '001'):
            converted += 'UN MILLON '
        elif(int(millones) > 0):
            converted += '%sMILLONES ' % __convertNumber(millones)
 
    if(miles):
        if(miles == '001'):
            converted += 'MIL '
        elif(int(miles) > 0):
            converted += '%sMIL ' % __convertNumber(miles)
 
    if(cientos):
        if(cientos == '001'):
            converted += 'UN '
        elif(int(cientos) > 0):
            converted += '%s ' % __convertNumber(cientos)
 
    converted += 'PESOS'
 
    return converted.title()
 
def __convertNumber(n):
    """
    Max length must be 3 digits
    """
    output = ''
 
    if(n == '100'):
        output = "CIEN "
    elif(n[0] != '0'):
        output = CENTENAS[int(n[0])-1]
 
    k = int(n[1:])
    if(k <= 20):
        output += UNIDADES[k]
    else:
        if((k > 30) & (n[2] != '0')):
            output += '%sY %s' % (DECENAS[int(n[1])-2], UNIDADES[int(n[2])])
        else:
            output += '%s%s' % (DECENAS[int(n[1])-2], UNIDADES[int(n[2])])
 
    return output

/**
 * Esta clase provee la funcionalidad de convertir un numero representado en
 * digitos a una representacion en letras. Mejorado para leer centavos
 * 
 * @author Camilo Nova
 * @version 1.0
 */
public abstract class NumberToLetterConverter {
 
	private static final String[] UNIDADES = { "", "UN ", "DOS ", "TRES ",
			"CUATRO ", "CINCO ", "SEIS ", "SIETE ", "OCHO ", "NUEVE ", "DIEZ ",
			"ONCE ", "DOCE ", "TRECE ", "CATORCE ", "QUINCE ", "DIECISEIS",
			"DIECISIETE", "DIECIOCHO", "DIECINUEVE", "VEINTE" };
 
	private static final String[] DECENAS = { "VENTI", "TREINTA ", "CUARENTA ",
			"CINCUENTA ", "SESENTA ", "SETENTA ", "OCHENTA ", "NOVENTA ",
			"CIEN " };
 
	private static final String[] CENTENAS = { "CIENTO ", "DOSCIENTOS ",
			"TRESCIENTOS ", "CUATROCIENTOS ", "QUINIENTOS ", "SEISCIENTOS ",
			"SETECIENTOS ", "OCHOCIENTOS ", "NOVECIENTOS " };
 
	/**
	 * Convierte a letras un numero de la forma $123,456.32 (StoreMath)
	 * <p>
	 * Creation date 5/06/2006 - 10:20:52 AM
	 * 
	 * @param number
	 *            Numero en representacion texto
	 * @return Numero en letras
	 * @since 1.0
	 */
	public static String convertNumberToLetter(String number) {
		return convertNumberToLetter(StoreMath.parseString(number));
	}
 
	/**
	 * Convierte un numero en representacion numerica a uno en representacion de
	 * texto. El numero es valido si esta entre 0 y 999'999.999
	 * <p>
	 * Creation date 3/05/2006 - 05:37:47 PM
	 * 
	 * @param number
	 *            Numero a convertir
	 * @return Numero convertido a texto
	 * @throws NumberFormatException
	 *             Si el numero esta fuera del rango
	 * @since 1.0
	 */
	public static String convertNumberToLetter(double number)
			throws NumberFormatException {
		String converted = new String();
 
		// Validamos que sea un numero legal
		double doubleNumber = StoreMath.round(number);
		if (doubleNumber > 999999999)
			throw new NumberFormatException(
					"El numero es mayor de 999'999.999, "
							+ "no es posible convertirlo");
 
		String splitNumber[] = String.valueOf(doubleNumber).replace('.', '#')
				.split("#");
 
		// Descompone el trio de millones - ¡SGT!
		int millon = Integer.parseInt(String.valueOf(getDigitAt(splitNumber[0],
				8))
				+ String.valueOf(getDigitAt(splitNumber[0], 7))
				+ String.valueOf(getDigitAt(splitNumber[0], 6)));
		if (millon == 1)
			converted = "UN MILLON ";
		if (millon > 1)
			converted = convertNumber(String.valueOf(millon)) + "MILLONES ";
 
		// Descompone el trio de miles - ¡SGT!
		int miles = Integer.parseInt(String.valueOf(getDigitAt(splitNumber[0],
				5))
				+ String.valueOf(getDigitAt(splitNumber[0], 4))
				+ String.valueOf(getDigitAt(splitNumber[0], 3)));
		if (miles == 1)
			converted += "MIL ";
		if (miles > 1)
			converted += convertNumber(String.valueOf(miles)) + "MIL ";
 
		// Descompone el ultimo trio de unidades - ¡SGT!
		int cientos = Integer.parseInt(String.valueOf(getDigitAt(
				splitNumber[0], 2))
				+ String.valueOf(getDigitAt(splitNumber[0], 1))
				+ String.valueOf(getDigitAt(splitNumber[0], 0)));
		if (cientos == 1)
			converted += "UN";
 
		if (millon + miles + cientos == 0)
			converted += "CERO";
		if (cientos > 1)
			converted += convertNumber(String.valueOf(cientos));
 
		converted += "PESOS";
 
		// Descompone los centavos - Camilo
		int centavos = Integer.parseInt(String.valueOf(getDigitAt(
				splitNumber[1], 2))
				+ String.valueOf(getDigitAt(splitNumber[1], 1))
				+ String.valueOf(getDigitAt(splitNumber[1], 0)));
		if (centavos == 1)
			converted += " CON UN CENTAVO";
		if (centavos > 1)
			converted += " CON " + convertNumber(String.valueOf(centavos))
					+ "CENTAVOS";
 
		return converted;
	}
 
	/**
	 * Convierte los trios de numeros que componen las unidades, las decenas y
	 * las centenas del numero.
	 * <p>
	 * Creation date 3/05/2006 - 05:33:40 PM
	 * 
	 * @param number
	 *            Numero a convetir en digitos
	 * @return Numero convertido en letras
	 * @since 1.0
	 */
	private static String convertNumber(String number) {
		if (number.length() > 3)
			throw new NumberFormatException(
					"La longitud maxima debe ser 3 digitos");
 
		String output = new String();
		if (getDigitAt(number, 2) != 0)
			output = CENTENAS[getDigitAt(number, 2) - 1];
 
		int k = Integer.parseInt(String.valueOf(getDigitAt(number, 1))
				+ String.valueOf(getDigitAt(number, 0)));
 
		if (k <= 20)
			output += UNIDADES[k];
		else {
			if (k > 30 && getDigitAt(number, 0) != 0)
				output += DECENAS[getDigitAt(number, 1) - 2] + "Y "
						+ UNIDADES[getDigitAt(number, 0)];
			else
				output += DECENAS[getDigitAt(number, 1) - 2]
						+ UNIDADES[getDigitAt(number, 0)];
		}
 
		// Caso especial con el 100
		if (getDigitAt(number, 2) == 1 && k == 0)
			output = "CIEN";
 
		return output;
	}
 
	/**
	 * Retorna el digito numerico en la posicion indicada de derecha a izquierda
	 * <p>
	 * Creation date 3/05/2006 - 05:26:03 PM
	 * 
	 * @param origin
	 *            Cadena en la cual se busca el digito
	 * @param position
	 *            Posicion de derecha a izquierda a retornar
	 * @return Digito ubicado en la posicion indicada
	 * @since 1.0
	 */
	private static int getDigitAt(String origin, int position) {
		if (origin.length() > position && position >= 0)
			return origin.charAt(origin.length() - position - 1) - 48;
		return 0;
	}
 
}

#!/usr/bin/env python
 
# Encapsulacion en python
class Automotor(object) :
    """Clase de la cual heredan las demas y que es del nuevo estilo en python"""
 
    def __init__(self, ensambladora, nombre) :
        self.setEnsambladora(ensambladora)
        self.setNombre(nombre)
        print "Automotor", nombre, "Creado!!!"
 
    def setEnsambladora(self, ensambladora) :
        """Determina la ensambladora"""
        self.__ensambladora = ensambladora
 
    def getEnsambladora(self) :
        """Retorna la ensambladora"""
        return self.__ensambladora
 
    def setNombre(self, nombre) :
        """Determina el nombre del automotor"""
        self.__nombre = nombre
 
    def getNombre(self) :
        """Retorna el nombre del automotor"""
        return self.__nombre
 
    #Determinamos que el unico acceso a las variables es por los metodos
    ensambladora = property(getEnsambladora, setEnsambladora)
    nombre = property(getNombre, setNombre)
 
 
class Carro(Automotor) :
    """Esta clase hereda de Automotor y sus metodos"""
    pass
 
class Motocicleta(Automotor) :
    """Esta clase hereda de Automotor y sus metodos, pero es diferente a Carro"""
    pass
 
if __name__ == '__main__':
    carro = Carro("Toyota", "Celica")
    moto = Motocicleta("Auteco", "Pulsar")
 
    print "\n\n"
    print "El carro es", carro.getNombre()
    print "La moto es", moto.getNombre()

#!/usr/bin/env python
 
#Herencia en python
class Automotor :
    """Clase de la cual heredan las demas"""
 
    def __init__(self, ensambladora) :
        self.ensambladora = ensambladora
 
    def printEnsambladora(self) :
        print "La ensambladora es", self.ensambladora
 
class Carro(Automotor) :
    """Esta clase hereda de Automotor y sus metodos"""
    pass
 
class Motocicleta(Automotor) :
    """Esta clase hereda de Automotor y sus metodos, pero es diferente a Carro"""
    pass
 
if __name__ == '__main__':
    carro = Carro("Toyota")
    moto = Motocicleta("Auteco")
 
    carro.printEnsambladora()
    moto.printEnsambladora()

#!/usr/bin/env python
 
#Primera clase en python
class Empresa :
    """Clase Empresa, que abstrae una empresa del mundo real"""
 
    def __init__(self, nombreEmpresa, productoReal, cantidadEmpleados) :
        self.nombreEmpresa = nombreEmpresa
        self.productoReal = productoReal
        self.cantidadEmpleados = cantidadEmpleados
 
        print "La empresa", nombreEmpresa, "vende", productoReal, " emplea a", cantidadEmpleados, "empleados."
 
    def venderProducto(self) :
        print "Vendida una unidad de", self.productoReal
 
    def contratarEmpleados(self, cantidad) :
        self.cantidadEmpleados = self.cantidadEmpleados + int(cantidad)
 
        print "La empresa ahora emplea a", self.cantidadEmpleados, "empleados."
 
# Orientacion a Objetos en python
if __name__ == '__main__':
    print "\nCreamos la instancia de la clase:"
    empresa = Empresa("AxiaCore", "AxiaHost", 10)
 
    print "\nVendemos un producto:"
    empresa.venderProducto()
 
    print "\nContratamos 2 empleados:"
    empresa.contratarEmpleados(2)

#!/usr/bin/env python
 
# La funcion debe declararse antes de ser llamada, en lo posible se deben declarar al comienzo del archivo
 
def imprimir(param1, param2, param3) :
    """Esta funcion imprime los parametros en pantalla"""
    print param1
    print param2
    print param3    
 
def funcion_valor_defecto(cadena, repeticion = 1) :
    """Esta funcion aplica un valor por defecto para uno de los argumentos"""
    print cadena * repeticion
 
def funcion_varargs_tupla(*tupla) :
    """Esta funcion recibe una cantidad de argumentos variables los cuales son almacenados en una tupla para ser trabajados dentro de la funcion"""
    print "Tupla \t" + str(tupla)
    for var in tupla :
        print var
 
def function_varargs_diccionario(**diccionario) :
    """Esta funcion recibe una cantidad variable de argumentos y los almacena en un diccionario"""
    print "Diccionario \t" + str(diccionario)
    # diccionario.items() muestra los elementos del diccionario, valor y clave respectivamente retornados como tuplas cada uno
    for elem in diccionario.items() :
        print elem
 
def function_retorna_suma(*elementos) :
    """Retorna la suma de los elementos pasados por parametro"""
    valor = 0
    for i in elementos :
        valor = valor + i
 
    return valor
 
def function_retorna_cuadrados(x, y) :
    """Retorna una tupla con los cuadrados de los numeros pasados como argumento"""
    return x ** 2, y ** 2
 
# Funciones en python
if __name__ == '__main__':
    """Esta es una linea de documentacion"""
    imprimir("Hola", "Estamos ", "Probando")
    print "---"
    funcion_valor_defecto("saludos ")
    funcion_valor_defecto("saludos", 10)
    print "---"
    funcion_varargs_tupla("Primero", "Segundo", "Tercero", 4, 5.05)
    print "---"
    function_varargs_diccionario(uno = 1, dos = 2, tres = "tres")    
    print "---"
    print function_retorna_suma(1, 3, 5, 6, 2, 8, 6, 0)
    print "---"
    print function_retorna_cuadrados(2, 6)

#!/usr/bin/env python
 
# Bucles en python
if __name__ == '__main__':
 
    while True :
        print 'Digite un numero o escriba \'salir\' para terminar'
        entrada = raw_input(">> ")
 
        if entrada == 'salir' :
            break
        else :
            conteo = int(entrada)
 
            # El bucle while se ejecuta mientras la condicion sea verdadera
            while conteo > 1 :
                conteo = conteo - 1
                if (conteo % 2 == 0) :
                    print 'El numero ' + str(conteo) + ' es par'
                    continue
                print 'El numero ' + str(conteo) + ' es impar'
 
            print 'El conteo ha finalizado'
 
    # Con un For imprimimos los creditos
    # El bucle for itera sobre una lista, recordemos que una cadena es una lista en python
    autor = 'AxiaCore'
    espaciador = '-'
    for caracter in autor :
        print espaciador + caracter
        espaciador = espaciador + '-'
 
    print 'El programa ha finalizado'

#!/usr/bin/env python
 
# Sentencias condicionales en python
if __name__ == '__main__':
 
    a = 12
    b = 8
 
    # Ejemplo de if-else
    if a < b :
        print str(a) + ' es mayor que ' + str(b)
        print 'Esta linea tambien se ejecuta dentro del if'
    else :
        print str(a) + ' es menor que ' + str(b)
    print 'Esta linea por estar a diferente identacion no entra en el if-else\n'
 
    cadena = 'texto'
 
    # Ejemplo del tipico if-else-if-else 
    if cadena == 'casa' :
        print 'Es una casa'
    elif cadena == 'carro' :
        print 'Es un carro'
    else :
        print 'No es ni una casa ni un carro'
 
    # Una contraccion del tipo (condicion) ? verdadero : falso
    print 'Es un texto' if(cadena == 'texto') else 'No es un texto'

#!/usr/bin/env python
 
#Ejemplo de diccionarios en python
if __name__ == '__main__':
 
    # Al igual que en java contamos con la ventaja de utilizar HashTable, en python los diccionarios son un objeto pareja de una llave y un valor que sirve basicamente para referenciar el contenido de una lista, sin ser una lista, sino un tipo de dato diferente.
 
    # A manera de repaso, para asignar valores a tuplas se usa (), a listas [] y a diccionarios {}
 
    diccionario = { 1 : "Primer Elemento",
                    2 : False,
                    'listado' : [1, 2, 3]}
 
    # Accedemos a su contenido por medio de las llaves (primer elemento)
    print diccionario
    print diccionario[1]
    lista = diccionario['listado']
    print lista
 
    # Podemos cambiar el contenido del diccionario
    lista = ['una ', 'nueva ', 'lista']
    diccionario['listado'] = lista
    print diccionario
 
    # En los diccionarios el slicing no funciona porque es una tabla indexada por valores (asociaciones), no por una secuencia determinada como una lista