Esta lección es genial, porque nos ayuda a pasar lo procesado en nuestro programa a un archivo para el usuario, como lo sería un archivo txt o quizá es útil para nuestro programa para futuras implementaciones.

Para hacer esta prueba, primero tendremos un archivo txt con el texto en mayúsculas que dice “LO QUE ESTA AQUÍ ADENTRO ES UNA PRUEBA DE LECTURA DE TEXTO” como podemos apreciar en las imágenes. El archivo de texto está en la misma carpeta que el programa para motivos de simplicidad, en caso de querer tener el archivo en otro lado, habría que especificar la ruta.

Para empezar, debemos abrir el archivo dentro de nuestro programa, para esto debemos asignar la apertura a una variable que solo usemos para esto, en el ejemplo usaremos la variable “f”. la sintaxis para abrir un archivo es “variable=open(‘nombreArchivo.extencion’,’parametros’)”, donde los parámetros pueden ser :

Ahora ya con el programa, abrimos le archivo “prueba.txt” con el parámetro de lectura, porque nos interesa leer que hay dentro de él (línea 3). Después, para poder manipular la información, debemos asignarla a otra variable (cabe resaltar que la variable con la que abrimos el archivo no debe de cambiar ni sobre escribirse hasta que cerremos el archivo), para que lea lo que hay dentro usamos la función “variable.read()” y se la asignamos a una variable. (línea 4). En este momento esa variable tiene el contenido del txt, lo podemos verificar al imprimirla (línea 5 y línea 1 de la salida de la consola). Esta variable es un string, y lo podemos tratar como tal, en este caso, pasaremos a minúsculas todo el contenido (línea 7).

Ahora para escribir en un archivo, abrimos un archivo con un nombre diferente y con el parámetro “w”, que nos creara el archivo en caso de no existir y nos dejara escribir dentro(línea 8). Cabe resaltar que si abres el archivo con el parámetro “r”, no te dejará escribir nada dentro de él.

Una vez abierto, pasamos nuestro texto procesado al archivo con la función “variable.write (variable o texto que deseamos imprimir)” (línea 9) y procedemos a cerrar el archivo de la misma manera (línea 10).

Una vez ejecutado este programa, podremos apreciar que se ha creado otro archivo, tal cual especificamos con el texto que procesamos.

Esto es muy útil al querer pasar la información que procesemos en nuestro programa para manipularla después, o usarla de una base de datos muy rudimentaria, que en este blog no la recomendamos en lo absoluto =)

¿No te ha pasado que realizas un programa en donde esperas que el usuario introduzca un dato, pero no es lo que necesitas y tu programa no funciona bien (o no funciona de plano)?

Esto se debe a que debemos validar la entrada del usuario antes de que proceda en nuestro programa, así podemos evitar una gran cantidad de errores. Pero, ¿a qué nos referimos con validar? Es el comprobar que la entrada nos es útil, es decir, que si queremos un número entero, no recibamos un flotante o un carácter, o números negativos, etc.

Cuando sólo son números es simple, pero si introducen un carácter en vez de un número, el programa caerá en un error fatal y no podrá continuar. Hay manera de evitar esto. Supondremos el caso de que tenemos un programa que necesitamos que solo introduzcan valores entre el 1 y 5 y que no pase de ahí hasta que obtengamos un valor deseado. Para este escenario usaríamos la instrucción “try – except”, donde al igual que otras instrucciones de control, nuestro código debe de estar dentado correctamente para funcionar.

En la primera parte, “try:” introduciremos la línea (o líneas) que podrían generar un error en alguna circunstancia (línea 4 y 5). Esto hará que el programa no caiga en un error fatal (aun), buscara una excepción que sea relacionada a ese error, para eso usamos la segunda parte, “except” que va seguido del tipo de excepción, en este caso “ValueError” es la que necesitamos, y las líneas de código que se ejecutaran (líneas 6-8).

En palabras resumidas, le indicamos al programa que intentara obtener el input del usuario siempre y cuando este sea un entero, en caso de que no, no lo registrara.

Si pasa de esa parte el programa, sabes que el valor introducido es un entero, ya solo falta validar si está dentro de nuestro rango con una simple instrucción de comparativa (línea 9). Agregamos las instrucciones necesarias para que el proceso se repita hasta que tengamos el valor necesario y salga en ese momento.

