jueves, 12 de septiembre de 2019

Módulo de Login y Registro en Python - Gestión de Datos

Este artículo pertenece al proyecto Login y Registro de usuarios en python y es la continuación del capítulo de Template y menú del sistema. En esta ocasión introduciremos al sistema la gestión de los datos ingresado a través del menú creado anteriormente. El código lo puede encontrar acá.

Antes de iniciar debemos activar el entorno virtual e instalar bcrypt paquete que se usará para la encryptación del password. Para instalar bcrypt ejecutamos:

# pip install bcrypt

ACTUALIZACIÓN DEL MAIN

En esta ocasión solo actualizaremos la carpeta main.py, quedando de la siguiente forma:

# -*- coding: utf-8 -*-
import time
import bcrypt
from menu import MenuTemplate

username = []
email = []
password = []

def main():
    menu = MenuTemplate()
    opcion = menu.main_menu()

    if opcion == "1":
        ''' Sección para el registro de usuario '''
        data = menu.register()

        if data["username"] in username:
            print(f'Este username: <{data["username"]}> ya se encuentra registrado.')
        elif data["email"] in email:
            print(f'Este Email: <{data["email"]}> ya se encuentra registrado.')
        elif not data["password1"] == data["password2"]:
            print(f'Las contraseñas no coinciden.')
        else:
            password_hashed = bcrypt.hashpw(
                data["password1"].encode('utf8'), 
                bcrypt.gensalt()
            )
            
            username.append(data["username"])
            email.append(data["email"])
            password.append(password_hashed)

            print ("Se ha registrado en el sistema.")

        time.sleep(2)
        main()

    elif opcion == "2":
        ''' Sección para el login de usuario '''
        data = menu.login()
        index = 0
        try:
            index = username.index(data['username'])
            
            password_hashed = password[index]
            if not bcrypt.checkpw(data["password"].encode('utf8'), password_hashed):
                print("Username o password inválido.")
            else:
                print("Se ha autenticado de forma correcta.")

        except ValueError as e:
            print("Username o password inválido.")

        time.sleep(2)
        main()

    elif opcion == "3":
        ''' Sección para salir del sistema'''
        menu.exit_text()
        time.sleep(2)
        menu.clean_screen()

    else:
        ''' En caso de no coincidir la opciones anteriores '''
        print("\n Opción incorrecta. Intente de nuevo")
        time.sleep(2)
        main()

main()

Iniciemos estudiando los nuevos cambios ingresados al código por parte:

import time
import bcrypt
from menu import MenuTemplate

username = []
email = []
password = []

El primer segmento de código modificado se encuentra justamente al inicio. En ella se agregó:
  • La importación del módulo bcrypt (import bcrypt); éste módulo será requerido para encryptar la contraseña que el usuario ingresa al registrarse.
  • Luego creamos tres listas vacías: username, email, password, para almacenar los datos ingresados por el usuario.
La otra modificación se realizó cuando la opción es 1; es decir, cuando el usuario elige registrarse.

if opcion == "1":
        ''' Sección para el registro de usuario '''
        data = menu.register()

        if data["username"] in username:
            print(f'Este username: <{data["username"]}> ya se encuentra registrado.')
        elif data["email"] in email:
            print(f'Este Email: <{data["email"]}> ya se encuentra registrado.')
        elif not data["password1"] == data["password2"]:
            print(f'Las contraseñas no coinciden.')
        else:
            password_hashed = bcrypt.hashpw(
                data["password1"].encode('utf8'), 
                bcrypt.gensalt()
            )
            
            username.append(data["username"])
            email.append(data["email"])
            password.append(password_hashed)

            print ("Se ha registrado en el sistema.")

        time.sleep(2)
        main()

Nótese que la variable data recibe la información del registro en forma de diccionario. Luego:
  • Se verifica si el nombre de usuario (username) ingresado por el usuario se encuentra en la lista username (if data["username"] in username). De encontrarse se muestra un mensaje indicando que ese username ya se encuentra registrado.
  • También se verifica que el email ingresado por el usuario no se encuentre registrado (elif data["email"] in email). Si se encuentra registrado muestra un mensaje indicándolo.
  • Mas adelante se valida que el password1 y password2 coincida (elif not data["password1"] == data["password2"]). Si no coinciden se muestra un mensaje de error. 
  • Todas estas validaciones básicas permiten filtrar la unicidad del username e email, evitando que se registren dos usuarios con el mismo username e email. Asimismo que cuando se ingrese el password (las dos veces) sean coincidente.
  • Si no se cumple se procede a encryptar el password guardándolo en una variable llamada password_hashed, para posteriormente agregar los nuevos datos a las listas. Esto se hace con la función append, la cual permite agregar un nuevo elemento a las estructuras tipo lista.
  • Nótese que al mostrar los mensajes de error se concatena el texto con el diccionario dato colocando como prefijo f, siendo éste una forma elegante de combinar texto y variable. También se pudo haber hecho:
    • print("Este username: <"+data["username"]+"> ya se encuentra registrado").
    • print("Este username: <{}> ya se encuentra registrado".format(data["username"])).
Otra sección que sufrió modificación es donde se verifica la opcion 2, que corresponde al login de usuario.

elif opcion == "2":
        ''' Sección para el login de usuario '''
        data = menu.login()
        index = 0
        try:
            index = username.index(data['username'])
            
            password_hashed = password[index]
            if not bcrypt.checkpw(data["password"].encode('utf8'), password_hashed):
                print("Username o password inválido.")
            else:
                print("Se ha autenticado de forma correcta.")

        except ValueError as e:
            print("Username o password inválido.")

        time.sleep(2)
        main()

De igual forma se recibe la información del login en forma de diccionario en la variable data. Después se:
  •  Crea una variable index cuyo valor por defecto es 0 (index = 0). Esta variable se utilizará para buscar el password en la posición donde se almacenó el username.
  • Se construye un bloque try - except esto debido a que dentro del try se ejecuta la instrucción username.index(data["username"]) la que permite obtener el index donde se encuentra el nombre de usuario ingresado por teclado. Si no se encuentra se dispara una excepción ValueError la cual capturamos en except. En otras palabras, se buscan dentro de la lista username el nombre se usuario teclado, si se encuentra se devuelve el index donde se encontró, sino se dispara la excepción. En la excepción mostramos un mensaje indicando que el Username o Password es inválido.
  • Si el nombre de usuario se encuentra dentro de la lista username se obtiene el index el cual es utilizado para extraer de la lista password el password encryptado (password_hashed = passsword[index]).
  • Usando una función de bcrypt.checkpw se compara el password ingresado con el encryptado. Si no hay coincidencia se muestra un mensaje indicando Username o Password inválido. De lo contrario se muestra un mensaje indicado que se ha logeado correctamente.
Nótese que aunque en el login sea erróneo el username o el password se muestra el mismo mensaje "Username o password inválido", esto se hace por cuestiones de seguridad. Ya que si mostramos el error por separado le estamos indicios a un posible atacante sobre cual de los dos datos ingresado es el erróneo.

Con esto finalizamos esta capítulo. En el próximo añadiremos validaciones más específicas al dato del email y password.


Creación de entorno virtual para Python

ENTORNO VIRTUAL PARA PYTHON

