Guía de Python en 1 hora

Python en 1 Hora: Una Introducción Exprés

Esta guía rápida está diseñada para tener una visión general de los conceptos básicos de Python. El objetivo es que puedas entender y reutilizar cada parte del código en 1 hora.

Características Destacadas:

  1. Velocidad y Efectividad: En tan solo una hora, absorberás conceptos clave que te permitirán comprender la esencia de Python y su poderosa sintaxis.
  2. Enfoque Centrado: Esta guía rápida se concentra en los aspectos fundamentales para ofrecer una experiencia de aprendizaje concentrada y efectiva.
  3. Guía de Referencia Instantánea: Diseñada para ser tu guía de referencia rápida, Python en una Hora un recurso para conceptos y comandos fundamentales.
  4. Aprendizaje Activo: Aprovecha los ejemplos prácticos y metafóricos para una experiencia de aprendizaje activa y práctica en tiempo real.

Resumen del código:

1. Introducción y Configuración:

   – Resumen de Python

   – Instalación de Python

   – Configuración del entorno de desarrollo

2. Variables y Tipos de Datos:

   – Declaración de variables

   – Tipos numéricos (int, float,..)

   – Cadenas de texto y manipulación de cadenas

   – Tipo booleano

3. Operadores:

   – Operadores aritméticos

   – Operadores de comparación

   – Operadores lógicos

   – Operadores de asignación

4. Control de Flujo:

   – Estructuras condicionales (if, elif, else)

   – Bucles (for, while)

   – Instrucciones break y continue

5. Estructuras de Datos:

   – Listas

   – Tuplas

   – Conjuntos

   – Diccionarios

6. Funciones:

   – Definición de funciones

   – Parámetros y valores de retorno

   – Ámbito y duración de las variables

7. Conceptos Básicos de Programación en Estilo Python:

    – Comprensiones de lista

    – Funciones lambda

    – Funciones map, filter y reduce

8. Módulos y Paquetes:

   – Importación de módulos

   – Creación y uso de paquetes

9. Manejo de Archivos:

   – Lectura y escritura de archivos

   – Trabajo con diferentes formatos de archivos (texto, CSV, JSON)

10. Manejo de Excepciones:

    – Manejo de errores con bloques try-except

    – Generación de excepciones

11. Programación Orientada a Objetos (OOP):

    – Clases y objetos

    – Herencia y polimorfismo

    – Encapsulación y abstracción

12. Librerías y Marcos de Trabajo:

    – Introducción a librerías populares (por ejemplo, NumPy, Pandas)

    – Exploración de marcos web (Flask)

13. Conceptos Básicos de Pruebas:

    – Escritura y ejecución de pruebas

    – Pruebas unitarias con `unittest` o `pytest`

14. Trabajo con APIs:

    – Realización de solicitudes HTTP

    – Análisis de respuestas JSON

15. Desarrollo Web Básico con Python (Flask):

    – Introducción al desarrollo web

    – Uso de Flask para aplicaciones web

  • *Nota: Python en una Hora se centra en una entrega rápida y efectiva y está diseñado para proporcionar un vistazo general al lenguaje Python en un período de tiempo limitado.*

Estructura de archivos

Pre-requisitos

# Instala el paquete 'virtualenv' (si no está instalado)
pip install virtualenv

# Crea un entorno virtual
python -m venv venv

# Activa el entorno virtual
# En Windows
venv\Scripts\activate
# En macOS/Linux
source venv/bin/activate

#Instala las dependencias para la ejecución del código
pip install Flask requests

MicroGuiaPython.py

# 1. Introducción y Configuración
# Vamos a Preparar con python una cocina donde puedes cocinar varios platos (programas).

# La configuración implica preparar la cocina (instalar Python).
#Consulta https://www.python.org/ y los pre-requisitos indicados más arriba.



# 2. Variables y Tipos de Datos
#Las variables son como contenedores que contienen diferentes tipos de datos (ingredientes).
gramos = 50  # Tipo numérico
kilos = 1.14  # Tipo float
ingrediente1 = "Harina"  # Tipo cadena de texto
ingrediente2 = "Sal"  # Tipo cadena de texto
disponible = True  # Tipo booleano = verdadero/falso

# 3. Operadores
# Los operadores realizan acciones en los ingredientes (variables).
resultado = gramos + kilos * 1000  # Suma gramos y kilos convertidos a gramos
precio_por_kilo = 2.5
precio_total = kilos * precio_por_kilo
mensaje_precio = f"El precio total de {kilos} kilos de {ingrediente1.lower()} es ${precio_total:.2f}"

# 4. Control de Flujo
# El control de flujo dirige la ejecución del programa basado en condiciones (pasos de la receta).
if disponible:
    print(ingrediente1)  # Imprimir si el ingrediente está disponible
else:
    print("No disponible")

# 5. Estructuras de Datos
# Por ejemplo, para un Libro de recetas organizando múltiples recetas.
# Las estructuras de datos almacenan y organizan datos (recetas).
lista_recetas = ["Pizza", "Pasta", "Ensalada"]  # Lista
tupla_recetas = ("Sopa", "Estofado", "Curry")  # Tupla
conjunto_recetas = {"Hamburguesa", "Sándwich", "Wrap"}  # Conjunto
diccionario_recetas = {"Postre": "Pastel", "Bebida": "Té"}  # Diccionario

# 6. Funciones
# Las funciones son como electrodomésticos que realizan acciones específicas (tareas).
def cocinar_receta(receta):
    print("Cocinando...", receta)