Aquí podemos ver que el programa responde bien ante entradas de datos que no deseamos, manteniéndose firme hasta obtener lo que necesitamos.

La validación es de las partes más importantes en un programa, porque así nos aseguramos de que el programa no fallará por una equivocación por parte del usuario y que siempre estaremos manejando la información deseada =)

Un string es un tipo de variable, en español es una cadena, la cual almacena conjunto de caracteres, es decir, palabras, oraciones, cuentos o historias.

Para declarar un string, es necesario que nuestros caracteres estén entre comillas simples “ ’ “ o comillas dobles “ “ “ (si, puede ser raro apreciarlo así), no importa la que utilices, debe ser la misma para abrir y para cerrar, esta no se puede poner en el intermedio de la cadena (líneas 3 y 4), si queremos poner alguna de esas comillas dentro de la cadena, si es posible, solo debemos abrir y cerrar con una de las comillas y utilizar el otro tipo dentro de la cadena de caracteres (línea 7).

Al igual que las listas, podemos imprimir un carácter en específico o dividir la cadena en 2, según nos convenga (líneas 9 y 10 y líneas 4 y5 de la salida en consola)

Los strings tienen muchas más instrucciones que pueden realizar, aquí les diremos unas cuantas.

La concatenación de strings o de un string con la entrada del usuario. Esto se realiza con el signo suma “+” entre los strings, si parece muy fácil, pero lo es (línea 14-15 y línea 6 de la salida en consola). La concatenación también se puede dar en múltiplos, es decir, que se repita tantas veces queramos. De una manera muy similar al unir 2 strings, solo tenemos que multiplicarlo (línea 16 y línea 7 de la salida de la consola)

Otra de las funciones que podemos realizar con un string es pasar todas las letras a minúsculas o mayúsculas, según lo necesitemos, con el comando “tuString.lower()” y “tuString.upper()” respectivamente (líneas 17-20 y líneas 8-9 de la salida en la consola).

Por último, la función “len(variable)” que nos indicara de qué tamaño es nuestra cadena, espacios incluidos (línea 21 y línea 10 de la salida en consola)

Es normal que al introducirnos en la programación escuchemos el termino lista o tupla, ¿pero ¿qué son?

Ambas, son una variable que puede contener muchos valores diferentes, cadenas de caracteres, enteros, flotantes, etc. Esto con la finalidad de tener agrupada cierta información para un fácil manejo de la misma. Es más fácil tener en una lista la edad de 10 personas que tener 10 variables diferentes para hacer el mismo trabajo.

Empezaremos explicando cómo usar una tupla.

Para declarar una tupla, lo haremos como cualquier variable, excepto que usaremos paréntesis “()” para almacenar el o los valores, cada uno de ellos separados por una coma “,” (línea 3 del código). Podemos usar la instrucción “type(variable)” para que nos diga qué tipo de variable será (línea 4 del código, primera salida en la consola). La tupla puede sobrescribirse totalmente con una tupla diferente, al igual una variable cualquiera (linea5). Se pueden dividir las tuplas según nos convenga, desde si queremos que no imprima el primer valor o que no se impriman los últimos 4; en el ejemplo vemos como se omiten los 3 primeros valores (línea 7, línea 3 de la salida en la consola) y después omitimos los 2 últimos valores (línea 8 del código y línea 4 de la salida en consola).

Las listas pueden hacer exactamente lo mismo que las tuplas, pero ¿qué las hace diferentes?

La respuesta es sencilla, que son mutables, es decir, que se pueden modificar fácilmente, se puede alterar el tamaño de la lista, se puede reducir el tamaño, modificar los valores internos de la lista, algo que en las tuplas no se puede realizar.

Empezando con una de las diferencias, la lista al declararse, se tienen que poner el o los valores entre corchetes “[] “, separando cada valor entre comas (línea 3), al igual que con las tuplas, podemos verificar el tipo de variable con la instrucción “type(variable)” (línea 4 y primera salida en consola), se puede sobreescribir completamente (línea 5) y se puede partir en 2 según nos convenga (línea 7 y 8, y línea 3 y 4 de la salida de consola).

Hasta ahora todo es igual que en una tupla, ahora veremos la mutabilidad.

