Creando Calculadoras del Tiempo #2 - El funcionamiento de VALID.py

Índice

Introducción:

Les doy la bienvenida, a la segunda parte de "Creando Calculadoras del Tiempo". En este articulo, mi compañero Antonio, explicara el funcionamiento y desarrollo del script "VALID.py" el cual es usado en el programa. Espero que les sea de mucha ayuda, y que aprendan mucho.

No sabes de lo que hablo?, visita este articulo: "Creando Calculadoras del Tiempo #1 - una breve introducción al proyecto."

A partir de ahora, los dejo con Antonio.

El modulo "VALID.py":

El presente
artículo se enmarca en una serie destinada a la creación de un programa capaz
de calcular la “distancia” en horas, minutos y segundos, existente entre dos
instantes de tiempo definidos por día y hora.

Para empezar, hemos
de recordar el hecho de que la computadora es capaz de realizar una gran
cantidad de operaciones a una velocidad y con un nivel de eficiencia,
inalcanzable por el ser humano. No obstante también es cierto que para poder
efectuar todas esas operaciones la computadora necesita contar con el conjunto
de instrucciones que ha de proporcionarle el programador.

Aunque un programa
este bien escrito, se puede dar la posibilidad de que el usuario potencial
introduzca como input, algún tipo de dato que con el que el programa no pueda
trabajar, en cuyo caso nos enfrentamos a la posibilidad de que se produzca un
fallo que lleve consigo la interrupción de su correcto funcionamiento.

Por eso es
importante dotar al programa de una respuesta ante tal tipo de eventualidades,
evitando ese tipo de errores. Eso es lo que me he propuesto con la creación del
modulo “VALID.py” el cual constituye un paquete de funciones que, además,
poseen la característica común de poder ser utilizadas en diferentes programas,
sin necesidad de estar constantemente definiéndolas en cada programa que las
necesite (bastando simplemente con importarlas del referido modulo).



De este modo
“VALID.py” se convertirá en una pieza esencial para la correcta ejecución del
programa, motivo por el cual voy a empezar por la explicación de la lógica
seguida en la creación de cada una de las funciones que lo componen,
especialmente de las denominadas “OKI”,”ER” y “ns” que son las que se van a
utilizar en nuestra calculadora de horas, minutos y segundos.

Las funciones del modulo "VALID.py":

A
menudo, cuando usamos cualquier programa es habitual que en algún momento,
tengamos que introducir algún tipo de datos, los cuales pueden ser de distinto
tipo, y entre los que, naturalmente, se encuentran los de tipo numérico. Es
precisamente de esto de lo que tratan las tres primeras funciones que he
incluido en mi modulo. Con ellas lo que pretendo es (de algún modo) no dejar al
usuario potencial, de mi programa, la opción de introducir un dato que no sea
numérico (lo cual, tal y como he escrito el programa, daría lugar a un error
que 
produciría la
interrupción de su funcionamiento, debido a que se le estaría pidiendo a la
computadora que realizase una serie de operaciones con unos datos con los que
no podría trabajar).

La primera de tales
funciones es la que he denominado “OKI” (la cual utilizo en mi calculadora de
tiempo “Instant-Date”) y cuya misión es “cerciorarse” de que el usuario solo
introduzca valores numéricos y además que se trate de números enteros.


La función empieza
tomando como argumento el input introducido por el usuario (argumento que en la
función he bautizado como “n”). Acto seguido, programamos la excepción pidiendo
a la computadora que “intente” (con “try”) convertir el input introducido por
el usuario, en un número entero (n=int(n)), lo cual sería imposible en el
supuesto de que se haya introducido un número con decimales o cualquier
carácter no numérico (situaciones las cuales queremos evitar). El modo de
hacerlo es mediante “except” con el
que definimos lo que queremos que suceda para el caso en el que la conversión
previamente “intentada” no se haya podido llevar a cabo debido a la
inadecuación del dato introducido. Así, con “except”, doy la orden de que aparezca un mensaje que diga “Caracter no valido: “, dando al usuario
la posibilidad de introducir un nuevo input. Es interesante señalar aquí el
hecho de que en este caso la función se vuelve a aplicar sobre el nuevo dato
que introduzca el usuario. Esto es debido a que cabe la posibilidad (aunque no
se suele dar) de que el usuario del programa vuelva a equivocarse al meter el
dato. Es por ello que se tiene que volver a aplicar sobre el mismo, toda la
función desde el comienzo. Por último tras haberse completado este ciclo (ya
sea por que el “intento inicial se ha podido realizar a la primera o se haya
tenido que introducir el dato después), la función, a través de “return” devolverá el dato para que el
programa pueda utilizarlo sin problemas.

La siguiente
función (a la que he dado el nombre de “OK”) es muy similar a la anterior, de
hecho es igual salvo por la circunstancia de que lo trata de hacer es que se
introduzca un carácter numérico (ya sea entero o decimal), mientras en el caso
anterior solo admitía 
números enteros.

Lo cierto es que no
hay mucho que añadir en referencia a esta función, debido a que utiliza la
misma lógica que la anterior, con la salvedad de que en este caso la conversión
que se va a “intentar” es la de pasar nuestro input a un formato decimal (lo
cual puede hacerse tanto con números con decimales como enteros).

Por su parte, la
siguiente función (a la que he dado el nombre de “OKP”) ha sido creada pensando en su posible utilización en
programas que efectúen operaciones matemáticas. De hecho creé esta función para
una calculadora en la que permitía la introducción de string “pi” como input, en vez de un dato
estrictamente numérico tal y como se aprecia a continuación.


De ese modo
conseguía un modo de introducir un input que hiciera referencia directa al
número pi. Pasemos a ver la función:


Lo primero que hay
que hacer en este caso (que fue lo que hice) es importar desde el modulo “math” la función “pi” la cual pondrá a nuestra disposición dicho número para trabajar
con él. Si nos fijamos bien, en esta función volvemos a “intentar” la
conversión de nuestro input en un número. Sin embargo este método, jamás podría
aceptar la palabra “pi” como input,
motivo por el cual haremos depender la aplicación de esta excepción, del hecho
de que el argumento introducido se diferentes a “pi” (if n!=(“pi”)) y en caso contrario no solo no se aplicara la función
try”, sino que “n” pasará a
convertirse en el número “pi” (3.141592265389793)
pudiéndose, a partir de ese momento, trabajar con él sin problemas.

La siguiente
función de la que voy a hablar es la llamada “ER”. Lo cierto es que en este caso, a diferencia de lo que se
sucedía con las anteriores, su misión no es la de evitar la introducción de un
dato que pudiera causar problemas en su uso por la computadora, sino que
responde a una dificultad que (al menos yo) he tenido siempre a la hora de leer
números con muchas cifras.

Se trata de una
función que proporciona una pauta para leer este tipo de cifras, en función del
número de dígitos de los que se encuentre compuesto el número. A continuación
iré exponiendo paso a paso el desarrollo de dicha función.

Tal y como he dicho
anteriormente, el criterio principal para establecer la unidad perteneciente a
nuestro número es la longitud del mismo, lo cual podemos sacar usando la
función “len”. No obstante, sabemos
que esta función no puede ser aplicada sobre datos de tipo numérico, tal y como
se ve a continuación:


Esto nos hace ver,
que para poder usar ese método debemos trabajar sobre cadenas (formato “string”), por lo que lo primero que
debe hacer nuestra función es pasar el número de entrada a dicho formato.


De ese modo, en
nuestro ejemplo, hemos creado un “string
de nuestro número, al que le hemos dado el nombre de “strn”y sobre el cual ya podemos utilizar el método “len” para contar el número de
caracteres y al que daremos el nombre de “lstrn”.

Antes de continuar
debemos tener en cuenta que el número a “leer”, puede ser negativo y/o puede
contener decimales. Esta es relevante en el sentido de que aplicando la técnica
anterior tal cual, los caracteres “-“ y “.” Se contarían (cuando  lo que nos interesa es que se contabilicen
solo las cifras numéricas).

Tal y como se
aprecia en la imagen, hemos creado un bloque de código, dentro de nuestra
función, destinado a evitar que tanto el signo “-“, de los números negativos,
como el signo “.” En los decimales, sean contabilizados. En este bloque, lo primero
es hacer la variable “lstrn” (que
define la longitud de la cadena “strn”)
igual a 0, y a continuación, haciendo uso de un ciclo “for”, recorremos la cadena incrementando el valor de “lstrn” en 1 mientras que dicho carácter
(representado en este caso por “i”) sea distinto de “.” De modo que en el
momento en que se cumpla tal caso se “rompa” la ejecución del ciclo, mediante “break”.

Con la operación anterior
hemos conseguido “eliminar” del computo de caracteres, el punto decimal y los
dígitos situados a su derecha (contándose solo la parte entera de nuestro
número). Sin embargo, aún cabe la posibilidad de que se haya contado la
presencia de un signo negativo “-“, eventualidad, esta que es tenida en cuenta
a continuación, cuando e la función se establece que si existe un “-“, en
nuestra cadena (if (“-“) in strn),
al resultado obtenido en la operación anterior, será disminuido en 1.

Una vez que tenemos
la longitud de la cadena, descontando los decimales y el signo negativo, ya
estamos en condiciones de establecer la denominación del número en función de
la longitud de dicha cadena.


La siguiente parte
de la función es la que nos da la pauta para la lectura del número, en función
del su longitud (cabe señalar que esta función solo devolverá un resultado
visible para números de 4 a 18 dígitos) en el que el resultado final será un “string” compuesto por la unidad en la
que está el número y la cantidad de dígitos que se ha de tomar por la izquierda
para iniciar su lectura.

Como ejemplo de lo
dicho anteriormente, tenemos:


De este modo, el
resultado entre paréntesis nos indica que la cifra está millones y que tenemos
que coger los tres primeros dígitos para iniciar su lectura.

De este modo hemos
creado una función que puede facilitar la lectura de cifras altas (sin signos de
puntuación), la cual será útil para ser usada en programas en los que se  suelan generar cifras muy altas, como es el
caso del contador de horas, minutos y segundos del que hablaré más adelante.

La última función
del presente módulo, que usaremos en nuestra calculadora de horas, minutos y
segundos, es una realmente sencilla (y que utilizo en casi la totalidad de
programas que escribo). Dicha función es la que he denominado “ns”.


En nuestros
programas (especialmente cuando no utilizamos interfaz gráfica), a menudo
tenemos que preguntar al usuario, si quiere realizar una determinada acción con
el programa. Se trata de aquellos casos en los que queremos que el usuario opte
por una u otra opción (en este caso “si” o “no”). Para ello creé esta función en
la que pido al usuario que escriba “s” (para afirmar) o “n” (para indicar
negación), de modo que mientras que la respuesta sea distinta de “n” o “s”, el
programa continuará pidiendo una respuesta válida.


Hasta aquí, hemos
hecho un repaso de las funciones principales que componen mi modulo “VALID.py”
de las cuales, tres de ellas (“OKI”,”ER” y “ns”) serán utilizadas en nuestra
calculadora de horas “Instant-Date” y de cuyo desarrollo hablaré en un artículo
futuro.

El código de los programas referidos en este artículo
puede verse, en mi perfil de GitHub, en la siguiente dirección: https://github.com/antonioam82/Timer.

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *

Subir
White Monkey