Para éste artículo hemos de suponer que posee instalado Python3 en su sistema operativo, de no ser así recomendamos seguir el post de djangogirls. Bien, una vez instalado python tenemos la posibilidad de comenzar a desarrollar aplicaciones con él; y como este lenguaje de programación es lo máximo, es probable que te enganche y desees iniciar varios proyectos con él. Esto está muy bien y de hecho en Tratado Tecnológico te felicitamos si es así, sin embargo debes procurar separar todos tus proyectos con entornos virtuales para cada uno.
¿Por qué crear entornos virtuales? Pues imagina que estas trabajando en un Proyecto A en la que necesitas instalar paquetes o módulos especiales para desarrollar un característica en él; pues resulta que todos esos paquetes se instalan en el path principal de tu sistema operativo. ¿Esto es malo? realmente no. Pero supongamos que tu Proyecto A es funcionando perfectamente y un año después inicias otra app diferente la cual llamaremos Proyecto B, que casualmente usará un módulo ya instalado por A, mas este módulo tiene una actualización que B requiere; entonces resulta que lo actualizas y... oh no! El Proyecto A de hace una año deja de funcionar. ¿Por qué ocurrió esto? Es muy probable que la actualización del módulo no sea compatible con algunas funciones o métodos de la versión anterior, generando un problema.
Para evitar este tipo de inconveniente (que resultan ser un dolor de cabeza) se recomienda crear entorno virtuales para cada proyecto. Un entorno virtual es como una cápsula para cada app, en la que todo lo que se instala allí solo estará disponible para el proyecto en cuestión. Tomando el ejemplo anterior, si tenemos un entorno virtual para A y otro para B de forma independiente, la instalación de módulos en cada uno también lo será.

CREACIÓN DE ENTORNO VIRTUAL

Hay varias formas de crear un entorno virtual, seguramente en la web conseguirá varias maneras. La que usaremos acá hará uso de una herramienta llamada virtualenv. Para ello es necesario, como se comentó al inicio, tener instalado Python 3, y el módulo virtualenv. Para instalarlo solo debemos usar el gestor de paquete de python pip (pip ya viene por defecto con la instalación de python).

mi/directorio# pip install virtualenv

Con esto ya puedes crear un entorno virtual para cada proyecto de la siguiente forma:

mi/directorio# virtualenv env --python=python3

En la sintaxis de la instrucción tenemos varias cosa a considerar. Se ejecuta virtualenv para crear el entorno virtual y se dice que todo será gestionado por la carpeta env (la cual se creará después de la ejecución de esta instrucción). El nombre env se colocó como una notación general, pero usted puede darle el nombre que deseé, por ejemplo: myenv, venv, myentorno, etc., luego le indicamos cual versión de python deseamos usar, en cual, en este caso, es python3. Sino se coloca tomará como versión la que tengas por defecto.

Al pasar el tiempo es muy probable que deba actualizar la versión de python; por ejemplo, actualmente tengo instalado python2.7, python3.5, python3.7, entonces es muy ambiguo dejar en blanco la versión de python con la que se creará el entorno virtual. De hecho se puede ser más específico; note que en la instrucción anterior indiqué --python=python3, lo cual, en mi caso, puede ser 3.5 o 3.7, entonces para ser más específico le indico la versión de python3 a usar:

mi/directorio# virtualenv env --python=python3.7

Y listo. Eso creará una carpeta llamada env que permitirá gestionar todas las instalaciones de módulos para ese proyecto.

ACTIVACIÓN DEL ENTORNO VIRTUAL

Ya teniendo la carpeta del entorno virtual solo debemos activar el entorno virtual. Esto se hace justo en el mismo directorio donde se encuentra la carpeta env tecleando lo siguiente:

mi/directorio# source env/bin/activate

Esto hará que al inicio de la línea de comando aparezca el prefijo (env), tal como se muestra a continuación:
 
(env) mi/directorio# source env/bin/activate

Con lo cual nos indica que se encuentra activo el entorno virtual. Ya con esto podemos instalar todos los paquetes/módulos que necesita nuestro proyecto sin afectar las instalaciones de los otros, ya que estas instalaciones sólo tendrán efecto en este entorno virtual. Para desactivar el entorno virtual, solo debemos escribir:

(env) mi/directorio# deactivate

y volvemos a estado inicial.

Espero haya sido útil esta información y cómo recomendación, para cada proyecto sugerimos crear un entorno virtual independiente para evitar conflicto este todos tus app.

martes, 10 de septiembre de 2019

Programación en Python - Funciones

Con este artículo seguimos avanzando en la construcción del Curso de Programación en Python. Hasta los momentos hemos estudiado las estructuras más básicas que se pueden usar en Python: Variable, listas, tuplas, diccionarios, sentencias de control de flujo y de repetición, las cuales, sin embargo, nos han permitido crear programas completos y funcionales. Mas, lo visto hasta ahora esta muy lejos de ser lo mejor de los lenguajes de programación, aun quedan muchas cosas interesantes en python que nos permitirán elaborar aplicaciones más complejas. El tema que estudiaremos hoy son las funciones.

FUNCIONES

Una buena práctica en la programación es dividir el programa en partes, ya que nos permite reutilizar un segmento de código en diferentes partes del programa, pues esto se puede lograr gracias a las funciones. Supongamos que deseamos realizar una operación matemática, por ejemplo la resolvente, en diferentes partes de un programa; una opción es repetir el código la veces que sean necesario dentro del programa, pero la mejor es separar en una función esas instrucciones y llamar a la función cuando se requiera ejecutar dicho código.

Como se comentó anteriormente un función es un fragmento de código con un nombre asociado que realiza una serie de tareas y devuelve un valor. En otros lenguaje también se habla de procedimiento para algo similar que no devuelven valor. Pues en python no hay procedimientos, pero se puede emular al devolver un None (Nada).

La forma de declarar un función en python es la siguiente:

def mi_primera_funcion(dato1, dato2):
    print(dato1)
    print(dato2)

Lo que define una función es la palabra def, posteriormente, el nombre del función mi_primera_funcion y luego, entre paréntesis y separados, los argumentos dato1, dato2 que se pasan a la función. Debajo esto e indexado las instrucciones que se ejecutarán al llamar la función. En este caso imprimir el dato1 y dato2.

Lo que hemos hecho con lo anterior es definir la función. Para hacer uso de ella es necesario llamarla. Esto se logra colocando el nombre de la función y pasándole los datos correspondiente a los argumentos:

mi_primera_funcion("Tratado Tecnólogico", 3)

Al invocar esta función se ejecutará el código interno la cual consiste en imprimir lo que corresponde al dato1 (el string Tratado Tecnológico) y el dato2 (el número 3). Como nos podemos dar cuenta la asociación de argumento con el valor es de izquierda a derecha, es decir el argumento dato1 esta asociado al string y el dato2 al número.

Sin embargo también es posible modificar el orden de los parámetros si indicamos el nombre del parámetro al que asociar el valor a la hora de llamar a la función:

mi_primera_funcion(dato2 = 3, dato1 = "Tratado Tecnólogico")

Es importante que la cantidad de datos a pasar a la función coincida con la cantidad de argumentos que la función puede recibir. En este caso son dos argumentos y se pasan dos valores. Si se intentase pasar uno o más del permitido se obtendría un error.

También es posible, no obstante, definir funciones con un número variable de argumentos, o bien asignar valores por defecto a los parámetros para el caso de que no se indique ningún valor para ese parámetro al llamar a la función.

Los valores por defecto para los parámetros se definen situando un signo igual después del nombre del parámetro y a continuación el valor por defecto:

def mi_primera_funcion(dato1, dato2 = 4):
    print(dato1)
    print(dato2)

En la función anterior si le pasamos un solo dato no ocurre el error ya que el argumento dato2 tiene como valor por defecto 4. Por ejemplo:

mi_primera_funcion("Tratado Tecnólogico")

Si se le pase el valor correspondiente será ese el que utilice. Para definir funciones con un número variable de argumentos colocamos un último parámetro para la función cuyo nombre debe precederse de un signo * :

def varios_arg(dato1, dato2, *arg):
    print(dato1)
    print(dato2)
    for val in arg:
        print (val)

Esta sintaxis funciona ya que crea una tupla (en este caso de nombre arg) en la que se almacenan los valores de todos los parámetros extra pasados como argumento. Una forma de probar esto es llamando a la función pasando valores extra como parámetros:

varios_arg(1, "hola")
varios_arg(1, "hola", 3)
varios_arg(1, "hola", 3, "mundo")

Para la primera llamada, varios_arg(1, "hola") , la tupla otros estaría vacía dado que no se han pasado más parámetros que los dos definidos por defecto, por lo tanto no se imprimiría nada. extra En la segunda llamada arg valdría (3, ) , y en la tercera (3, "mundo") .

