Saludos, en el presente artículo
vamos a realizar un ejercicio con tablas. Concretamente vamos a crear un
programa que nos genere una tabla de logaritmos, a partir de la información
referente al rango numérico sobre el que queremos realizarlos y la base de
tales logaritmos. Un ejemplo de ejecución de nuestro programa sería el
siguiente:
Como se puede ver, nuestro programa ca a generar una table de logaritmos, partiendo de unos datos introducidos por el usuario del programa (en este caso la base del logaritmo a realizar).
Como es habitual, empezaremos
importando los módulos y funciones que vamos a necesitar para crear nuestro
programa:
Así, importaremos, por una parte, la función "log" del módulo "math" de python. Lo cual nos permitirá realizar el calculo de los logaritmos que vamos a mostrar en nuestra tabla. En segundo lugar, impportaremos "subprocess" para la limpieza de la consola, que vamos a realizar tras cada ejecución de nuestro programa.
Como ya hemos señalado, lo
primero que va a hacer nuestro programa es dar al usuario la posibilidad de
escoger entre ver los logaritmos correspondientes a un conjunto de números
empezando por el número 1, o ver tales cálculos referidos a un rango numérico
determinado por el mismo usuario. Para ello, empezaremos mostrando en pantalla,
ambas posibilidades:
De ese modo, tras mostrar las dos
posibilidades, (a las que a efectos de definirlas, llamaremos “A” y “B”) mostraremos
un input en el que el usuario tendrá que indicar una de tales opciones,
almacenándose la opción en la variable “met”. Debido a que solo queremos que la
respuesta sea “A” o “B” (y ninguna otra), aplicaremos sobre este input una
función (a la que hemos llamado “AB”) que asegure que la respuesta introducida
sea únicamente una de las indicadas. Dicha función la habremos definido con
anterioridad y será la siguiente:
Una vez establecido el modo de
seleccionar los números que conformarán nuestra tabla, lo siguiente que vamos a
pedirle al usuario (al ser un dato necesario para calcular nuestros logaritmos)
es que nos indique la base de tal logaritmo. Dicho dato lo almacenaremos en
otra variable a la que llamaremos “B”.
Pero hemos de recordar aquí, que
lo que queremos es una base para el logaritmo. Esto implica que no nos vale
cualquier número, ya que dicha base habrá de ser mayor de 1, ya que si
intentáramos calcular el logaritmo de un número tomando como base un número
igual o inferior a 1, obtendríamos errores como los que se muestran en la
imagen:
Por ello, es conveniente diseñar
nuestro programa de tal forma que no se pueda dar lugar a que se produzcan este
tipo de errores. Por ello haremos uso de una función (a la que hemos llamado
“op_val”) que se aplicará sobre el input introducido para la variable “B”. Esta
función deberá verificar la idoneidad de la base introducida.
Pero junto a los logaritmos con
base a un número (mayor de 1) vamos a crear nuestro programa de tal forma que
pueda crear tablas de “logaritmos naturales”, los cuales, toman como base el
número “e” (cuyo valor aproximado es de 271828). Para ello vamos a diseñar
nuestra función verificadora (“op_val”) de modo que admita como input válido,
la letra “e”. De ese modo pasamos a explicar dicha función que habremos
definido con anterioridad:
Tenemos, así, una función que
tomando como argumento el dato introducido para la base (“B”) empieza
comprobando si el carácter introducido es “e” (en cuyo caso, devolverá dicho
resultado, sin realizar ninguna comprobación más). No obstante, en el caso de
que el dato introducido sea distinto de “e” (número “e”), mediante “try”
intentará convertir el dato al formato de número entero (de modo de que en el
caso de que no lo consiga será debido a que no se ha introducido un dato
numérico, produciéndose una excepción que mostrará en pantalla un texto
pidiendo la introducción de un dato adecuado (un valor numérico o el número
“e”) sobre el que se volverá a aplicar la función integra desde el principio.
En el caso de que la conversión haya podido realizarse con éxito (por tratarse
de un valor numérico), el siguiente paso será constatar si dicho número es
menor de 1 (porque aquí lo que interesa es que sea mayor que la unidad), en
cuyo caso aparecerá un texto en el que se advertirá de que dicho número ha de
ser mayor de 1 (aplicándose de nuevo la función desde el principio, sobre el
resultado introducido en tal caso). Finalizado el proceso de verificación
(habiéndose constatado que el dato introducido es mayor de 1 o “e”) el programa
devolverá el dato que quedará almacenado en la variable “B” (base).
A partir de este punto
empezaremos a crear la nuestra tabla. El modo en el que nuestro programa va a
mostrar los resultados dependerá del método previamente escogido por el usuario
(que como recordaremos se almacenaba en la variable “met”). Empezaremos
introduciendo las instrucciones a ejecutar por el programa para el supuesto de
que la elección hubiese sido la “A” (método “lista”):
Puesto que en este caso vamos a
mostrar los resultados desde 1, lo primero que haremos será crear un variable
“x” que será igual a la unidad. Por su parte, crearemos otra variable (que
recibirá el nombre de “top”) la cual representará el número hasta el que queremos
que se extienda la tabla (la función “OK” se encargará de verificar de que se
trata, efectivamente, de un carácter numérico).
A partir de este punto (y
conociendo el primer y último número cuyo logaritmo se mostrará en la tabla)
crearemos un ciclo el cual se irá desarrollando mientras que la variable “x”
sea menor o igual al número introducido para la variable “top” (para lo que en
cada ejecución del ciclo el valor de “x” tendrá que aumentar en 1). Pero, a su
vez, el calculo que se va a efectuar en cada ejecución del ciclo, va a depender
de la opción introducida para la base (concretamente, diferenciaremos el caso
en el que la base sea el numero “e” de aquellos en que la base sea cualquier
número mayor de 1).
Así, para el caso en el que se
haya optado por el “logaritmo natural”, para cada ejecución del ciclo
visualizaremos el valor actual de “x” (que irá cambiando con cada ejecución) y
el resultado de calcular sobre dicho valor, su correspondiente logaritmo (ambos
números, los separaremos mediante una secuencia de escape y un carácter de
tabulación (‘\t’)):
Por su parte, para el caso del
logaritmo con base en un número natural:
En este caso prácticamente lo
mismo que en el caso anterior, con la salvedad que a la hora de calcular el
logaritmo tendremos que dividir el logaritmo (natural) del valor actual de “x”,
por el logaritmo de “B” (que como recordamos, es la base que establecimos con
anterioridad).
Finalmente, habrá que hacer que
“x” vaya aumentando en una unidad en cada ejecución del ciclo (y evitar caer en
un bucle infinito y para ir visualizando el logaritmo de los sucesivos
números). Para ello escribiremos:
Hasta aquí hemos visto el modo de
generar nuestra tabla, para el supuesto en que el método de visualización
escogido (“met”) fuera el de lista (empezando siempre por el 1 y hasta el
límite marcado por el usuario). Pero puede suceder que deseemos establecer un
rango personalizado (que no empiece necesariamente por 1).
El método que vamos a emplear
para definir el rango que queremos, es el de pedir a nuestro usuario potencial,
que introduzca los dos números que acotan dicho rango, separados por una coma.
De ese modo, creamos una variable (a la que denominaremos “nums”) que
almacenará dicho rango mediante el correspondiente input:
Sin embargo, al igual de lo que
nos sucedía cuando establecíamos la base del logaritmo, no nos vale cualquier
rango numérico, ya que necesitamos que dicho input cumpla tres requisitos: 1)
Que se trate de valores numéricos, para que la computadora pueda trabajar con
ellos. 2) Que el número de elementos introducido sea 2 (un valor de inicio y un
valor final) y 3) Que ninguno de los valores sea menor de 1.
Para ello tenemos que crear una
función que verifique que nuestro input cumpla esos tres requerimientos. A esta
función la hemos llamado (como se ve arriba) “ran_val” la cual aplicaremos
sobre el input introducido para la variable “nums”. Dicha función la habremos
definido con anterioridad y será la siguiente:
Así nuestra función “ran_val” va
a efectuar la comprobación del input mediante tres grandes pasos: Lo primero
que hará será tomar el input (“nums”) y hacer una separación de sus elementos
tomando la coma como criterio separador. De modo que mientras que la cantidad
de elementos sea distinta de 2 nos aparecerá un mensaje instándonos a
introducir los dos valores separados por una coma. Así, esta primera fase tiene
la doble misión de comprobar si el número de valores introducidos es 2 y si el
elemento separador es una coma, ya que si se usase otro elemento separador (para
este caso concreto), la longitud de la lista “nums” sería 1, tal y como se ve
en este ejemplo:
En la segunda fase de nuestra
función “ran_val”, empleamos un ciclo “for” mediante el cual la variable “i” va
tomando el valor de cada uno de los dos elementos de la lista, con los que
haciendo uso de “try” va “intentando” convertirlos al formato entero de modo
que si con alguno de dichos valores no consigue completar tal operación (por no
ser datos numéricos) se generará un excepción que devolverá un mensaje instando
a introducir solo valores numéricos.
La última fase del proceso de
comprobación, es la empleada para detectar si ambos valores introducidos son
mayores o iguales a 1, de modo que mientras (“while”) no se de esta condición
nos aparecerá un mensaje diciendo “rango no válido”.
Nótese que cada vez que instamos
al usuario a corregir su input, aplicamos sobre este, la función “ran_val” desde el principio.
Finalmente, una vez completados
todos pasos en la verificación (sin que se detecte ningún fallo en el input) la
función devolverá el rango establecido.
Una vez que tenemos el rango
establecido (en formato cadena) lo que haremos es pasar sus dos elementos (el
situado en la posición 0 y el situado en la posición 1) al formato entero. Lo
que haremos del siguiente modo:
Después de lo cual, usaremos la
función “.sort()” para ordenar los valores del rango de menor a mayor. Esto
último lo haremos de cara a que, nuestro programa, genere la misma lista,
indistintamente de si el usuario introduce como rango (por ejemplo) “2,10” o
“10,2”.
Finalmente, una vez que tenemos
nuestro rango establecido correctamente, emplearemos un ciclo (“for”) en el que
una variable “i” irá tomando los distintos valores existentes entre ambos
valores y sobre los que se irán calculando los correspondientes logaritmos en
función de la base escogida, del mismo modo que veíamos para el método “A” (en
lista):
Cabe señalar que, debido a que el
recorrido en el rango, excluye el último valor (tal y como se aprecia en el
ejemplo siguiente), para conseguir que nuestro valor último se incluya, lo que
haremos es establecer como final del rango, ese mismo valor más 1.
Y con esto ya tendríamos nuestro
programa generador de tablas logarítmicas para cualquier base que queramos. Lo
último que haremos será preguntar (haciendo uso de la función “ns” y la
variable “conti”) si quiere crear más tablas. De modo que en el caso de que la
respuesta sea negativa, finalice nuestro programa mediante la sentencia
“break”. Y en caso afirmativo, se haga uso de la función “subprocess.call” que
efectuará una limpieza de pantalla, dejándola lista para crear una nueva tabla
logarítmica.
La mencionada función "ns", se encargará de procurar que la respuesta del usuaro ante la pregunta solo pueda ser "n" (para "no") y "s" (para "si"). Dicha función sería la siguiente:
El código completo de este
programa puede verse integro en el
siguiente enlace de github:
Comentarios
Publicar un comentario