Mostrando las entradas con la etiqueta Cursos. Mostrar todas las entradas
Mostrando las entradas con la etiqueta Cursos. Mostrar todas las entradas

lunes, 14 de octubre de 2019

Módulo de Login y Registro en Python - Conexión con MySQL

Hasta los momentos hemos creado una aplicación donde el almacenamiento de los datos se logra haciendo uso de SQLite. Esta primera integración se realizó con este gestor de base de datos ya que viene integrado por defecto en la instalación de Python, sin embargo no es recomendable para app que gestione grandes cantidades de datos. Es por ello que en esta ocasión se mostrará la integración con MySQL. El código de esté capitulo lo puedes descargar en mi cuenta github.

Es importante que tengas instalado MySQL en tu ordenador y que dispongas del usuario y contraseña para realizar la conexión; además se debe instalar un paquete que hace de interfaz entre python-msyql.
# pip install pymysql

ACTUALIZACIÓN DE LA ESTRUCTURA DE LA APP

create_sqlite_db.py # Archivo para la creación de la db y tablas
create_mysql_db.py # Archivo para la creación de la db y tablas
app  # paquete app
  |-> main.py  # archivo principal del app
  |-> menu.py  # funciones para los menús del app
  |-> validators.py # funciones para validar el email y password
  |-> db_conection.py # funciones para gestionar la db


Para esta ocasión se agregó el archivo create_mysql_db.py en el directorio principal con el propósito de crear la base de datos y tablas en MySQL.

CREACIÓN DE LA BASE DE DATOS

El archivo create_mysql_db.py contiene el script para crear la base de datos y la tabla. El código es el siguiente:
import pymysql

DB_HOST = "localhost"
DB_USER = "your_user"
DB_PASS = "your_password"

db = pymysql.connect(DB_HOST, DB_USER, DB_PASS)
cursor = db.cursor()
cursor.execute('CREATE DATABASE LoginDB')
cursor.execute('USE LoginDB')
cursor.execute('''
 CREATE TABLE users (
       username VARCHAR(50) PRIMARy KEY,
       email VARCHAR(50) NOT NULL,
       password VARCHAR(200) NOT NULL
       )
       '''
)
  • Lo primero que se hace es importar el módulo de pymysql.
  • Luego se crean las variables para la conexión a la base de datos: DB_HOST, DB_USER, DB_PASS. Para las últimas dos variables usted debe colocar el usuario y contraseña que creó al momento de instalar MySQL en su computador.
  • Posteriormente se crea una conexión pasando los datos de las variables, asimismo se crea un cursor de esa conexión.
  • En la siguientes líneas se ejecutan las instrucciones SQL para:
    • Crear la Base de Datos.
    • Usar la base de datos una vez creada.
    • Crear la tabla user.
Este script se debe correr una sola vez mediante la siguiente instrucción en shell:
# python create_mysql_db.py

MODIFICACIÓN DE DB_CONECTION

Para poder adaptar la aplicación con la gestión de los datos mediante MySQL se a modificado el archivo db_conection.py. En él no se ha eliminado la clase de conexión con SQLite sino que, por el contrario, se agregó una nueva clase llamada MySQLConection, cuyos nombres de los métodos son similares a la clase de conexión con SQL para facilitar la integración en el app. El archivo db_conection queda así:
import sqlite3
import pymysql

class SQLiteConection():
# Conexión con la Base de Datos
    def connect(self):
        self.con = sqlite3.connect('../LoginDB.db')
        self.cur = self.con.cursor()

    def create_user(self, username, email, password):
        self.connect()
        self.cur.execute(
         'INSERT INTO users (username, email, password) VALUES (?, ?, ?);',
            (username, email, password)
        )
        result = self.cur.lastrowid
        self.con.commit()
        self.con.close()
        return result

    def find_user_by_username(self, username):
        self.connect()
        self.cur.execute('SELECT * FROM users WHERE username = "{}"'.format(username))
        result = self.cur.fetchone()
        self.con.close()
        return result

    def find_user_by_email(self, email):
        self.connect()
        self.cur.execute('SELECT * FROM users WHERE email = "{}"'.format(email))
        result = self.cur.fetchone()
        self.con.close()
        return result


class MySQLConection():
    DB_HOST = "localhost"
    DB_USER = "your_user"
    DB_PASS = "your_pass"
    DB_NAME = "LoginDB"

    def connect(self):
        self.con = pymysql.connect(self.DB_HOST, self.DB_USER, self.DB_PASS, self.DB_NAME)
        self.cur = self.con.cursor()

    def create_user(self, username, email, password):
        self.connect()
        try:
            self.cur.execute(
                'INSERT INTO users (username, email, password) VALUES ("{0}", "{1}", "{2}")'.format(
                    username, email, password.decode("utf-8"))
            )
            self.con.commit()
            result = True

        except:
            result = False

        self.con.close()
        return result

    def find_user_by_username(self, username):
        self.connect()
        self.cur.execute('SELECT * FROM users WHERE username = "{}"'.format(username))
        result = self.cur.fetchone()
        self.con.close()
        return result

    def find_user_by_email(self, email):
        self.connect()
        self.cur.execute('SELECT * FROM users WHERE email = "{}"'.format(email))
        result = self.cur.fetchone()
        self.con.close()
        return result

  • La primera modificación que se realizar es importar el módulo de pymysql.
  • Posteriormente se agrega la clase MySQLConection, las cuales tiene los atributos para la conexión a la base de datos: DB_HOST, DB_USER, DB_PASS, DB_NAME (Acá deben sustituir el usuario y password que crearon al instalar MySQL).
  • Los métodos son los mismos que la clase usada para conectarte a SQLite, con la salvedad que fueron modificados para adaptarlo a la sintaxis de MySQL. 