También se puede preceder el nombre del último parámetro con ** , en cuyo caso en lugar de una tupla se utilizaría un diccionario. Las claves de este diccionario serían los nombres de los parámetros indicados al llamar a la función y los valores del diccionario, los valores asociados a estos parámetros. Veamos un ejemplo de ello:

def varios_arg(dato1, dato2, **arg):
    print(dato1)
    print(dato2)
    print(arg["tercero"])

varios_arg("Hola", 2, tercero = "Mundo")

Fijense que en esta ocasión el tercer parámetro es un dato cuyo nombre es tercero y su valor, luego dentro de la función se asocia como un diccionario con una clave arg["tercero"]. Es importante que las claves del diccionario sean iguales a los nombres de los parámetros extras, de no ser así ocasionaría un error.

EJERCICIOS

Bien, es hora de practicar. La solución de estos ejercicios los podrás encontrar acá.

Ejercicio Nro. 1: Crear un programa que tenga una función que pase en mayúscula una cadena de caracteres y otra que la pase a minúscula.

# -*- coding: utf-8 -*-
def pasar_mayuscula(texto):
    return texto.upper()

def pasar_minuscula(texto):
    return texto.lower()

t = input("Ingrese el texto a formatear: ")
t_may = pasar_mayuscula(t)
print("El texto en mayúscula es: "+t_may)
t_min = pasar_minuscula(t)
print("El texto en minúscula es: "+t_min)

Explicación:
  • Se crean dos funciones pasar_mayuscula y pasar_minuscula las que reciben como argumento el texto a cambiar el formato. Al inicio se declara y posteriormente se llaman. La función pasar_mayuscula recibe como parámetro una cadena de caracteres y se formatea con upper(), cuyo objetivo es transformar el texto en mayúscula. Por otro lado, la función pasar_minúscula es similar con la diferencia que convierte todo el texto en minúscula gracias a lower(). En ambas funciones se retorna el resultado del cambio.
  • El programa inicia cuando se solicita la usuario que introduzca un texto a formatear. Esa información se guarda en la variable t.
  • Se crea la variable t_may que recibirá el resultado de la función pasar_mayuscula, la que, más adelante, se imprime.
  • De igual forma se crea t_min recibe el resultado de pasar_minuscula, e igualmente la imprime.
Ejercicio Nro. 2: Desarrollar un programa que ejecute una de estas operaciones matemáticas: Suma, resta, división o multiplicación. Se debe crear un función que haga la operación y se le pase como parámetros los dos números y el nombre de la operación a realizar.

# -*- coding: utf-8 -*-
def operacion(num1, num2, oper = 'suma'):
    if oper.lower() == "suma":
        return num1 + num2
    elif oper.lower() == "resta":
        return num1 - num2
    elif oper.lower() == "division":
        return num1 / num2
    elif oper.lower() == "multiplicacion":
        return num1 * num2
    else:
        return "Operación inválida"

oper = input("Qué desea hacer: suma, resta, division o multiplicacion: ")
n1 = int(input("Ingrese el primer número: "))
n2 = int(input("Ingrese el segundo número: "))
result = operacion(n1, n2, oper)
print(result)

Explicación:
  • Se crea la función operacion que recibe como parámetro el num1, num2 y oper. Los dos primeros son los números con los que se hará el cálculo y el tercer recibe un string indicando la operación a realizar. La función formatea la variable oper en minúscula para pasar todo el texto en minúscula (esto se hace por si el usuario escriba la palabra de una forma diferente a la esperada, por ejemplo: Suma, SUMA, etc). A su vez, se verifica que operación indicó y se procede a retornar el cálculo. Si la opción que ingresó el usuario no coincide se retorna un texto indicando el error.
  • El programa inicia solicitando al usuario cual operación hará. Posteriormente solicitando los valores a operar. Al tener estos datos se llama la función y se pasa los datos como parámetro.
  • Al final se imprime los resultados.
Bien amigos. Con estos dos ejercicios concluimos este artículo. En el siguiente post estudiaremos la creación de Clase en Python.

lunes, 9 de septiembre de 2019

Módulo de Login y Registro en Python - Templates y menu

Con este post damos inicio al proyecto de desarrollo de un Módulo de Login y Registro de Usuario en Python. Como requerimiento es necesario que tengas instalado Python 3. Así como también recomendamos crees un entorno virtual para gestionar los paquetes que se instalarán en tu app. Si aun no sabes como crear un entorno virtual para tus proyectos, te sugerimos leas esto primero --> Creación de entorno virtual.

Hoy iniciaremos creando la estructura inicial de nuestro proyecto y desarrollando el template/menu para solicitar y mostrar la información por consola. El código presentado a continuación la puedes clonar desde mi cuenta github.

ESTRUCTURA DE LA APP

app  # paquete app
  |-> main.py  # archivo principal del app
  |-> menu.py  # funciones para los menús del app  
La estructura tiene un paquete llamado app. Dentro de él dos archivos .py, el main donde se concentrará la gestión principal de la app, y menu donde estará la clase y métodos para mostrar el menú y solicitar los datos al usuario.

DESARROLLANDO EL MENÚ

En el archivo menu.py se crea una clase para mostrar la plantillas y menú del proyecto. El código es el siguiente:
# -*- coding: utf-8 -*-
import os

class MenuTemplate():
    def __init__(self,
                 title = "Tratado Tecnologico"):
        self.title = title
        self.clean = "clear" if os.name == "posix" else "cls"
    
    def clean_screen(self):
        os.system(self.clean)

    def head(self):
        print("\t-------------------------------------------------------")
        print("\t\t\t{}".format(self.title))
        print("\t Bienvenido al Módulo de Lógin y Registro de Usuarios")
        print("\t-------------------------------------------------------")
 
    def main_menu(self):
        self.clean_screen()
        self.head()
        print("1.- Registrar")
        print("2.- Logear")
        print("3.- Salir")
        opcion = input("Seleccione una opción --> ")
        return opcion

    def register(self):
        self.clean_screen()
        self.head()
        username = input("Ingrese username: ")
        email = input("Ingrese email: ")
        password1 = input("Ingrese password: ")
        password2 = input("Repita el password: ")
        return {
            "username": username,
            "email": email,
            "password1": password1,
            "password2": password2,
        }

    def login(self):
        self.clean_screen()
        self.head()
        username = input("Ingrese username: ")
        password = input("Ingrese password: ")
        return {
            "username": username,
            "password": password,
        }

    def exit_text(self):
        self.clean_screen() 
        self.head()
        print("\n")
        print("Gracias por usar nuestro sistema")

 La clase se llama MenuTemplate cuyos métodos son los siguientes:
  • __init__: Es el constructor de la clase. Su función es inicializar el objeto; esto es, cuando se crea un objeto de esta clase se ejecutará este método de forma automática. Él recibe como argumento self y title, el primer argumento es la que permite a __init__ (y como se verá más adelante también a los demás métodos) acceder a los atributos y métodos de la clase; en sí es como si le pasáramos la clase como argumento. El argumento title es un dato que debe ser pasado cuando se instancia el clase y si no se pasa él tomará como valor por defecto el string "Tratado Tecnológico". Dentro del método se asigna el valor de title a un atributo de la clase con el mismo nombre (self.title); asimismo se le asigna a un atributo llamado clean el comando para limpiar la pantalla; para ello se usa el módulo os importado al inicio y se le pasa el comando dependiendo del sistema operativo donde se ejecute el programa (self.clean = "clear" if os.name == "posix" else "cls").
  • clean_screen: Con este método limpiamos la pantalla de la consola. Nótese que hace uso del atributo clean inicializado en __init__ y al ser llamado éste método se ejecuta un comando del sistema operativo para limpiar la consola (os.system(self.clean)).
  • head: Es un método genérico que mostrará un encabezado en los menú del proyecto. Como se puede observar él hace uso del atributo title para mostrarlo en el encabezado.
  • main_menu: Con esto se muestra el menú inicial donde se le pide al usuario que indique lo que desea hacer: 1.-Registrarse, 2.-Logear o 3.-Salir. Antes de mostrar este texto se limpia la pantalla y se imprime el encabezado. Fíjense que para acceder a los atributos y métodos de la clase se debe anteponer el prefijo self seguido de punto (.), es por ello que para usar el método clean_screen se hace self.clean_screen, lo mismo se hace para el método head. Posterioemente se captura la tecla presionada por el usuario mediante la instrucción input, la cual se asigna a la variable opcion para luego retornarla.
  • register: Este método permite al usuario ingresar los datos de registro: username, email, password1 y password2, y se retorna los datos como un diccionario.
  • login: El método login solicita los datos para logearse: username y password, para luego retornar la información en forma de diccionario.
  • exit_text: Con él se muestra un texto de despedida al salirse del programa.

