Curso de programación con Python

Python es un lenguaje de programación de alto nivel, interpretado y de propósito general que ha revolucionado el mundo del desarrollo de software desde su creación por Guido van Rossum a finales de los años 80. Su filosofía de diseño enfatiza la legibilidad del código y la simplicidad, permitiendo a los programadores expresar conceptos en menos líneas de código que otros lenguajes como C++ o Java.

Características fundamentales

Python destaca por su sintaxis clara y expresiva, que utiliza la indentación para delimitar bloques de código en lugar de llaves o palabras clave. Esta característica fomenta la escritura de código limpio y consistente, facilitando su mantenimiento y comprensión.

El lenguaje sigue una filosofía resumida en "El Zen de Python", que incluye principios como:

• La legibilidad cuenta
• Simple es mejor que complejo
• Explícito es mejor que implícito
• La practicidad le gana a la pureza

Python es multiparadigma, permitiendo programar siguiendo diferentes estilos:

• Programación imperativa
• Programación orientada a objetos
• Programación funcional
• Programación procedural

Su tipado dinámico permite que las variables cambien de tipo durante la ejecución, lo que aporta flexibilidad al desarrollo. Además, es un lenguaje multiplataforma que funciona en Windows, macOS, Linux y otros sistemas operativos.

Ecosistema y aplicaciones

El ecosistema Python es extremadamente rico y diverso, con miles de bibliotecas y frameworks que extienden sus capacidades a prácticamente cualquier dominio:

• Ciencia de datos: NumPy, Pandas, SciPy
• Aprendizaje automático: TensorFlow, PyTorch, scikit-learn
• Desarrollo web: Django, Flask, FastAPI
• Automatización: Ansible, Fabric
• Análisis de datos: Matplotlib, Seaborn
• Computación científica: SymPy, Biopython

Python se ha convertido en el lenguaje preferido para:

• Análisis y visualización de datos
• Inteligencia artificial y aprendizaje automático
• Desarrollo web backend
• Automatización y scripting
• Desarrollo de aplicaciones de escritorio
• Educación en programación

Fundamentos del lenguaje

El curso comienza con los conceptos básicos de Python, incluyendo su instalación y configuración. Aprenderás a trabajar con diferentes tipos de datos como enteros, flotantes, cadenas y booleanos, y a manipularlos mediante operadores aritméticos, de comparación y lógicos.

# Ejemplos de tipos de datos básicos
entero = 42
flotante = 3.14
texto = "Hola, Python"
booleano = True

Las estructuras de control te permitirán dirigir el flujo de ejecución de tus programas:

# Estructura condicional
edad = 18
if edad >= 18:
    print("Eres mayor de edad")
else:
    print("Eres menor de edad")

# Estructura iterativa
for i in range(5):
    print(f"Iteración {i}")

Las funciones son bloques de código reutilizables que encapsulan operaciones específicas:

def saludar(nombre):
    """Función que saluda a una persona"""
    return f"¡Hola, {nombre}!"

mensaje = saludar("Ana")
print(mensaje)  # Imprime: ¡Hola, Ana!

El manejo de excepciones te permitirá controlar errores y situaciones inesperadas:

try:
    resultado = 10 / 0
except ZeroDivisionError:
    print("No se puede dividir por cero")
finally:
    print("Operación finalizada")

Estructuras de datos

Python ofrece estructuras de datos versátiles y potentes que facilitan el manejo de colecciones de información:

• Listas: colecciones ordenadas y mutables
• Tuplas: colecciones ordenadas e inmutables
• Diccionarios: colecciones de pares clave-valor
• Conjuntos: colecciones no ordenadas de elementos únicos

# Lista (mutable)
frutas = ["manzana", "banana", "cereza"]
frutas.append("damasco")

# Tupla (inmutable)
coordenadas = (10, 20)

# Diccionario
persona = {
    "nombre": "Carlos",
    "edad": 30,
    "profesión": "ingeniero"
}

# Conjunto
colores = {"rojo", "verde", "azul"}

Las comprehensions proporcionan una sintaxis concisa para crear estas estructuras:

# List comprehension
cuadrados = [x**2 for x in range(10)]

# Dict comprehension
cuadrados_dict = {x: x**2 for x in range(5)}

# Set comprehension
vocales_set = {letra for letra in "murcielago"}

Programación orientada a objetos

Python implementa la programación orientada a objetos de forma elegante y accesible. Aprenderás a crear clases y objetos, aplicar encapsulación para proteger datos, utilizar métodos especiales (dunder methods) para personalizar el comportamiento de tus objetos, y aprovechar la herencia y el polimorfismo para crear jerarquías de clases eficientes.

class Persona:
    def __init__(self, nombre, edad):
        self.nombre = nombre
        self.edad = edad
        
    def saludar(self):
        return f"Hola, soy {self.nombre} y tengo {self.edad} años"
    
    def __str__(self):
        return f"Persona: {self.nombre}"
        
# Herencia
class Estudiante(Persona):
    def __init__(self, nombre, edad, carrera):
        super().__init__(nombre, edad)
        self.carrera = carrera
        
    def estudiar(self):
        return f"{self.nombre} está estudiando {self.carrera}"

