Introducción:

Antes de profundizar en este script debes de saber obviamente python.

requisito:

• Python2 ó Python3(Recomendable).
• Saber de recursión(No es necesario).
• Saber Programación orientada a objetos(No es necesario).

Librerias:

• sys (usaremos solo el modulo "argv")
• termcolor (Para imprimir la salida con algunos colores.) No es soportado en win32

Ventajas y desventajas

La creación de este script es poder sumergirnos en el tema de la recursividad y la programación orientada a objetos.
Pero cuales son las ventajas y las desventajas de desarrollar este script, bueno son las siguientes:

Ventajas:

 - Lograr entender la recursividad.
 - Lograr entender la programación orientada a objetos

Desventajas:

 - Al utilizar la reucrsividad como una opcion para el desarrollo de este script, 

lamentablemente el script consumirá mucha memoria y se tornara lento en algunas 

ocasiones.

¿Qué es la recursividad?

Es la forma en la cual se especifica un proceso basado en su propia definición.
Osea cuando una función es llamada así mismo.

Recursión - Wikipedia

def f(start, stop):
    """
       Esto es un ejemplo simple de recursividad, la funcion se llamara a si misma hasta completar lo que el usuario quiere. Esta funcion tiene como objetivo imprimir los numero desde una cantidad inicial hasta llegar al numero de parada.
    """
    
    print(start)
    start += 1
    if start == stop:
        return start 
    return f(start, stop)  """ Es necesario retorna en esta parte porque si, a la   llamda siguiente, a funcion no recivira ningun dato y la funcion dejara de         ejecutarse al momento de indicarle que retirne la llamada de la funcion se entra
 en un bucle y hasto se le conoce como recursividad. """                  f(1, 10) 

Comienzo de la lógica del algoritmo.

Para comenzar con el desarrollo debemos analizar el problema en este caso solo 

necesitamos como poder ordenar el numero para que podamos trabajar de una forma 

muy sencilla a la hora de hacer la sustitución.

Primeros pasos:

Antes
de empezar lo ideal seria saber que debemos hacer en estes es decir
familiarizarnos con el funcionamiento del problema, bueno, lo que se
espera es retornar la cantidad de un numero, facil pero como hacer que
sea de forma ordenada y sencilla, "sustitucion".

Lo que debemos hacer es descomponer el numero ingresado en sub-grupos, y clasificaros, ejemplo:
input>>>10000; en ese ejemplo podemos ver que hay dos sub-grupos ya que en si ese numero seria diez mil, pero a simple vista no se podría separar o saber los dos sub-grupos por esto se tienen que añadir las (,), para poder separarlos de forma mas sencilla.

Sabiendo eso ya tenemos la primera parte lista, solo falta añadirles el valor correspondiente y seria asi:

- el sub-grupo mayor siempre sera el primero. eje: 1,000 -> 1 pertenece a (**mil**).

entonces ese es el mayor.
- para ser mas ordenados siempre se iniciara desde el sub-grupo mayor.

Sabiendo esto solo falta los datos para representar cada valor de los números y de los sub-grupos.

Hay entra el archivo numeros_.py ese archivo contiene dos diccionarios, los cuales son:

- LISTA_NUMEROS
- NUMEROS_RAROS

Funcionan de la siguiene manera:

El diccionario LISTA_NUMEROS se contiene las llaves 1, 2,
3, y 4, cada una representan el largo del sub-grupo y el largo del carácter:
ej: si el numero es 100, buscara el diccionario con el largo de ese
numero en este caso (3), LISTA_NUMEROS["3"], y
dependiendo del largo de los sub-grupos se obtiene el nivel. en este
caso seria asi LISTA_NUMEROS["3"][1], ya que se hace un for en el
sub-grupo, si es cero el numero entonces seguirá sin sustituir.
Con esta idea ya tenemos el script terminado solo le hacen falta
algunos retoques, validar si ya se recorrió el numero, validad si el
numero es raro osea pertenece a (once, doce, trece...), saber si el
numero es un cero, saber si el numero debe contener la preposicion y
etc...

Se utilizo la programación orientada a objeto en el
desarrollo de este script, porque facilitaba el uso de los datos a la
hora de modificarlos, ya que se usa la recursibidad y es un poco cansoso
definir variables globales

explicación del código

Se importan las librerías y los diccionarios

Bueno, los primero es vizualizar cada una de las variebles y luego decir su utilidad

• self.result: es la variable que sele añadian los datos del numero.
• self.number_copy: se retornara para indicar que fue el valor ingresado "1,000"
• self.number: en esta variable de guradara, una lista con los sub-grupos. "['1', '000']"
• self.len: guardara el largo de el total de sub-grupos. "2", luego se aplica un replace para eliminar los espacios.
• self.LN: es el diccionario que contiene los valores.
• self.vueltas: No es usado! "no es necasario definirlo".
• self.len_grpup: se guardara el largo de cada sub-grupo.

el metodo find se enargara de hacer todo el trabajo, se dividira en doferentes areas o pasos y cada uno tedra su explicacion.

Explicación