CONSTRUYENDO EL MAIN
En el archivo main.py concentra la estructura del programa. Así es el código de este archivo:

# -*- coding: utf-8 -*-
import time
from menu import MenuTemplate

def main():
    menu = MenuTemplate()
    opcion = menu.main_menu()

    if opcion == "1":
        data = menu.register()
        print("Los datos de registro son: ")
        print(data)
        time.sleep(2)
        main()
    elif opcion == "2":
        data = menu.login()
        print("Los datos de ingreso son: ")
        print(data)
        time.sleep(2)
        main()
    elif opcion == "3":
        menu.exit_text()
        time.sleep(2)
        menu.clean_screen()
    else: 
        print("\n Opción incorrecta. Intente de nuevo")
        time.sleep(2)
        main()

main()

Por los momentos se usará este archivo para validar la opción seleccionado por el usuario y para mostrar los datos que se han ingresado en el registro y login. Nótese que se tiene una función llamada main() (def main()), la cual se llama para que se ejecuté al final. Dentro de la función:
  • Se instancia la clase MenuTemplate(); para ello es necesario importarlo desde el archivo menu.py (from menu import MenuTemplate). Cuando se instanció la clase no se pasó el argumento title, por lo que tomará su valor por defecto. Sin embargo se pudo crear el objeto de esta forma MenuTemplate("Mi sistema") para asignarle el título al encabezado.
  • Se recibe la opción del menu inicial con opcion = menu.main_menu().
  • Se evalúa las opciones con los if. Si es una de las evaluadas se muestra los datos correspondiente; sino se vuelve a mostrar el menú inicial.
  • La función time.sleep hace que el programa se detenga por 2 segundos.
Para correr el programa habrá la consola, dirígete a path donde se encuentra el archivo main.py y ejecute python3 main.py.
Con esto concluimos esta post. Por los momentos sólo se ingresarán los datos y se mostrarán. En el siguiente post asignaremos esos datos en un arreglo y haremos algunas validaciones iniciales. 
Espero lo hayan disfrutado y sigan este tutorial. ¡Nos vemos!

sábado, 31 de agosto de 2019

Programación en Python - Control de Flujo (IF - WHILE - FOR)

Hola participantes. ¿Cómo se han sentido con el Curso? Recuerden que pueden dejar su comentarios o sugerencias al final del post. Hoy avanzaremos en un tema muy importante: Control de Flujo. Hasta los momentos hemos hecho programas lineales, donde se ejecutan instrucciones de forma secuencial. Aplicaciones desarrolladas de esta forma son de poca utilidad, ya que si deseamos tomar una decisión respecto a un dato, por los momentos, no podríamos hacerlo.

Los condicionales nos permiten dirigir el flujo del programa al evaluar una condición; haciendo que se comporte de una forma u otra, que ejecute un segmento de código o no. Así que para darle más vida a nuestros programas introduciremos condicionales en él. Qué te parece si estudiamos el primero de ellos.

IF - ELIF - ELSE

La forma más simple de evaluar una condición es con IF (Si inglés) seguido de la condición a evaluar y, para finalizar, dos puntos (:). Posteriormente debajo, en la siguiente línea e indentado, la instrucciones a ejecutar si se cumple la condición. Un ejemplo sería el siguiente: 

# -*- coding: utf-8 -*-
tu_web = "www.tratadotecnologico.com.ve"
if tu_web == "www.tratadotecnologico.com.ve":
    print("Tienes buen gusto")
Analizemos este código:
  • Primero creamos una variable llamada tu_web a la cual se le asigno el string de tu web favorita (www.tratadotecnologico.com.ve).
  • Luego se evalua el condicional de esta forma: Si tu_web es igual al texto "www.tratadotecnologico.com.ve" haz lo que sigue.
  • Lo que sigue es la impresión en pantalla del texto "Tienes buen gusto". Note que esta instrucción esta indentada (tabulada); esto se ha hecho de forma intencional y es la forma que tiene python de saber que esa instrucción pertenece a ese IF.
Te recomiendo que copies este código en un archivo .py y lo ejecutes o si utilizas Ninja IDE crea un nuevo archivo escribe el código y presiona Ctrl+F6; en el terminal que tiene integrado este IDE verás el resultado. Ahora si intentas modificar algo de texto que se asignó a la variable tu_web y ejecutas el programa no se mostrará algún texto pues no se cumple con la condición.

Ahora probemos mostrar otro texto si no se cumple la condición:

# -*- coding: utf-8 -*-
tu_web = "www.tratadotecnologico.com.ve"
if tu_web == "www.tratadotecnologico.com.ve":
    print("Tienes buen gusto")
if not tu_web == "www.tratadotecnologico.com.ve":
    print("Te recomiendo que visites www.tratadotecnologico.com.ve") 
Fíjate que ahora se agrega otro condicional en la que se evalúa si se cumple la condición: Si tu_web no es igual al texto "www.tratadotecnologico.com.ve" haz lo siguiente: Y lo siguiente es imprimir un texto de recomendación a nuestro blog.

Esto esta bien, pero cuando se evalúan dos posibles condiciones normalmente se utiliza la combinación IF - ELSE. Esto es: Si (IF) se cumple una condición haz esto Sino (ELSE) haz esto otro. Modifiquemos el código anterior para adaptarlo a esta nueva estructura:

# -*- coding: utf-8 -*-
tu_web = "www.tratadotecnologico.com.ve"
if tu_web == "www.tratadotecnologico.com.ve":
    print("Tienes buen gusto")
else:
    print("Te recomiendo que visites www.tratadotecnologico.com.ve")
Estudiemos éstas instrucciones:
  • Ya sabemos que en el if se evalúa que la variable tu_web sea igual al texto "www.tratadotecnologico.com.ve" y si esto es cierto se muestra el mensaje: "Tienes buen gusto".
  • La siguiente sentencia else indica que sino se cumple la condición anterior ejecuta las instrucciones de abajo.
Lo que hemos visto es funcional porque solo tenemos dos posibles alternativas, pero quisiéramos evaluar más de una condición. Pero si tenemos más de una condición podemos usar elif (que es una contracción de else if), esto quiere decir sino, si condición. Veamos un ejemplo para comprenderlo mejor.

# -*- coding: utf-8 -*-
numero = 0
if numero > 0:
    print("El número es positivo")
elif numero < 0:
    print("El número es negativo")
else:
    print("El número es cero") 
Nótese que ahora son tres evaluaciones:
  • Si el número es mayor a cero, se imprime el texto "El número es positivo".
  • Sino si el número es meno a cero, se imprime: "El número es negativo".
  • Sino se muestra: "El número es cero."
En este caso el else final serían las instrucciones que ejecutarán sino se cumplen las condiciones evaluadas previamente.

BUCLE WHILE

Hemos visto como lo condicionales nos permiten ejecutar cierto fragmento de código dependiendo de la evaluación de una condición; pero cómo haríamos si deseamos repetir ciertas líneas de instrucción mientras una condición se cumpla. La respuesta es: Usando instrucción de repetición (Bucles) como el WHILE y FOR.

El WHILE (mientras) nos permite ejecutar un segmento de código mientras una condición evaluada se cumpla. Como ejemplo veamos el siguiente código:

# -*- coding: utf-8 -*-
edad = 0
while edad < 18:
    edad = edad + 1
    print("Tu edad es "+str(edad)) 