ACTUALIZACIÓN DEL MAIN

El main es el archivo principal de la aplicación y para adaptarlo a los nuevos requerimientos se harán ajustes menores.
# -*- coding: utf-8 -*-
import time
import bcrypt
from menu import MenuTemplate
from db_conection import MySQLConection

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

    if opcion == "1":
        ''' Sección para el registro de usuario '''
        data = menu.register()
        
        if "username" in data:
            if mysql_db.find_user_by_username(data["username"]):
                print(f'Este username: <{data["username"]}> ya se encuentra registrado.')
            elif mysql_db.find_user_by_email(data["email"]):
                print(f'Este Email: <{data["email"]}> ya se encuentra registrado.')
            else:
                password_hashed = bcrypt.hashpw(
                    data["password1"].encode('utf8'), 
                    bcrypt.gensalt()
                )
                
                new_user = mysql_db.create_user(
                    data["username"],
                    data["email"],
                    password_hashed
                )
                
                if new_user:
                    print ("Se ha registrado en el sistema.")
                else:
                    print ("Ha ocurrido un error en la base de datos.")
        else:
            print(f"\n{data}")

        input("\nPresione una tecla para continuar...")
        main()

    elif opcion == "2":
        ''' Sección para el login de usuario '''
        data = menu.login()

        result = mysql_db.find_user_by_username(data["username"])
        if result:
            if not bcrypt.checkpw(data["password"].encode('utf8'), result[2].encode('utf8')):
                print("Username o password inválido.")
            else:
                print("Usted ha ingresado al sistema.")
        else:
            print("Username o password inválido.")
        
        input("\nPresione una tecla para continuar...")
        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()

  • Lo primero que vemos se ha modificado es la importación de la clase MySQLConection.
  • Luego se crea un objeto llamado mysql_db la cual es una instancia de la Clase MySQLConection.
  • Y con respecto a la sección anterior se reemplaza la instancia sqlite_db por mysql_db en todo el archivo main.
Con esto hemos concluido la adaptación de la aplicación para que trabaje con MySQL, así como también damos por concluido esta segunda fase, la cual consiste en establecer un mecanismo de permanencia de los datos almacenando los mismos en una base de datos. En el próximo capítulo iniciaremos la fase tres, en la que crearemos un entorno gráfico para la app, dejando atrás la interfaz de consola que hemos estado utilizando.

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.

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!

domingo, 27 de mayo de 2018

Ejercicios Propuestos C++




Los ejercicios propuestos a continuación pretenden ofrecerte algunos problemas para que los hagas a medida que vas avanzando en el curso. Si tienes duda o inconveniente resolviendo algunos de ellos, comenta y te apoyaré al respecto. Si deseas ver cómo los he resuelto puedes verlos en mi cuenta de github.