• Paso 0 (gris): en esa condicion se verifica que si el largo total de todos los sub-grupos, es cero retorne el self.result, cuando es cero quiere decir que ya no hay sub-grupos porque lo recorrió todos. no se utiliza la self.len para verificar porque el valor se actualiza una vez termine el bucl for, por lo que si se utiliza hay se produciría un error.

• Paso 1(rojo): aqui se toma el largo del sub-grupo que se encuentre
  en la primera posicion de la lista, y con este largo se pretender saber a
  que categoria pertenece ese sub-grupo, entonces dependiendo de ese
  largo se busca en LISTA_NUMEROS, ej: el numero es
  "100", en la lista seria ["100"], si tomamos el sub-grupo de la primera
  posicion seria ["100"][0] -> "100", tomamos el largo seria -> 3 y
  si buscamos en LISTA_NUMERO[3] devolveria algo asi:  y estaria en lo cierto ya que "100" pertenece a esa categoria, para eso es la declaracion de self.len y para eso se le asigna el alargo del sub-grupo.

• Paso 2(violeta): se utiliza este bucle para recorer los valores del sub-grupo, se usa enumerate()
  porque retorna el valor y el indice de dicho valor, el indice nos
  ayudara a poder predecir el valor futuro del elemento siguiente.

• Paso 3(amarillo): en este paso se indica que si el largo del sub-grupo es de 2 y si se une al numero futuro y pertenece a los NUMEROS_RAROS,
  devolvera el valor y se parara la ejecución, para comenzar de nuevo.
  los numeros raros son los números que no funcionan con la preposición y,
  ejemplo "treinta y cuatro" -> no es raror; pero, "once" -> si es
  raro, porque no es diez y uno. en si lo que hace es buscar en la tupla NUMEROS_RAROS, dependiendo del valor, si es el "11", buscaría en la posición 11-1, que seria la posición 10-"once".

• Paso 4(verde): este paso se cumple si el paso 3(amarillo) no se
  cumple, aqui solo pasaran los numeros que no son raros, se verifica de
  que el numero sea mayor a cero si lo es entonces se buscara el valor del
  numero, buscando primero su categoria y luego su valor, luego se
  verifica de que si el largo del subgrupo es dos, y el numero siguiente
  es diferente a 0(cero), entonces, se le añadira la preposicion y. ejemplo, el numero es "42", busca en LISTA_NUMERO["2"][int(4-1)] -> retornando "cuarenta", luego se le añade el "y ", devido a que el largo es 2 y el numero siguiente no es cero, porque es 2, luego al hacer eso denuevo, LISTA_NUMERO["1"][int(2-1)] -> "cuarenta y dos".

• Paso 5(morado): aqui se le resta 1 al largo del
  grupo actual, porque ya se sustituyo el valor del numero obtenido, esto
  hace que se adapte al cambio haciendo que sea mas preciso eso explica el
  porque en el caso del 2 en el punto anterior su largo fue 1.

• Paso 6(azul): aqui se verifica de que si el largo de los
  sub-grupos en total es mayor a 1 y si el valor de ese sub-grupo es mayor
  a 0, entonces, se le añadira su categoria dependiendo del largo, si el
  largo al cual se le resta 2, y de esa forma se devolvera su categoria. ej:
  si el numero es "1,000" entonces el largo es 2, al entrar al condicional pasa, ya que el largo es mayor a 1 y el subgrupo 0 es 1,
  luego se busca en el diccionario LISTA_NUMEROS["4"], la llave por
  defecto es "4" y, al restarle - 2 al largo quedaria 0,por lo que
  pertenece a mil.

  

• Paso 7(rosado): aqui se le resta un valor a self.len de esta forma de actualiza el largo del sub-grupo, self.vueltas no es necesario,
  y luego se elimina el sub-grupo que se encuentre en la primera posicion
  osea, se elimina el subgrupo ya recorido, de esta forma cuando se
  recorrarn todos los sub-grupos al llegar, el largo llegara a 0 y se
  retornara self.return, luego se llama de nuevo a la
  misma funcion para que logre recorer el sub-grupo siguiente, esto es la
  recursibidad. de esta forma no es necesario recorrer cada sub-grupo de
  forma individual osea que por cada sub grupo se defina una funcion, ya
  que solo serviria para escribir mas codigo, y esto es una ventaja que
  nos brinda la recursibidad.

• Paso 8(gris): este es el ultimo paso y el mas importante porque
  si no estubiera solo se lograria ver como se sustituyen los valores y no
  manipular el resultado, se utiliza el retorn, porque en si la funcion
  aunque no necesita recibir un valor pero si nesetita retornarlo, si no
  se usara este retorn, entonces el metodo, no retornaria nada. pero
  entonces para que sirve paso 0(gris), bueno es si ese paso solo funciona
  para detener la ejecucion de dicho metodo, porque si no se detuviera
  puede que un error lo haga o solo se sature el sistema.

Se utilizo el try, porque si ingresan un numero erróneo eso
saltaria un error y lo que hice fue capturar ese error para mostrar el
help, que imprime como funciona el script o modulo.


Código del programa: https://github.com/DarkCode01/number_to_string/.