Este ejemplo sencillo nos sirve para ilustrar el funcionamiento del WHILE.
  • Primero creamos una variable llamada edad la cual se inicializa con cero.
  • Posteriormente se coloca la instrucción while con la evaluación de la condición edad menor a 18. Esta condición pregunta si la variable edad es menor al 18. Si esto se cumple se ingresa al segmento de código debajo de ella.
  • Luego se introduce una razón de cambio de la variable que es evaluada. E este caso sumar uno a edad.
  • Finalmente se imprime en consola un texto indicando la edad.
  • Una vez se ejecuta la última instrucción dentro del bucle, se regresa al inicio a evaluar nuevamente la condición y si se cumplir se vuelve a correr las segmento de código interno.
  • Si ejecutamos este código mostrará el texto 18 veces, iniciando en la edad 1 hasta la 18.
  • Es importante tener en cuenta la razón de cambio dentro del bucle, ya que si no se cambia el valor de la variable a evaluar el bucle se ejecutará infinitamente. Por ejemplo, si quitamos la línea que suma uno a la variable edad, ella siempre valdría cero y cada vez que se evalúe la instrucción se cumplirá que cero es menor que dieciocho, haciendo que se corra para siempre (al menos que cierres el programa o apagues el PC).
Ahora, no siempre es un error que el bucle se ejecute infinitamente, es muy posible que esa sea nuestra intención. Entonces, si es así, bajo qué circunstancia queremos que el bucle nunca se termine. Supongamos que deseamos que se ejecute unas líneas de código hasta que el usuario teclee la palabra "salir". Creo que es mejor si lo codificamos ¿Les parece?

# -*- coding: utf-8 -*-
while True:
    palabra = input("Para terminar teclee 'salir' > ")
    if palabra == "salir":
        break 
    print(palabra)
Estudiemos este caso: El while True es una forma de decir ejecútate siempre. Entonces si es así, cómo haremos para que se termine, pues justamente después que se solicita que el usuario teclee una palabra, lo evaluamos con if con el string "salir", si esto se cumple se ejecuta la instrucción break. Es ésta instrucción la que rompe el bucle y lo fuerza a salir del while.

Otra forma de hacer esto es:

# -*- coding: utf-8 -*-
terminar = False
while not terminar:
    palabra = input("Para terminar teclee 'salir' > ")
    if palabra == "salir":
        terminar = True 
    print(palabra)
Si corremos este código obtendremos el mismo resultado, sin embargo nos ha permitido presentar la utilidad de la instrucción break dentro las sentencias de repetición. Otra instrucción que se usa dentro de los bucles es el continue; ésta no nos permite romper y salirse del bucle, pero sí pasar a la siguiente iteracción. Modifiquemos un poco el ejemplo anterior (El de mostrar las edades del 1 al 18) para mostrar solo las edades impares.

# -*- coding: utf-8 -*-
edad = 0
while edad < 18:
    edad = edad + 1
    if edad % 2 == 0:
        continue
    print("Tu edad es "+str(edad)) 
La diferencia de este código al anterior es que antes de mostrar el texto se evalúa la condición si el residuo de edad es igual a cero (en otras palabras esto verifica si el valor de edad es par), si esto se cumple entonces se ejecuta continue que no es más que indicarle a python que no siga con las instrucciones que siguen abajo y que pase a la siguiente iteracción.

BUCLE FOR

El for en Python es diferente a otros lenguajes de programación como C/C++. Acá esta pensado para iterar sobre una secuencia (listas, tuplas), y como tal intenta facilitar su uso para ese fin. La mejor forma de verlo es haciéndolo:

# -*- coding: utf-8 -*-
cuidades = ["Caracas", "Bogotá", "Quito", "Lima", "Santiago", "Buenos Aires"]
for ciudad in ciudades:
    print(ciudad) 
Como se digo anteriormente la sentencia for en python está pensado para iterar sobre secuencias. En el ejemplo anterior podríamos interpretar como para cada ciudad en ciudades hacer. En este caso lo que ocurre es que en cada iteracción se toma un dato de la lista cuidades y se asigna a la variable ciudad, para que luego dentro del for se manipule ese dato extraido. Acá simplemente se ha impreso el valor. Al ejecutar este pequeño código obtendremos la impresión de cada ciudad: Caracas, Bogotá, Quito, Lima, Santiago, Buenos Aires.

EJERCICIOS

Llegó el momento de ejercitarnos. La resolución de estos ejercicios los podrás encontrar acá.

Ejercicio Nro. 1: Crear un programa que solicite al usuario dos número e indique cual de los dos es el mayor.

# -*- coding: utf-8 -*-
#el_mayor.py
num1 = float(input("Ingrese el primer número: "))
num2 = float(input("Ingrese el segundo número: "))
if num1 > num2:
    print("El primer número es mayor que el segundo")
elif num1 < num2:
    print("El segundo número es mayor que el primero")
else:
    print("Ambos número son iguales")
Explicacion: 
  • Se crean dos variables num1 y num2 a las cuales se le asigna el valor que ingresa el usuario mediante la instrucción input(). El dato ingresado se formatea a float para tener el dato como un valor número real.
  • Con los condicionales se evalúa dos condiciones: Un primer if para saber si num1 es mayor a num2; un elif para evaluar si num2 es mayor a num1. Finalmente un else cómo condición final (sino se cumplen las dos condiciones anteriores).
Ejercicio Nro. 2: Creemos un programa que simule un juego de adivinanza en la que el usuario tenga tres intentos para adivinar un número del 1 al 100. Cada vez que usuario indique un número erróneo debemos decirle si es mayor o menor (según sea el caso) al número a adivinar. 

# -*- coding: utf-8 -*-
#juego_de_adivinanza.py
numero_adivinar = 55
intentos = 3
while True:
    num = int(input("Intente adivinar el número: "))
    if num == numero_adivinar:
        print("¡Felicitaciones lo ha logrado!")
        break
    elif num > numero_adivinar:
        print("Error: Este número es mayor al que debe adivinar")
    else:
        print("Error: Este número es menor al que debe adivinar")
    intentos = intentos - 1
    if intentos == 0:
        print("Ha usado todos sus intentos. Mejor suerte a la próxima")
        break
Explicación:
  • Iniciamos el programa creando dos variables numero_adivinar e intentos. La primero es el numero que el usuario debe adivinar y la segunda la cantidad de intentos que tiene el usuario para adivinar.
  • Dentro de un while que se ejecutará continuamente se solicita un número al usuario y se almacena en la variable num.
  • La variable se evalúa para saber si coincide con el valor de numero_adivinar; si esta condición se cumple se muestra un mensaje de felicitaciones y se rompe el bucle con break. De lo contrario se evalúa otras dos condiciones para saber si el dígito que ingreso es mayor o menor al número a adivinar.
  • Por último se disminuye en uno la variable intentos (intentos = intentos - 1) para descontar el intento actual y se consulta si la variable alcanzó el valor cero, es decir, si ya realizó tres intentos; de ser así se muestra un mensaje indicando que no lo logró y se rompe el bucle con break.
Ejercicio Nro. 3: Escribir un programa que muestre en pantalla el mensaje "Yo cursé <asignatura>  y obtuve <nota> pts.", donde asignatura y nota es una cátedra y su nota, respectivamente, de una lista creada por el programador de que contiene un diccionario con la información requerida.

# -*- coding: utf-8 -*-
#yo_estudio.py
asignaturas = [
    {"catedra":"Matemática", "nota": 18},
    {"catedra":"Física","nota": 16},
    {"catedra":"Química","nota": 19},
    {"catedra":"Inglés","nota": 17},
    {"catedra":"Historia","nota": 16},
    {"catedra":"Biología","nota": 18},
]
for asign in asignaturas:
    print("Yo cursé "+str(asign["catedra"])+" y obtuve "+str(asign["nota"])+ "pts.")