Podemos modificar cualquier elemento de la lista como si fuera una variable, solo tenemos que indicar de que elemento nos referimos poniendo entre corchetes “[]” la posición del elemento que queremos modificar (Cabe recordar que los lenguajes de programación inician los conteos desde el 0, no el 1) de esta manera si queremos modificar el primer valor, se encuentra en la posición 0 (línea 10 y línea 5 de la salida en consola), así mismo podemos eliminar un elemento de la lista, usando la instrucción “del” y “lista[posición]” (línea 12 y línea 6 de la salida en consola). Y también podemos ver un elemento en específico de la lista, de la misma manera en la que hemos estado trabajando “lista[posición]” (línea 14 y línea 7 de la salida de la consola).

Cabe resaltar que para indicar la posición podemos usar enteros o alguna variable tipo entero.

La utilidad de las listas es más amplia en el mundo de la programación, ya que nos sirve para ordenar datos (es muy fácil ordenarlos cuando están en una lista), nos pueden servir para alojar mucha información de manera temporal, búsquedas, etc.

Con esto vimos que la diferencia entre tuplas y listas es la mutabilidad, una tupla no puede alterarse un valor de la tupla, hay que sobrescribirla completamente mientras que una lista si se puede modificar. Si queremos tener varios datos en una variable, pero no nos interesa modificarlos en algún momento, lo ideal seria usar una tupla, pero si queremos modificar el orden o los valores, necesitaríamos usar una lista.

La recursividad es un método muy utilizado en la programación, el cual nos permite ejecutar una función dentro de sí misma, realizando un proceso muy similar a las iteraciones de los ciclos while y for. Suena algo revoltoso, (y lo es), pero es más fácil explicarlo con ejemplos.

Algo interesante, es que el fin de cada iteración va de atrás hacia adelante, es decir, la última iteración es la primera que termina, y la primera es la última en finalizar.

Un ejemplo para visualizar mejor esto último:

Realizando el ejemplo que hemos utilizado en while y for, calcularemos el factorial usando una función recursiva:

Echando un vistazo más a detalle:

Sí, la recursividad es bastante confusa de inicio, pero al dominarla nos ayuda a entender y tener un mejor funcionamiento dentro de nuestros futuros programas.

Otra manera de hacer iteraciones es con la instrucción “for”, que la podemos traducir como “para”, que a diferencia del while, for se le estable desde un principio a que se le hará una iteración, que generalmente ésta es su indicación de salida de la instrucción. La instrucción for tiene múltiples sintaxis, que dependen mucho de lo que queramos realizar con el ciclo. Los dos que veremos son los siguientes:

for variable in cadena:
      bloque de código

Podríamos leerlo como: “para la variable en la cadena” que nos puede ayudar a entender un poco mejor la instrucción. Un ejemplo:

Otro ejemplo divertido:

Son ejemplos sencillos, obviamente podemos realizar más cosas dentro de cada ciclo.

Otra sintaxis que podemos utilizar para el for es:
for variable in range(parámetro del rango):
      bloque de código

Esta es la manera en la que otros lenguajes de programación utilizan el for; aquí vemos que remplazamos la cadena con range() , range nos otorga la posibilidad de hacer iteración usando un “contador” que por default irá incrementando de uno en uno, iniciando en el 0.

Los parámetros de range pueden ser:

(cantidad de números)

(inicio de conteo, fin de conteo) [usando incrementos de uno]

(inicio de conteo, fin de conteo, valor del incremento) [se pueden usar valores negativos]

Otros ejemplos:

También aquí podríamos realizar más operaciones con el ciclo. Usando un ejemplo del ciclo while, para poder hacer una comparativa, realizaremos el cálculo del clásico factorial usando la instrucción for.

Al igual que con el ciclo while, debemos tener cuidado de no generar bucles infinitos con las condiciones en el range, porque esto es más fácil que caer en un bache conduciendo por López Mateos 🙂

¿Qué es una iteración? Es el realizar la misma acción una y otra vez. Como cuando buscamos un archivo específico que está en un contenedor lleno de archivos. Tendríamos que ir uno a uno, revisándolos hasta encontrar el que queremos. Es una tarea tediosa y para eso nos auxiliamos con la computación.

Y bien, ¿cómo lo hacemos? Existen varias maneras de realizar iteraciones, vamos a empezar con la instrucción “While” que se traduce a “mientras”. La instrucción while, al igual que la instrucción if, requiere de una condición, que mientras se esté cumpliendo, el ciclo while se ejecutará.

