Curso 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.

Versiones modernas del lenguaje

La versión estable actual de Python incorpora mejoras significativas de rendimiento y ergonomía. La release trae un intérprete más rápido, mensajes de error más precisos con sugerencias, un sistema de tipos más expresivo y un modo experimental free-threading que permite ejecutar código sin el GIL para paralelismo real en CPU. Se añade también un JIT experimental basado en copy-and-patch que acelera bucles calientes en cargas numéricas.

Para el programador práctico, esto significa que proyectos existentes se ejecutan más rápido sin cambios y que las nuevas APIs como typing.TypeAlias, typing.Self o la sintaxis type Alias = ... están disponibles sin importaciones adicionales.

Ecosistema y herramientas modernas

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, Polars.
• Aprendizaje automático: TensorFlow, PyTorch, scikit-learn.
• Desarrollo web: Django, Flask, FastAPI.
• Automatización: Ansible, Fabric.
• Análisis de datos: Matplotlib, Seaborn, Plotly.
• Computación científica: SymPy, Biopython.

La cadena de herramientas de desarrollo también ha evolucionado:

• uv como gestor de paquetes y entornos virtuales, escrito en Rust, que reemplaza a pip, virtualenv, pip-tools y pyenv con un rendimiento entre diez y cien veces superior.
• ruff como linter y formateador unificado, sustituye a flake8, isort, black y pyupgrade con una sola herramienta ultrarrápida.
• mypy y pyright como verificadores estáticos de tipos, esenciales en proyectos profesionales.
• pyproject.toml como fichero de configuración central (PEP 621), reemplazando a setup.py y setup.cfg en proyectos modernos.

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 basicos
entero: int = 42
flotante: float = 3.14
texto: str = "Hola, Python"
booleano: bool = True

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

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

for i in range(5):
    print(f"Iteracion {i}")

Las funciones son bloques de código reutilizables que encapsulan operaciones específicas, con anotaciones de tipo modernas desde el primer día:

def saludar(nombre: str) -> str:
    return f"Hola, {nombre}"

mensaje = saludar("Ana")

El manejo de excepciones permite controlar errores y situaciones inesperadas:

try:
    resultado = 10 / 0
except ZeroDivisionError:
    print("No se puede dividir por cero")