#Se invoca a la función enviándole un valor.
cocinar_receta("pizza")

# 7. Conceptos Básicos de Pruebas
# Las pruebas implican verificar y ajustar el programa para la corrección.
# Verifica si la salida de cocinar_receta(receta) coincide con la cadena esperada
# Si la afirmación es falsa, se generará una excepción
def prueba_receta(receta):
    assert cocinar_receta(receta) == "Cocinando " + receta

# 8. Módulos y Paquetes
# Los módulos contienen código reutilizable
# Los paquetes son directorios que agrupan varios módulos relacionados
# Los módulos son como secciones en un libro de recetas, y los paquetes son colecciones de libros.
import herramientas_cocina.modulo_cocina as cocina  # Importar un módulo
print(cocina.mezclar(ingrediente1,ingrediente2))

# 9. Manejo de Archivos
# Guardar recetas en un archivo de recetas.
with open("archivo_recetas.txt", "w") as archivo:
    archivo.write("Receta: Pasta\nIngredientes: Harina, Agua, Salsa")
# Leer el contenido del archivo_recetas.txt
with open("archivo_recetas.txt", "r") as archivo:
    contenido_archivo = archivo.read()
# Imprimir el contenido
print(contenido_archivo)


# 10. Manejo de Excepciones
# El manejo de excepciones es como manejar erroros inesperados de forma controlada.
try:
    resultado = gramos / 0  # División por cero generará un error
except ZeroDivisionError as e:
    print("El error controlado es:", e)

# 11. Programación Orientada a Objetos (OOP)
# Explicación: La POO implica crear objetos personalizados con propiedades y comportamientos específicos (tareas).
# Creamos un objeto de la clase "ElectrodomesticoCocina" de nombre "Horno" con una función de "Asar"
class ElectrodomesticoCocina:
    def __init__(self, nombre):
        self.nombre = nombre

    def asar(self):
        print(self.nombre, "está asando")

horno = ElectrodomesticoCocina("Horno")
horno.asar()

# 12. Librerías y Marcos de Trabajo
# Una librería es un conjunto de módulos y paquetes que ofrecen funciones y herramientas
import mezclas_especias as especias  # Importar una librería
print(especias.condimentar(ingrediente1))

# 13. Conceptos Básicos de Programación en Estilo Python
# Programar de manera pythonica implica usar el estilo único y limpio de Python.
numeros_al_cuadrado = [num**2 for num in range(5)]  # Comprensión de lista

# 14. Trabajo con APIs
# Trabajar con APIs es como hacer pedidos (órdenes) de datos en línea a otro programa, web, etc
# Por ejemplo para comprar ingredientes online en una tienda nos conectamos a la API de su Web

#Vemos si la API de la Web responde. 
import requests
x = requests.get('https://ikerbit.com')
print(x.status_code)

# 15. Desarrollo Web Básico con Python
# Por ejemplo para presentar menu de un restaurante (desarrollo web).
from flask import Flask  # Usar Flask para aplicaciones web
import threading

app = Flask(__name__)

@app.route("/")
def inicio():
    contenido_web=f"""
    <h1>Bienvenido al restaurante de Python</h1>
    <p>gramos:{gramos}</p>
    <p>kilos:{kilos}</p>
    <p>Ingrediente: {ingrediente1}</p>
    <p>Lista recetas:{lista_recetas}</p>
    <p>contenido_archivo:{contenido_archivo}</p>
    <p>especias.condimentar(ingrediente):{especias.condimentar(ingrediente1)}</p>
"""
    return contenido_web

def run_flask():
    app.run(debug=True, use_reloader=False)

# Iniciar Flask en un hilo
flask_thread = threading.Thread(target=run_flask)
flask_thread.start()

# Detener el servidor Flask y finalizar el programa
flask_thread.join()

herramientas_cocina/modulo_cocina.py

# Este es el contenido del archivo "herramientas_cocina/modulo_cocina.py"

def cortar(ingrediente):
    return f"Cortando {ingrediente}"

def mezclar(ingrediente1, ingrediente2):
    return f"Mezclando {ingrediente1} y {ingrediente2}"

def batir(ingrediente):
    return f"Batiendo {ingrediente}"

mezclas_especias.py

# Este es el contenido del archivo "mezclas_especias.py"

def condimentar(ingrediente):
    return f"Sazonando {ingrediente}"

def marinar(ingrediente):
    return f"Marinando {ingrediente}"

Listo! Hasta aquí el código. Ahora lo ejecutamos para ver su comportamiento!

Ejecutar el código

python tu_archivo.py

Salida

Como se puede observar, la salida de la ejecución muestra los valores de las variables y funciones. El último lugar se muestra cómo Flask se queda corriendo en el puerto 5000.

Vamos a acceder al puerto 5000 de localhost (equipo en el que se está ejecutado) para ver el resultado.

Flask

Salida de ejecución. WebApp Flask

Listo!! La aplicación muestra el resultado esperado.

Ahora se puede finalizar la ejecución del programa presionando Ctrl+C.

Os dejo todo el código disponible en https://github.com/ikerbit/MicroCursoPython

Gracias

¡Gracias por llegar hasta aquí! Agradecemos tu tiempo y dedicación. Recuerda que esto es solo el comienzo del vasto mundo de Python. Continúa explorando y practicando, y no dudes en buscar más información mientras te adentras en el fascinante mundo de la programación.

¡Feliz codificación y mucha suerte en tu camino de aprendizaje!

Saludos, Ikerbit

Deja un comentario

Scroll al inicio