La sintaxis más simple de un while es:
while(condición):
      bloque de código

Como siempre, cuidar la identación pero, además, hay que cuidar que la condición de nuestro while se pueda cumplir o poner una condición de salida, que si no, el bucle será infinito y no queremos eso. 

Veremos un ejemplo sencillo.

Donde vemos que la condición del while es que sea menor a 10 y dentro del código hacemos un incremento con cada iteración. Cabe resaltar que se está repitiendo el bloque de código del while tantas veces es necesario para cumplir con nuestra condición.

Y bien si quiero tener múltiples maneras de salirme, ¿cómo lo hago? Es fácil, hay otras instrucciones que nos permiten controlar las iteraciones. Como lo es la instrucción break y continue, traducidas como romper o continuar, respectivamente.

Para la instrucción break, si dejamos que se ejecute, en ese momento se saldrá del ciclo while y seguirá con el resto del programa, si es que hubiera uno.

Para la instrucción continue, al ejecutarse, en ese momento pasaremos directamente a la siguiente iteración, es decir, no terminará ese ciclo y empezará uno nuevo.

Y como último, un ejemplo útil, el clásico ejercicio de cómo calcular un factorial usando un while:

Como vemos, cada iteración va a actualizar el valor del factorial, multiplicando por el valor actual de la iteración 🙂

La anidación es definida como poner condicionales dentro del bloque de código de otra condicional y así sucesivamente. ¿Para qué nos sirve esto? Para poder tener un mejor control con la información que manejemos, un cribaje más estrecho y ordenado, pero debemos de tener cuidado, que al anidar instrucciones podemos hacer un revoltijo en nuestro código y solucionar un error podría volverse una pesadilla.

Usando una versión más completa del ejemplo de condicionales, aquí podemos ver que el control de la información es mayor. El programa hará muchas más comparaciones, anidadas en los respectivos else, es altamente expandible y quizá, más entendible, a comparación de la versión anterior que vimos en el post de condicionales.

Otro ejemplo, es como sigue:

Para ver si el número es mayor que 10, primero tenemos que ver que sea mayor o igual a 0, luego que sea mayor o igual que 5 para después comprobar si el número es mayor que 10. Parece un mayor trabajo para algo tan simple, pero este trabajo extra nos permite un mayor control a prueba de errores.

Es muy, muy, muy importante cuidar la identación cuando se trabaja con anidación, pues Python reconocerá como apertura y cierre del condicional al que se encuentre en la misma columna, y esto podría ocasionar dolores de cabeza innecesarios. Sólo hace falta trabajar con un poco de orden y la anidación nos permitirá obtener resultados asombrosos.

Hasta ahora hemos visto que todos los programas se van ejecutando línea tras línea, pero ahora veremos bifurcaciones en su ejecución. Veremos las condicionales dentro del programa que nos abre un mundo de posibilidades a realizar. Pero primero, ¿qué es una condicional?

En los lenguajes de programación la condicional más básica es la instrucción “if”, que, en español, la traducción “si” (no de afirmación). Como ejemplo: SI haces la tarea, entonces puedes comer helado.

¿Cómo funciona la instrucción “if”?

Es muy simple,

if(condición):
      código a ejecutar

Al igual que en las funciones, es muy importante identar el código para que el compilador reconozca que parte del código pertenece al if.

Condiciones: todas las condiciones se basan en la comparación, entre variables, funciones, o verdadero o falso (True/False). Para ello podemos usar los siguientes símbolos:

==	Igual a
!=	No es igual a
> ó <	Mayor que  o  menor que
>= ó <=	Mayor o igual que  o  menor o igual que
%	Es un símbolo que indica si el residuo de una variable entre otra es igual o no a 0
or	Compuerta lógica “or” para juntar varias condiciones, donde con una que sea cierta, sucederá [Ejemplo: SI barres O SI trapeas, puedes comer helado]
and	Compuerta lógica “and” para juntar varias condiciones, donde todas tienen que ser cierta para que suceda [Ejemplo: SI barres Y SI trapeas, puedes comer helado]