finally:
    print("Operacion 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.

frutas: list[str] = ["manzana", "banana", "cereza"]
frutas.append("damasco")

coordenadas: tuple[int, int] = (10, 20)

persona: dict[str, str | int] = {
    "nombre": "Carlos",
    "edad": 30,
    "profesion": "ingeniero",
}

colores: set[str] = {"rojo", "verde", "azul"}

Las comprehensions proporcionan una sintaxis concisa para crear estas estructuras:

cuadrados = [x ** 2 for x in range(10)]
cuadrados_dict = {x: x ** 2 for x in range(5)}
vocales_set = {letra for letra in "murcielago" if letra in "aeiou"}

Programación orientada a objetos

Python implementa la programación orientada a objetos de forma elegante. Aprenderás a crear clases y objetos, aplicar encapsulación con @property, utilizar métodos dunder para personalizar el comportamiento de tus objetos, y aprovechar la herencia y el polimorfismo para crear jerarquías eficientes.

from dataclasses import dataclass

@dataclass
class Persona:
    nombre: str
    edad: int

    def saludar(self) -> str:
        return f"Hola, soy {self.nombre} y tengo {self.edad} anos"

class Estudiante(Persona):
    def __init__(self, nombre: str, edad: int, carrera: str) -> None:
        super().__init__(nombre, edad)
        self.carrera = carrera

    def estudiar(self) -> str:
        return f"{self.nombre} esta estudiando {self.carrera}"

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

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

class BaseDatos:
    def __init__(self, conexion: str) -> None:
        self.conexion = conexion

class ServicioDatos(BaseDatos, LoggerMixin):
    def obtener_datos(self) -> list[str]:
        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:

cuadrado = lambda x: x ** 2

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

from functools import reduce
suma = reduce(lambda acc, x: acc + x, numeros, 0)

def contador(maximo: int):
    n = 0
    while n < maximo:
        yield n
        n += 1

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

from functools import wraps

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

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

Sistema de tipos y dataclasses

El sistema de tipado moderno de Python permite escribir código seguro y autodocumentado sin perder la flexibilidad del lenguaje. Con type hints, dataclasses y protocols se cubren los casos más exigentes de una aplicación profesional:

from dataclasses import dataclass
from typing import Protocol

@dataclass(frozen=True, slots=True)
class Producto:
    nombre: str
    precio: float
    stock: int = 0

class Repositorio(Protocol):
    def guardar(self, producto: Producto) -> None: ...
    def buscar(self, nombre: str) -> Producto | None: ...

La sintaxis X | None reemplaza a Optional, los tipos list, dict, tuple y set se usan directamente como genéricos, y Protocol habilita el tipado estructural al estilo duck typing tipado.

Entrada y salida, archivos y recursos

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

from pathlib import Path

archivo = Path("datos.txt")
archivo.write_text("Hola, mundo", encoding="utf-8")

contenido = archivo.read_text(encoding="utf-8")
print(contenido)

with open("grande.txt", encoding="utf-8") as f:
    for linea in f:
        print(linea.rstrip())

Aprenderás a trabajar con archivos temporales y archivos comprimidos usando tempfile, zipfile, tarfile y gzip.

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 orientado a objetos 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.

from pathlib import Path
from datetime import datetime
from collections import Counter
import json

archivos = list(Path(".").iterdir())

datos = {"nombre": "Python", "version": 3.13}
texto_json = json.dumps(datos, ensure_ascii=False)

ahora = datetime.now()

palabras = ["python", "java", "python", "javascript"]
conteo = Counter(palabras)

Módulos, paquetes, entornos virtuales y dependencias

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

# Crear entorno y anadir dependencias con uv
uv init mi_proyecto
cd mi_proyecto
uv add requests pandas
uv run python -m mi_paquete

# Equivalente tradicional con venv y pip
python -m venv .venv
source .venv/bin/activate   # Linux/macOS
.venv\Scripts\activate      # Windows
pip install -r requirements.txt

El fichero pyproject.toml centraliza metadatos y configuración del proyecto siguiendo PEP 621.

Acceso a bases de datos

Python permite conectarse a diferentes sistemas de bases de datos de forma nativa:

import mysql.connector

conexion = mysql.connector.connect(
    host="localhost",
    user="usuario",
    password="contrasena",
    database="mi_db",
)
cursor = conexion.cursor()
cursor.execute("SELECT id, nombre FROM usuarios WHERE activo = %s", (True,))
resultados = cursor.fetchall()

from pymongo import MongoClient

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

Testing moderno

El testing es fundamental en el desarrollo profesional. Python ofrece dos frameworks principales:

import pytest

def suma(a: int, b: int) -> int:
    return a + b

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

@pytest.mark.parametrize("a,b,esperado", [(1, 1, 2), (0, 0, 0), (-1, 1, 0)])
def test_suma_parametrizada(a: int, b: int, esperado: int) -> None:
    assert suma(a, b) == esperado

pytest es el estándar de facto y unittest sigue disponible en la biblioteca estándar para proyectos que evitan dependencias externas.

Características modernas

Python continúa evolucionando con características que mejoran la expresividad y la seguridad:

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

# Pattern matching estructural
def describir(valor):
    match valor:
        case 0:
            return "cero"
        case int(n) if n > 0:
            return f"positivo {n}"
        case [x, y, *resto]:
            return f"lista con {x}, {y} y {len(resto)} mas"
        case {"tipo": tipo, **datos}:
            return f"dict con tipo={tipo}"
        case _:
            return "desconocido"

# Asyncio para concurrencia
import asyncio

async def descargar(url: str) -> str:
    await asyncio.sleep(0.1)
    return f"contenido de {url}"

async def main() -> list[str]:
    return await asyncio.gather(
        descargar("a"),
        descargar("b"),
        descargar("c"),
    )

Proyectos prácticos

El curso incluye proyectos prácticos que permiten aplicar lo aprendido:

• Gestor de tareas CRUD en consola.
• Calculadora con sintaxis avanzada.
• Analizador de logs con módulos de biblioteca estándar.
• Proyecto integrador con CLI argparse, persistencia en SQLite o JSON, asyncio y pytest.

Python 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.