La composición de clases y los mixins te permitirán crear diseños más flexibles y reutilizables:

class LoggerMixin:
    def log(self, mensaje):
        print(f"LOG: {mensaje}")

class BaseDatos:
    def __init__(self, conexion):
        self.conexion = conexion

class ServicioDatos(BaseDatos, LoggerMixin):
    def obtener_datos(self):
        self.log("Obteniendo datos...")
        return ["dato1", "dato2"]

Programación funcional

Python soporta el paradigma funcional con características como funciones lambda, funciones de orden superior y generadores:

# Función lambda
cuadrado = lambda x: x**2

# Map y filter
numeros = [1, 2, 3, 4, 5]
cuadrados = list(map(lambda x: x**2, numeros))
pares = list(filter(lambda x: x % 2 == 0, numeros))

# Reducción
from functools import reduce
suma = reduce(lambda x, y: x + y, numeros)

# Generador
def contador(max):
    n = 0
    while n < max:
        yield n
        n += 1

Los decoradores permiten modificar el comportamiento de funciones y métodos:

def registrar(funcion):
    def wrapper(*args, **kwargs):
        print(f"Llamando a {funcion.__name__}")
        resultado = funcion(*args, **kwargs)
        print(f"Llamada completada")
        return resultado
    return wrapper

@registrar
def suma(a, b):
    return a + b

Entrada/salida y manejo de archivos

Python facilita las operaciones de entrada y salida, especialmente el manejo de archivos:

# Usando el contexto with para manejo seguro de recursos
with open("datos.txt", "w") as archivo:
    archivo.write("Hola, mundo!")

with open("datos.txt", "r") as archivo:
    contenido = archivo.read()
    print(contenido)

Aprenderás a trabajar con archivos temporales y archivos comprimidos:

import tempfile
import zipfile

# Archivo temporal
with tempfile.NamedTemporaryFile(delete=False) as temp:
    temp.write(b"Datos temporales")
    temp_name = temp.name

# Archivo comprimido
with zipfile.ZipFile("archivo.zip", "w") as zip_file:
    zip_file.write("datos.txt")

Biblioteca estándar

La biblioteca estándar de Python es extremadamente rica, ofreciendo módulos para diversas tareas:

• sys y os: interacción con el sistema operativo
• pathlib: manejo de rutas de archivos
• collections: estructuras de datos especializadas
• math, random y statistics: operaciones matemáticas y estadísticas
• datetime y time: manejo de fechas y tiempos
• json, pickle y csv: serialización y deserialización de datos
• re: expresiones regulares

import os
import json
from datetime import datetime
from collections import Counter

# Operaciones con el sistema de archivos
archivos = os.listdir(".")

# Serialización JSON
datos = {"nombre": "Python", "año": 1991}
json_str = json.dumps(datos)

# Fecha y hora actual
ahora = datetime.now()

# Conteo de elementos
palabras = ["python", "java", "python", "javascript"]
conteo = Counter(palabras)

Módulos, paquetes y entornos

Aprenderás a organizar tu código en módulos y paquetes, y a gestionar entornos virtuales y dependencias:

# Importación de módulos
import math
from datetime import datetime

# Creación de entornos virtuales
# (en terminal)
# python -m venv mi_entorno
# source mi_entorno/bin/activate  # Linux/Mac
# mi_entorno\Scripts\activate     # Windows

# Gestión de dependencias
# pip install requests
# pip freeze > requirements.txt

Acceso a bases de datos

Python permite conectarse a diferentes sistemas de bases de datos:

# MySQL
import mysql.connector

conexion = mysql.connector.connect(
    host="localhost",
    user="usuario",
    password="contraseña",
    database="mi_db"
)
cursor = conexion.cursor()
cursor.execute("SELECT * FROM usuarios")
resultados = cursor.fetchall()

# MongoDB
from pymongo import MongoClient

cliente = MongoClient("mongodb://localhost:27017/")
db = cliente["mi_db"]
coleccion = db["usuarios"]
resultado = coleccion.find_one({"nombre": "Ana"})

Testing y desarrollo moderno

El testing es fundamental en el desarrollo profesional:

# Test con pytest
def suma(a, b):
    return a + b

def test_suma():
    assert suma(2, 3) == 5
    assert suma(-1, 1) == 0

Python continúa evolucionando con características modernas como el operador walrus y el pattern matching:

# Operador walrus (:=)
if (n := len(lista)) > 10:
    print(f"Lista larga con {n} elementos")

# Pattern matching (Python 3.10+)
match valor:
    case 0:
        print("Cero")
    case 1:
        print("Uno")
    case _:
        print("Otro número")

Proyectos prácticos

El curso incluye proyectos prácticos que te permitirán aplicar lo aprendido:

• Gestor de tareas CRUD
• Calculadora con sintaxis avanzada
• Retos de programación tipo puzzle

Estos proyectos te ayudarán a consolidar tus conocimientos y desarrollar habilidades de resolución de problemas.

Python es un lenguaje que combina simplicidad y potencia, lo que lo convierte en una excelente elección tanto para principiantes como para desarrolladores experimentados. Su versatilidad y amplio ecosistema lo han posicionado como uno de los lenguajes más populares y demandados en la industria tecnológica actual.