Explicación:
  • Lo primero que se hace es crear una lista cuyos datos será un diccionario que tiene la información de una cátedra y su nota. Por ejemplo la cátedra Matemática y su nota 18. Así ocurre con las otras materias.
  • Luego con un for iteramos la lista extrayendo uno a uno cada diccionario asignandolo a la variable asign
  • Posteriormente muestro el texto haciendo mención a cada clave del diccionario para obtener su valor asociado. Esto se logra haciendo asign["catedra"] para obtener la cátedra y asign["nota"] para obtener su nota.
Noten que en post anterior donde estudiamos las listas, tuplas y diccionarios no se hizo ejercicios, esto fue así porque para ver si aplicación es necesario combinarlo con alguna estructura de repetición como el for
Con estos ejemplos terminamos este capítulo. Espero les haya gustado. Si tienen alguna dudan puede hacérmelo saber mediante un comentario. Hasta pronto.

miércoles, 28 de agosto de 2019

Programación en Python - Listas, Tuplas, Diccionarios

Hola chic@s, espero que hasta los momentos les este gustando el curso de Programación en Python. En el artículo anterior se habló acerca de las variables y constantes; ellas no son particulares de Python, de hecho todos los lenguajes de programación las usan, sin embargo se pudo notar la particularidad con la que podemos usarla en python.

Hoy veremos otras estructuras de almacenamiento, tales como: Listas, Tuplas y Diccionario. Ellas nos permiten agrupar varias datos dentro de un misma estructura; por ejemplo: En una variable solo podemos guardar un dato a la vez (edad = 35), pero en un tipo de colección podríamos almacenar un listado de edades de una localidad.

Si esto te parece un poco extraño no te alarmes, ya pronto lo comprenderás. 

Listas
La lista es lo que en otros lenguajes se conocen como arrays o vectores. Lo potente de las listas en python es pueden almacenar cualquier tipo de datos: int, float, bool, e inclusive otras listas. Ahora, para crear una lista únicamente hace falta indicar, entre corchete y separados por comas, los valores que se almacenarán en ella. Veamos un ejemplo:

>>>mi_lista = [2, 'lista', 4.5, True, [9, 22]]
Fíjense que no sólo se indica un solo dato sino varios y de diferentes tipos. Bien, cada uno de esos datos tienen un posición dentro de la lista y para poder acceder es necesario indicar, entre corchete, el índice de la posición:

>>>mi_lista[0]
2
>>> mi_lista[3]
True
Notemos que con hacer mención a la lista con un índice (entre corchete) estaremos accediendo al dato en esa posición. Los índices de las listas inician en 0, por lo que si tenemos cinco valores almacenados en ella (como en este caso), para ver él último dato deberemos hacer mención al índice 4.

>>> mi_lista[4]
[9, 22]
En el caso de tener una lista dentro de otra, así como se muestra en este ejemplo, se debe utilizar dos veces el corchete: El primero para indicar la posición de la lista exterior y, el segundo, para la interior. Si queremos acceder al número 22 de la lista interna deberemos hacer:

>>> mi_lista[4][1]
22
También es posible modificar un dato usando este método. Para cambiar el dato de la posición 0 (el valor 2) haríamos:

>>> mi_lista[0] = 45
>>> mi_lista[0]
45

Una particularidad de la listas son la posibilidad de usar índices negativos y el slicing. El primer caso (índice negativos) se traduce en que el índice comienza a contar desde el final; es decir con [-1] accederíamos al último elemento de la lista, con [-2] al penúltimo y así sucesivamente...

>>> mi_lista[-1]
[9, 22]
>>> mi_lista[-3]
4.5

Con el slicing se puede acceder a porciones o rangos de elementos Si en lugar de un número escribimos dos números inicio y fin separados por dos puntos (inicio:fin) Python interpretará que queremos una lista que vaya desde la posición inicio a la posición fin , sin incluir este último. Si escribimos tres números (inicio:fin:salto) en lugar de dos, el tercero se utiliza para determinar cada cuantas posiciones añadir un elemento a la lista.


>>> mi_lista[0:3]
[45, 'lista', 4.5]
>>> mi_lista[0:4:2]
[45, 4.5] 

Las listas ofrecen mecanismos más cómodos para ser modificadas a través de las funciones de la clase correspondiente, aunque no veremos estos mecanismos hasta más adelante, después de explicar lo que son las clases, los objetos y las funciones.

Tuplas
La tuplas tienen el mismo comportamiento que las listas con dos diferencias fundamentales: 

a) Para definir sus datos no es necesario colocar los valores entre corchetes, y su separador es la coma:

>>> mi_tupla = 1,2,5.6,'tupla'
>>> mi_tupla
(1, 2, 5.6, 'tupla')
A pesar de ésto, como forma estándar, se proponen definirlos agrupando los datos entre paréntesis:

>>> mi_tupla = (1,2,5.6,'tupla')
>>> mi_tupla
(1, 2, 5.6, 'tupla')

Nótese que se obtiene el mismo resultado. Si se desea crear una tupla con un solo valor hay que colocar después de ésta, de forma obligatoria, la coma; de no ser así sería tomado como una variable y no una tupla; por ejemplo:

>>> mi_tupla = (1)
>>> type(mi_tupla)
int   # Variable
>>> mi_tupla = (1,)
>>> type(mi_tupla)
tuple  # Tupla
b) La otra diferencia es que las tuplas son inmutables, esto quiere decir que una vez creada sus valores no se pueden modificar. Intentémoslo:

>>> mi_tupla = (1,2,5.6,'tupla')
>>> mi_tupla[0] = 4
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment
A cambio de estas limitaciones las tuplas son más “ligeras” que las listas, por lo que si el uso que le vamos a dar a una colección es muy básico, puedes utilizar tuplas en lugar de listas y ahorrar memoria.

De resto, todo lo demás es similar; es decir, la forma de acceder a la información, el uso de índices negativos y slicing es igual.

>>> mi_tupla[0]
1
>>> mi_tupla[0:3]
(1, 2, 5.6)
>>> mi_tupla[-1]
'tupla'

Diccionarios
Los Diccionarios es un tipo de colección que relaciona una clave con un valor, y no un índice con un dato como las dos estructuras anteriores; por ejemplo creemos un diccionario de países y sus capitales:

>>>mi_dic = {"Venezuela": "Caracas", "Colombia": "Bogotá", "Ecuador": "Quito"}

Para crear un diccionario se debe agrupar la clave-valor dentro de llaves. En este caso la clave es el nombre del país y el valor es la capital. Por ejemplo si deseamos conocer la capital de Colombia lo hacemos colocando a su clave entre corchete:

>>> mi_dic["Colombia"]
'Bogotá'

Fíjense que ya no se usan los índices para acceder al valor sino a su clave. De hecho si intentamos colocar un índice nos da error por no conseguir esa clave:

>>> mi_dic[0]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 0
Al igual que en listas y tuplas también se puede utilizar este operador para reasignar valores.

>>> mi_dic["Colombia"] = "Cuidad de Bogotá"
>>> mi_dic["Colombia"]
'Cuidad de Bogotá'

Sin embargo en este caso no se puede utilizar slicing, entre otras cosas porque los diccionarios no son secuencias, si no mappings (mapeados, asociaciones); esto último lo veremos más adelante.

Conclusión 
Con esto concluimos este tema. En esta oportunidad no tendremos ejercicios debido que las  colecciones requieren usar otros tipos de estructuras para poder ver mejor su utilidad.

Espero hayan disfruta de éste capítulo. Nos vemos.

martes, 20 de agosto de 2019

Programación en Python - Variables

Hola estimados lectores, en la sección anterior se presentó la instalación de Python y logramos crear y ejecutar un programa. Nótese que la intención no era desarrollar algo complejo sino presentarles la forma en la que se crearán y ejecutarán los programas. En esta oportunidad estudiaremos el concepto de variables y constantes, y cómo se aplican en éste lenguaje de programación.

Variables

En resumidas cuentas una variable es un identificador que apunta a un espacio de almacenamiento en la cual podemos almacenar un dato para posteriormente manipularlo.

