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

    Te has suscrito correctamente al boletín

    Se produjo un error al intentar enviar tu solicitud. Inténtalo de nuevo.

    Mi Diario Python will use the information you provide on this form to be in touch with you and to provide updates and marketing.