En este ejemplo vemos que se le pide al usuario que escoja una opción, la cual vamos a comparar en nuestras condicionales. Si el usuario selecciona la opción 1, se le imprimirá el texto “Buenos días”, pero al llegar a la segunda condicional, al no cumplirse, no se ejecutará dicho código. De igual manera, como es en el caso de mostrado, si el usuario escoge la segunda opción, la primera opción, al no cumplir la condición, no entrará a esa parte del código. ¿Qué hubiera pasado si se ingresaba un 3? En ese caso, no se hubiera ejecutado ninguna función.

¿Qué pasa si no se cumple la condición? ¿Tenemos que considerar todas las posibilidades de una en una?  Por suerte, no. Existe otra instrucción, “else”, que en español significa “sino”. Como ejemplo: SI haces la tarea puedes comer helado, SINO, te castigare.

La instrucción else solo puede ir después de alguna instrucción de comparación (como lo es if o while (que veremos más adelante)), su sintaxis es mucho más simple, ya que no requiere una condición:

If(condición):
      bloque de código
else:
      bloque de código

Se tiene que seguir teniendo cuidado con la identación para que el compilador sepa que ese código es exclusivo de la instrucción else. Y la instrucción else tiene que estar al mismo nivel que la instrucción if a la cual pertenece.

En el ejemplo tenemos una condicional, que, si se cumple, imprimirá el texto “buenos días”, pero si no, imprimirá el texto “buenas tardes”. De esta manera logramos dar una respuesta sin importar lo que pueda introducir el usuario, generalmente se puede utilizar para señalar al usuario que su valor introducido no es válido para lo que nuestro programa está diseñado.

Finalmente, en Python tenemos una tercera instrucción, “elif”, que es una combinación entre el if y el else. Se podría traducir como “si no si” como, por ejemplo: SI haces la tarea puedes comer helado, SI NO SI, haces los deberes de la casa, puedes salir al parque, SI NO, quedarás castigado el fin de semana.

Como se puede apreciar en el ejemplo, elif permite que se realice otra comparación condicional, pero sólo si la instrucción anterior no fue cierta, como si fuera un else.

La sintaxis quedaría de esta manera:

If(condición):
      bloque de código
elif(condición):
      bloque de código
else:
      bloque de código

Al igual que en el else, hay que tener cuidado con la identación para que el compilador sepa reconocer a que if pertenece y que parte del código es del elif.

Si el usuario hubiera ingresado un 1, imprimiría “buenos días” y la instrucción elif y else serían ignoradas, porque la condición ya se cumplió.

Esto en forma básica, es el uso de condicionales, y la forma especial que existe en Python, elif 🙂

¿Qué es un módulo en Python?

Un módulo en Python es un archivo que contiene una o más funciones listas para su uso.

¿Cómo funcionan y cómo lo uso?

Primero se tiene que avisar al compilador que importaremos esas funciones, usando la sintaxis: import Nombre_modulo

Donde “import” es la palabra reservada para expresar la importación de un módulo y “Nombre_modulo” es el nombre del archivo de Python (sin la extensión .py)

Para llamarlas usamos la siguiente sintaxis:  Nombre_modulo.Nombre_funcion(parámetros)

Donde “Nombre_modulo” es el módulo al cual queremos acceder, “Nombre_funcion” es la función que queremos utilizar que está dentro del módulo, “parámetros” como anteriormente hemos mencionado, van las variables que se necesiten separadas por comas (,), sin ser obligatorio su uso.

Cabe resaltar que “Nombre_modulo” y “Nombre_funcion” están pegados por un punto (.) que es el que denota que la función está dentro del módulo.

Al usar estas funciones dentro de un módulo, se pueden seguir usando como variables, al igual como se explicó anteriormente, sólo que la referencia a ellas será un poco más larga y de más cuidado.

Ahora la gran pregunta… ¿Cómo creo un módulo?

Es fácil de crear, solo debemos de abrir un archivo de Python nuevo, poner las funciones que deseamos y guardarlo con un nombre que cumpla las reglas del nombramiento de variables (exceptuando que sí puede iniciar en mayúscula).

Como una nota muy importante, tanto los módulos como el código principal deben de estar guardados en el mismo directorio, es decir, la misma carpeta, como se observa aquí:

Para demostrar lo escrito, usaremos el ejemplo anterior pero pondremos todas las funciones dentro de un módulo, el cual importaremos y usaremos:

Esto es un módulo, así se usan y se crean 🙂