Es común en otros lenguajes de programación que al momento de definir una variable se deba establecer, en el mismo instante, el tipo de dato que almacenará, esto es: Indicar si el dato será un número entero, un número con decimal (número real), una cadena de caracteres o booleano; para python no es necesario, pues el tipo de dato se establecerá dependiendo de la información que este almacene.

Si una variable recibe como dato un número entero, su tipo de dato será int, será float si el dato es un número real, str si es una string o cadena de caracteres y si el dato corresponden a una valoración binaria (True o False), este será bool.

Ahora, probemos esto. Abra la consola interactiva de python, creemos unas variables y asignémosle un dato, para posteriormente ver que tipo de datos asumen:

>>>a = 1
>>>type(a)
int

>>>b = 2.3
>>>type(b)
float

>>> s = ‘A’
>>>type(s)
str

>>>c = True
>>>type(c)
bool

Fíjense que tenemos 4 variables: a, b, s, c cuyos valores asignados son 1, 2.3, 'A', True, respectivamente, las cuales al verificar que tipo de datos son -con la función type()- obtenemos int, float, str, bool. Con esto comprobamos que, las variables en python, no requieren se le indiquen que tipo de datos almacenarán, pues esta la asumirán dependiendo del valor que reciba.

Sin embargo, si queremos evitar ambigüedades al asignar un valor a una variable, podemos establecer que tipo al dato que recibirá. Para los casos anteriores sería:

>>> a = int(1)
>>>b = float(2.3)
>>> s = str(‘A’)
>>>c = bool(True)

Esto generará el mismo resultado anterior; si no me crees intentan corroborarlo verificando el tipo de datos con type(). Ahora, estas funciones también son útiles para cambiar el formato de las variables por ejemplo: Supongamos que tenemos un número real y queremos solo su valor entero; esto lo podemos lograr formateando el dato con int(); probésmolo:

>>> a = int(4.5)
>>>a
4
>>>b = 2.3
>>>a = int(b)
>>>a
2

Lo mismo ocurre con las otras funciones:

>>>s = str(23)
>>>s
‘23’
>>>b = float(3)
>>>b
3.0

Si deseas juega un rato con el cambio de formato para que se adapte un poco y también conozca sus limitaciones, por ejemplo: No se puede pasar un carácter a entero si este no es numérico. Con esto quiero decir:

>>>a = int(‘G’)
Traceback (most recent call last):
 File "", line 1, in 
ValueError: invalid literal for int() with base 10: 'G'

Esto genera un error debido a que el dato que se desea pasar a entero no corresponde a un dígito base 10. En otras palabras, no es un número.

Operadores

Ahora que ya conocemos como se crea una variable, veamos que operaciones se puede hacer usando los operadores por defecto.

Operador +: La función de este operador dependerá sobre que datos se esté ejecutando. Si se aplica en valores numéricos (enteros o reales) se realizará una suma algebraica; por otro la si se aplica en caracteres, se obtendrá una concatenación (unión de caracteres). Como siempre, probemos esto:
>>>a = 3
>>>b = 5
>>>a+b
8
>>>a = 3.6
>>>b = 5.4
>>>a+b
9.0
>>>a = 3
>>>b = 5.4
>>>a+b
8.4
>>>c=”Hola”
>>>s=”Mundo”
>>>c+s
“HolaMundo”

Nota: No se puede intentar sumar/concatenar un número con caracteres, esto generaría un error.

Operador -: Este operador sólo puede ser usado en valores numéricos y dependiendo de su uso puede representa una sustracción algebraica (resta) o una negación. Estudiemos los casos:
# Resta
>>>a = 3
>>>b = 5
>>>a-b
-2

# Negación
>>>a = 3
>>>-a
-3

Nota: No se puede intentar substraer un número con caracteres, esto generaría un error.

Operador *: Este operador también se puede aplicar tanto para valores numéricos como caracteres. En el primer caso funciona como una operación de multiplicación y en el segundo como repetidor de caracteres. Acá unos ejemplos:
>>>a = 3
>>>b = 5
>>>a*b
15

>>>c=”Hola”
>>>c*3
'HolaHolaHola'

Operador **: Esta forma de presentar el símbolo (doble **) indica que se debe aplicar como un exponente y solo puede ser usado para datos numéricos. Esto es:
>>>a = 3
>>>a**3  # a elevado a la 3
27

Operador /: Acá se realiza una división, la cual puede ser usado con valores numéricos.
>>>b = 5.6
>>>b / 2
2.8

Operador //: Cuando el símbolo es doble se realiza una división, pero a diferencia del anterior el resultado será la parte entera de la división. Ejemplo:
>>>b = 5.6
>>>b // 2
2.0

Operador %: Es usado en valores numéricos para obtener el resto de una división.
>>>b = 7
>>>b % 2
1

Constantes

Las constantes son variables cuyo valor no cambia durante el proceso de ejecución del programa. Un ejemplo podría ser los días de los meses del año, las cuales, a excepción de febrero, siempre tiene la misma cantidad de días: Enero = 31, Marzo = 31. Ellos son datos que no variaran por lo que podrían establecerse como constantes.

Bien, en otros lenguajes de programación se coloca un prefijo para indicar que esa variable será constante y, aunque intentes modificarlo, el programa no te dejará cambiar su valor. En Python no existe esta característica; en otras palabras no podemos establecer una constante y que el programa impida su cambio, por lo que como buena práctica se establece una notación como recordatorio o notificación de que esa variable se trata de una constante. Usando el ejemplo de los meses, en Python colocaríamos:

>>>ENERO = 31
>>>MARZO = 31
>>>PI = 3.1415

Ejercicios

Bien, yo creo que ya estamos listo para entrenar un rato. Todos los ejemplos que presenté anteriormente fueron probados en la consola interactiva de python. Esta vez crearemos un archivo con extensión .py y escribiremos allí nuestros programas ¿Te parece? Estos ejercicios los podrás encontrar en mi cuenta github presionando aquí

Ejercicio 1: Solicitar la usuario que ingrese su nombre y mostrar en pantalla “Bienvenido al Curso de Programación en Python Wilfred!”

# -*- coding: utf-8 -*-
#bienvenido_name.py
nombre = input("Introduzca su nombre: ")
print("Bienvenido al Curso de Programación en Python "+nombre+"!")