Escribe un Programa en C++ que:
  1. Muestre en pantalla el mensaje "Bienvenido". 
  2. Muestre en pantalla el mensaje "C++ no tiene misterios". 
  3. Muestre en pantalla la suma de 100 y 120. 
  4. Muestre en pantalla el producto de 50 y 51.
  5. Guarde en la variable x (entera) el número 23, en la variable y (entera) el número 24, en la variable z (entera) el número 25 y muestre en pantalla la suma de los valores de las tres variables.  
  6. Guarde en la variable x (entera) el número 10, en la variable y (entera) el número 11, en la variable z (entera) el número 12, calcule su producto y lo guarde en una variable llamada producto, y finalmente muestre en pantalla el valor de la variable producto.  
  7. Pida al usuario dos números enteros (que se guardarán en las variables a y b) y muestre su suma en pantalla.  
  8. Pida al usuario dos números enteros (que se guardarán en las variables n1 y n2) y muestre su producto en pantalla.  
  9. Pida al usuario dos números reales (que se guardarán en las variables dato1 y dato2) y muestre en pantalla el resultado de dividir dato1 entre dato2.  
  10. Pida al usuario dos números reales (que se guardarán en las variables dato1 y dato2). Si dato2 es cero,deberá mostrar un mensaje de error, y en caso contrario mostrará en pantalla el resultado de dividir dato1 entre dato2.  
  11. Pida al usuario dos números enteros (que se guardarán en las variables num1 y num2). Si num2 es cero,deberá mostrar un mensaje de error, y en caso contrario mostrará en pantalla el resto de la división de num1 entre num2. 
  12. Pida al usuario un número entero, diga si es par o impar,y repita todo lo anterior hasta que el número que se introduzca sea 0. (Nota: para saber si un número es par, se mira si el resto de su división entre 2 es 0). 
  13. Pida al usuario veinte números enteros y muestre su suma. 
  14. Pida al usuario veinte números reales y muestre cual es el mayor de ellos y cual el menor.
  15. Pida al usuario un número indefinido de números (mientras se tecleen números que no sean negativos). Después de la introducción de cada número aparecerá en pantalla información sobre el número de datos introducidos y la suma hasta el momento, así­: "Has introducido 5 números y su suma es 38" Se termina al ingresar un número negativo. 
  16. Pida al usuario un número entero y muestre en pantalla sus divisores (exceptuando el 1 y el propio número). Por ejemplo, si se introduce 20, deberí­a aparecer:
    2 es divisor de 20
    4 es divisor de 20
    5 es divisor de 20
    10 es divisor de 20  
  17. Mejora el ejercicio anterior para que avise si el número no tiene divisores, en vez de que la pantalla quede en blanco. 
  18. Pida al usuario un número entero y una letra, y muestre en pantalla la letra repetida tantas veces como indique el número. Por ejemplo, si el número es 10 y la letra es a, aparecerí­a: aaaaaaaaaa 
  19. Pida al usuario un número entero y muestre su tabla de multiplicar. 
  20. Pida al usuario un número real y diga cuantas cifras enteras tiene (pista: habrá que dividir varias veces entre 10). 
  21. Pida al usuario que teclee 20 números, que se almacenarán en una tabla. Después se debe mostrar en pantalla los 10 primeros, en la misma línea de pantalla, separados por espacios en blanco. 
  22. Pida al usuario que introduzca una palabra y la muestre al revés (por ejemplo: hola -> aloh). 
  23. Pida al usuario que teclee 10 números, que se almacenarán en una tabla. Después se debe mostrar en pantalla la suma de todos ellos, la media, el valor mínimo y el valor máximo. 
  24. Pida al usuario que introduzca una frase y cambie los espacios por guiones (por ejemplo: "como estas, juan" -> "como-estas,-juan"). 
  25. Pida al usuario que teclee 10 números, que serán almacenados en una tabla. Después se deberán mostrar todos en la misma línea, separados por punto y coma, y decir si alguno está repetido. 
  26. Pida al usuario que introduzca un número y diga si es capicúa (si se lee igual de derecha a izquierda que de izquierda a derecha, como el 12321). (pista: será interesante leer el número como cadena de texto). 
  27. Pida al usuario que introduzca una contraseña. Si en un máximo de 3 intentos no escribe la contraseña correcta (por ejemplo, "hola"), recibirá como respuesta "Acceso denegado". Si acierta la contraseña en tres intentos o menos, se le dirá "Acceso permitido". 
  28. Pida al usuario que introduzca su nombre (que se guardará en una cadena de texto) y después su apellido (que se guardará en otra). El programa deberá crear una nueva cadena de texto formada por el el apellido y el nombre, separados por una coma, y luego mostrarla en pantalla, así:
    Hola Sr. Gates, Bill 
  29. Calcule el factorial del número que introduzca el usuario. El factorial de un número se calcula multiplicando ese número por todos los menores que él, hasta llegar al uno: 3! = 3 * 2 * 1
    6! = 6 * 5 * 4 * 3 * 2 * 1  
  30. Pida al usuario que teclee los datos de 10 personas (sólo el nombre y el número de teléfono). Después se deberá mostrar en pantalla los nombres y los teléfonos de aquellas personas cuyo número de teléfono comience por 6.  
  31. Sea capaz de almacenar datos de hasta 100 personas (sólo el nombre y el número de teléfono). Aparecerá un menú en pantalla que permita añadir una nueva persona, ver los nombres de todas las personas almacenadas, ver el teléfono de una cierta persona (a partir de sus nombre), corregir los datos de una persona o salir. 
  32. Crea una función llamada "suma", que reciba como parámetros dos números enteros y devuelva como resultado otro número entero que sea la suma de ambos. 
  33. Crea una función llamada "división", que reciba como parámetros dos números enteros y devuelva como resultado un número real, que sea el resultado de dividir el primer número entre el segundo (con decimales). 
  34. Crea una función llamada "letraRepetida", que reciba como parámetros una letra y un número, y escriba en pantalla esa letra repetida en pantalla varias veces (tantas como indique el número), sin devolver ningún valor. 
  35. Crea dos funciones "solucionRC1" y "solucionRC2" que devuelvan las dos raíces de una ecuación de segundo grado. Además, deberás crear una función "existeSolucionRC", que devuelva un 1 si la raíz cuadrada tiene solución, o un 0, si no la tiene.
  36. Crea una función "raizCubica", que calcule la raíz cúbica de un "float", y devuelva otro "float" (pista: puedes elevar a 1/3 para hallarla).