Explicación:
  • La primera línea de instrucción (# -*- coding: utf-8 -*-) permite que se pueda colocar caracteres especiales en las cadenas de texto. Ejemplo de caracteres especiales son las vocales con acento, la letra ñ, entre otros. No es obligatorio colocarlo, sin embargo si no aparece y se intenta colocar un texto con una letra con acento, la ejecución dará error.
  • Solicitamos al usuario que ingrese su nombre, esto lo hacemos con la instrucción input(), la que permite que se muestre en pantalla el texto que esta entre comillas “Ingrese su nombre” y además detiene el programa esperando que el usuario ingrese información por teclado y presione Enter. Lo que ingresa el usuario se guardará en la variable nombre.
  • Con la instrucción print() mostramos una información por pantalla. En esta ocasión mostramos un texto concatenado (con el operador +) con la variable nombre, lo que nos permite imprimir el string deseado.

Ejercicio 2: Solicitar al usuario que ingrese una cadena de texto y la cantidad de veces que desea que imprima ese texto.
 
# -*- coding: utf-8 -*-
#n_veces_cadena.py
cadena = input("Ingrese el string que desea imprimir: ")
veces = int(input("Indique las veces a repetir: "))
print(cadena*veces)

Explicación:
  • Al igual del anterior se solicita con input() al usuario que ingrese la información deseada (La cadena de caracteres a imprimir y las veces que se mostrará). Una característica de la instrucción input() es que lo ingresado por el usuario se almacena como caracter, por lo que para almacenar la cantidad de veces que se desea se imprima el texto debo convertirlo a entero, para ello lo antecedo con la instrucción int().
  • Para imprimir el texto la cantidad de veces uso el operador * dentro de la instrucción print().

Ejercicio 3: Solicitar al usuario ingrese dos número enteros o reales y aplicar sobre ellos: suma, resta, multiplicación, división y exponente.
 
# -*- coding: utf-8 -*-
#operaciones_aritmeticas.py
num1 = float(input("Ingrese el primer número: "))
num2 = float(input("Ingrese el segundo número: "))
suma = num1 + num2
print("La suma es: "+str(suma))
resta = num1 - num2
print("La resta es: "+str(resta))
print("La multiplicación es: "+str(num1*num2))
print("La división es: "+str(num1/num2))
print("El exponente es: "+str(num1**num2))

Explicación:
  • Se solicita al usuario que ingrese dos número y, en esta ocasión, se formatean tipo float. Esto es así para que, aunque se ingrese un valor entero, se almacene como real.
  • Se hace la suma y la sustracción y se muestran en pantalla. Nótese que esas variables suma y resta son tipo float, por lo que para poder concatenarlo lo formateo a str dentro de la instrucción print().
  • Para mostrar que no es necesario guardar los datos de la operación en una variable (como el caso de la suma y resta), la multiplicación, división y exponente se muestran en el print() formateando a str la operación directamente.
Con esto concluimos este capítulo. Hemos visto las variables y como se relacionan entre sí para crear pequeños programas. Para la próxima ocasión estudiaremos las listas, tuplas y diccionarios; estructuras que son muy utilizadas en los programas en Python. Espero haya sido de su agrado. Nos vemos en la próxima ocasión.

martes, 13 de agosto de 2019

Programación en Python - Introducción

El curso de Programación en Python cumple el objetivo de iniciarte en el mundo de la programación, pero en esta ocasión, con uno de los lenguaje de programación más versátiles que existe. Comenzará con un nivel dirigido a la adaptación de Python (suponiendo que ya conoces algún otro lenguaje de programación, si aun no conoces alguno puedes hacer nuestro curso de Programación Nivel Básico en C++) cuestión que dará la sensación de ser básico, mas en la medida que se avance se atenderá temas más complejos, por lo que, al final, puede considerarse como un curso de programación de nivel intermedio.

¿Por qué Python?

Hace ya un tiempo inicié en este blog con un curso de Programación Básica en C++. En esa oportunidad tomé la decisión de ofrecerlo de C++ debido que, por requerimientos de la Institución de Educación Superior donde laboro, los estudiantes se inician con él. Esta fue la razón principal, sobretodo, para aprovechar la oportunidad de usar esta plataforma como un apoyo a las clases presenciales.

Ahora, ya cubierto esta primera etapa, considero necesario introducir a los lectores a uno de los lenguajes de programación más versátiles y potente en este mundo. Python tiene la particularidad de poseer una sintaxis simple, clara y sencilla; el tipado dinámico, la gran cantidad de librerías disponibles y la potencia del lenguaje y más, lo convierten en un lenguaje potente, rápido y divertido.

La características principales de Python son:
  • Lenguaje interpretado o script: Un lenguaje interpretado o de script es aquel que se ejecuta utilizando un programa intermedio llamado intérprete, en lugar de compilar el código a lenguaje máquina que pueda comprender y ejecutar directamente una computadora (lenguajes compilados). La ventaja de los lenguajes compilados es que su ejecución es más rápida. Sin embargo los lenguajes interpretados son más flexibles y más portables.
  • Tipado dinámico: Esto se refiere a que no es necesario declarar el tipo de dato que va a contener una determinada variable, sino que su tipo se determinará en tiempo de ejecución según el tipo del valor al que se asigne, y el tipo de esta variable puede cambiar si se le asigna un valor de otro tipo.
  • Fuertemente tipado: No se permite tratar a una variable como si fuera de un tipo distinto al que tiene, es necesario convertir de forma explícita dicha variable al nuevo tipo previamente. Por ejemplo, si tenemos una variable que contiene un texto (variable de tipo cadena o string) no podremos tratarla como un número (sumar la cadena “9” y el número 8).
  • Multiplataforma: El intérprete de Python está disponible en multitud de plataformas (UNIX, Solaris, Linux, DOS, Windows, OS/2, Mac OS, etc.) por lo que si no utilizamos librerías específicas de cada plataforma nuestro programa podrá correr en todos estos sistemas sin grandes cambios.
  • Orientado a Objetos: La orientación a objetos es un paradigma de programación en el que los conceptos del mundo real relevantes para nuestro problema se trasladan a clases y objetos en nuestro programa. La ejecución del programa consiste en una serie de interacciones entre los objetos.

Instalación de Python

Python viene instalado de forma nativa en casi todas las distribuciones GNU/Linux sin embargo es muy posible que no posean la versión requerida para este curso. Estamos hablando de la versión 3.5 o superior. Para conocer la versión tecleemos en la consola:

>> python3 –version 

con esto les debería aparecer la versión instalada de Python v3, de no ser así recomendamos realizar su instalación. Dependiendo de su distribución de GNU/Linux y versión deberá aplicar algunas instrucciones.

Windows no tiene a python como lenguaje de programación nativo, por lo que deberás descargarlo de la página oficial (www.python.org) y realizar la instalación. También puedes seguir los pasos que indican en la web de djangogirls. Allí encontrarás los pasos para instalarlo para variadas plataformas.

Ejecución de un programa python

Ya instalado python tenemos todo listo para crear nuestro primer programa. Con Python contamos con dos formas de realizar esta tarea:

  • Mediante el intérprete interáctivo: 
Para usar el interprete interactivo tecleemos en la consola:

>> python3

En la consola debería aparecer el intérprete:

Python 3.7.4 (default, Jul  9 2019, 03:52:42) 
[GCC 5.4.0 20160609] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>>

dándonos la apertura a que escribamos nuestro código. Y cómo todo inicio de curso de Programación, lo primero que haremos es imprimir en pantalla la frase “Hola mundo!”. Para ello tecleamos:

>>print (“Hola mundo!”)

La respuesta es justamente el texto que se encuentra entre comillas. Así se identifican las cadenas de caracteres en python (realmente en todos los lenguajes de programación); esto quiere decir que la instrucción print (esta instrucción permite mostrar datos/información en pantalla) muestra el texto tal cual como se encuentra entre las comillas. Ahora, el interprete permite al programador seguir escribiendo instrucciones y ver su respuesta de forma inmediata. Pero si queremos condensar una cantidad de instrucciones y ver, posteriormente, su resultado lo más útil es crear un archivo ejecutable.

  • A través de un archivo ejecutable con extensión .py
Para crear un archivo ejecutable debemos disponer de un editor de texto plano. Creamos un nuevo archivo con nombre hola.py (Nótese que la extensión del archivo es .py) y dentro de él escribirmos

print (“Hola mundo!”)

Guardamos y cerramos el editor de texto. Posteriormente es nuestra terminal, nos ubicamos dentro del directorio donde creamos el archivo y tecleamos:

>> python3 hola.py

Con esto deberíamos obtener el texto “Hola mundo!”.

Utilización de un IDE

A pesar de poder escribir los programas de python en cualquier editor de texto plano y poder ejecutarlo desde nuestra terminal, lo mejor es utilizar un IDE (Integrated Development Environment) para escribir nuestro código. Un IDE que recomiendo para este curso es NINJA IDE (lo puedes descargar desde acá) debido que posee una consola integrada, lo que permite escribir y ejecutar el código sin salirse del programa.

Bien, si decidiste instalar NINJA IDE probémoslo corriendo el programa hola.py de la sección anterior.

Para ello abrimos la aplicación y creamos un nuevo archivo (puede ser el mismo nombre del anterior u otro) recordando que debe terminar con extensión .py y escribimos nuevamente:

print (“Hola mundo!”)


Luego en Project → Run File o Ctrl + F6 se ejecuta el programa



Con esto concluimos este capítulo de introducción a python. Quiero acotarles que es indiferente la forma en la que ejecutes tus programas .py, lo importante es que sigas el ritmo de este curso y aprendas a programar excelentes aplicaciones con python, de la forma que mejor te parezca.

A partir del próximo capítulo te prometo que iniciaremos con mucho más ejemplos para que practiques. ¡Hasta pronto!