Guía de Python: De 0 a 100

¿Qué es Python?

Python es un lenguaje de programación interpretado, de tipado dinámico y multiparadigma, creado por Guido van Rossum y lanzado por primera vez en 1991. Su filosofía se resume en el Zen de Python (PEP 20): legibilidad, simplicidad y explícito sobre implícito.

¿Dónde se usa?

• Web: Django, FastAPI, Flask — potencian Instagram, Spotify, Netflix
• Ciencia de datos / ML: NumPy, Pandas, TensorFlow, PyTorch — estándar en la industria
• DevOps / infraestructura: Ansible, Terraform providers, AWS CDK, contenedores
• Automatización / scripting: tareas de sistema, ETL, scraping (Scrapy, BeautifulSoup)
• Embebido / IoT: MicroPython, CircuitPython en microcontroladores
• Ciberseguridad: herramientas como Impacket, sqlmap, Volatility están escritas en Python

¿Quién lo usa? Google (YouTube, backend), Netflix (orquestación de CDN), NASA (análisis de datos), Spotify (recomendación), Reddit (backend original).

Fuente: Python.org — About, Real Python — What Is Python?

Prerrequisitos

Antes de empezar, necesitas:

• Conocimientos básicos de terminal: navegar directorios, ejecutar comandos, usar un editor de texto
• El lenguaje/herramienta instalado en tu sistema (sigue la sección de Instalación si aún no lo tienes)

Si no cumples algún requisito, no te preocupes: cada sección te guiará paso a paso.

¿Cómo empezar? Instalación en todos los entornos

Windows

1. Descarga el instalador desde python.org/downloads
2. Marca “Add Python to PATH” en la primera pantalla — esto es crítico
3. Opcional pero recomendado: elige “Disable path length limit” al final
4. Verifica: abre cmd o PowerShell y ejecuta python --version
5. Alternativa vía winget: winget install Python.Python.3.13

macOS

• Homebrew (recomendado): brew install python@3.13
• Xcode Command Line Tools: xcode-select --install (necesario para compilar algunos paquetes)
• Verifica: python3 --version

Linux (Debian/Ubuntu)

sudo apt update
sudo apt install python3 python3-pip python3-venv build-essential

Para Fedora/RHEL: sudo dnf install python3 python3-pip

pyenv (Linux/macOS/WSL) — versión múltiple

curl https://pyenv.run | bash
echo 'export PYENV_ROOT="$HOME/.pyenv"' >> ~/.bashrc
echo 'command -v pyenv >/dev/null || export PATH="$PYENV_ROOT/bin:$PATH"' >> ~/.bashrc
echo 'eval "$(pyenv init -)"' >> ~/.bashrc
exec $SHELL

pyenv install 3.13 3.12 3.11
pyenv global 3.13

Docker

FROM python:3.13-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY . .
CMD ["python", "main.py"]

Usa python:3.13-slim como base (menos de 130 MB). Evita python:latest para builds reproducibles.

Alias útiles para el día a día

Añade a tu ~/.bashrc o ~/.zshrc:

alias py='python3'
alias pyenv-activate='source .venv/bin/activate'
alias pir='pip install -r requirements.txt'
alias pyfind='find . -name "*.py" -not -path "./.venv/*"'
alias pyt='python3 -m pytest -v'
alias pydev='python3 -m pip install --upgrade pip setuptools wheel'

Fuente: pyenv GitHub, Docker Official Images — Python

Escala de aprendizaje: de 0 a 100

Nivel 0-15: Fundamentos absolutos

Qué aprender:

• Sintaxis básica, variables, tipos (int, str, float, bool)
• Condicionales, bucles, listas, diccionarios
• Funciones, file system básico
• Mutabilidad, small integer caching

Proyecto: Adivina el número — número aleatorio entre 1-100, pistas mayor/menor, contador de intentos, manejo de errores con try/except.

Testing: pytest con aserciones simples, pytest.raises para entrada inválida.

Nivel 15-30: Estructuras de datos y funciones avanzadas

Qué aprender:

• Tuplas, sets, comprehensions, *args/**kwargs
• Lambdas, map/filter/reduce, f-strings avanzadas
• pathlib, csv, json, sorted con key
• EAFP, is vs ==

Proyecto: Gestor de tareas CLI — añadir, listar, completar, eliminar. Persistencia en JSON. Usa argparse o click.

Testing: @pytest.mark.parametrize, tmp_path para archivos.

Nivel 30-45: POO, módulos y errores

Qué aprender:

• Clases, herencia, super(), MRO, ABC, @property
• Excepciones personalizadas, match/case
• dataclasses, collections, heapq
• Decoradores básicos

Proyecto: Sistema de inventario con clases Producto, Inventario. Persistencia con JSON. Decorador @loguear_operacion.

Testing: Fixtures, mocks con monkeypatch, pytest.raises para excepciones personalizadas.

Nivel 45-60: Testing, logging y empaquetado

Qué aprender:

• pytest avanzado (fixtures, parametrización, tmp_path)
• coverage.py, logging, type hints avanzados (Protocol, Generic)
• pyproject.toml, empaquetado pip
• itertools, functools, Pillow básico

Proyecto: Calculadora empaquetada — paquete pip instalable. Tests con parametrize, logging, CI con GitHub Actions (pytest, mypy --strict, ruff).

Nivel 60-75: Web APIs y async

Qué aprender:

• FastAPI, Pydantic, SQLAlchemy 2.0
• asyncio, httpx.AsyncClient, WebSockets
• moviepy/pydub para multimedia básico

Proyecto: API de recetas — FastAPI + SQLAlchemy + PostgreSQL. Tests con pytest-asyncio y httpx.AsyncClient.

Nivel 75-90: Producción

Qué aprender:

• Docker, docker-compose, CI/CD, Redis, Celery
• OpenCV, WebSockets en producción
• pydantic-settings, watchfiles

Proyecto: Dashboard de monitorización — FastAPI + Redis + WebSocket. Docker Compose (api + redis + worker). Tests de integración.

Nivel 90-100: Arquitectura

Qué aprender:

• Arquitectura hexagonal, gRPC, GraphQL, Kafka
• OpenTelemetry, profiling con cProfile/py-spy
• free-threaded Python 3.13, Cython

Proyecto: Sistema de notificaciones distribuidas — microservicios con FastAPI + gRPC + Kafka. OpenTelemetry para tracing.

Primeros pasos y configuración del entorno

Si prefieres ver directamente el “Hola Mundo” en Python, consulta El Atlas del Hola Mundo.

El REPL

Python incluye un intérprete interactivo. Ejecuta python3 en terminal y escribe directamente:

>>> print("Hola mundo")
>>> 2 + 2
>>> [x**2 for x in range(10)]

Para salir: exit() o Ctrl+D.

Scripts y estructura de proyecto

def main():
    print("Hola mundo")

if __name__ == "__main__":
    main()

Ejecuta: python3 hola.py

Entornos virtuales (aislamiento de dependencias)

python3 -m venv .venv
source .venv/bin/activate

# Poetry (moderno, declarativo)
curl -sSL https://install.python-poetry.org | python3
poetry new mi-proyecto
poetry add fastapi

# uv (ultrarrápido, en Rust)
pip install uv
uv venv
uv pip install requests

Editores recomendados

Los IDEs y editores más usados son VSCode, JetBrains y Neovim. Extensiones y configuraciones recomendadas.

Configuración inicial del proyecto

python3 -m venv .venv && source .venv/bin/activate
pip install --upgrade pip setuptools wheel
pip install ruff mypy pytest

Archivo pyproject.toml básico:

[build-system]
requires = ["setuptools>=68.0"]
build-backend = "setuptools.backends._legacy:_Backend"

[tool.ruff]
line-length = 100
target-version = "py313"

[tool.mypy]
python_version = "3.13"
strict = true

Fuente: Python Packaging Guide, Poetry docs

Paradigmas de programación

Python es un lenguaje multiparadigma: soporta programación imperativa/procedural, orientada a objetos y funcional, permitiéndote elegir el enfoque según el problema.

Imperativo / Procedural

El paradigma por defecto. El código se ejecuta en secuencia, con condicionales y bucles:

def sumar_pares(numeros):
    total = 0
    for n in numeros:
        if n % 2 == 0:
            total += n
    return total

print(sumar_pares([1, 2, 3, 4, 5, 6]))  # 12

Programación Orientada a Objetos (POO)

Organiza el código en clases y objetos. Python soporta herencia múltiple, polimorfismo, encapsulación:

class Contador:
    def __init__(self):
        self._valor = 0
    
    def incrementar(self):
        self._valor += 1
    
    @property
    def valor(self):
        return self._valor

c = Contador()
c.incrementar()
c.incrementar()
print(c.valor)  # 2

Programación Funcional

Funciones puras (sin efectos secundarios), lambdas, map/filter/reduce:

from functools import reduce

numeros = [1, 2, 3, 4, 5]

doble = list(map(lambda x: x * 2, numeros))
pares = list(filter(lambda x: x % 2 == 0, numeros))
suma = reduce(lambda a, b: a + b, numeros)

doble2 = [x * 2 for x in numeros]

Declarativo (compresiones)

Las comprensiones describen qué quieres, no cómo:

pares = [n for n in range(20) if n % 2 == 0]

pares2 = []
for n in range(20):
    if n % 2 == 0:
        pares2.append(n)

Tabla comparativa

Fuente: Python docs — Functional Programming, itertools docs

Tipos de datos y variables

Sistema de tipos

¿Qué es?

Python tiene tipado dinámico fuerte: el tipo se infiere en tiempo de ejecución y no se realizan conversiones implícitas entre tipos incompatibles. Es como una caja sin etiqueta: sabes lo que contiene solo cuando la abres.

Duck typing: “si camina como pato y habla como pato, entonces es un pato”. Python mira el comportamiento, no el tipo nominal.

Type hints (PEP 484) añaden tipado gradual opcional para herramientas estáticas.

🔗 Wikipedia — Tipado dinámico, PEP 484

Sintaxis básica

x = 42          # int
x = "hola"      # ahora str — dinámico
# "42" + 1      # TypeError: tipado fuerte

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

from typing import Optional, Union, List, Dict, Any
def procesar(items: List[Union[int, str]]) -> Dict[str, Any]:
    return {"count": len(items), "data": items}

🧪 Cómo probarlo

import pytest

def test_tipado_dinamico():
    x = 42
    assert isinstance(x, int)
    x = "hola"
    assert isinstance(x, str)

def test_tipado_fuerte():
    with pytest.raises(TypeError):
        "42" + 1

def test_type_hints():
    assert procesar([1, "a"]) == {"count": 2, "data": [1, "a"]}

💡 Memoria y rendimiento

• Los type hints no tienen impacto en memoria ni rendimiento: se descartan en runtime
• isinstance() es O(1) gracias al caché de tipos de CPython
• El duck typing añade overhead de búsqueda de atributos en cada llamada

✅ Buenas prácticas

• ✅ Usa type hints siempre en código nuevo — facilitan el mantenimiento y detección de errores
• ⚠️ No uses type() para comparar tipos; prefiere isinstance()
• ❌ No confíes en type hints para validación en runtime — no son vinculantes

🏗️ Metodología

• Usa type hints desde el primer día en proyectos nuevos
• En scripts pequeños (< 100 líneas), los hints son opcionales
• En bibliotecas y APIs, los hints son obligatorios para buena experiencia de desarrollador

🔗 Para saber más

• Real Python — Python Type Checking
• Python docs — typing
• mypy docs

Primitivos

¿Qué es?

Los tipos primitivos son los bloques básicos de datos en Python. A diferencia de C o Java, en Python todo es un objeto, incluso los enteros. Esto significa que tienen métodos, ocupan memoria en heap y tienen overhead.

🔗 Wikipedia — Tipo de dato elemental

Sintaxis básica

print(2**1000)
print(0.1 + 0.2)       # 0.30000000000000004 (IEEE 754)
z = 3 + 4j
print(z.real, z.imag, abs(z))  # 3.0 4.0 5.0
print(True + True)     # 2

🧪 Cómo probarlo

import pytest
import math

def test_int_precision_arbitraria():
    assert 2**1000 > 10**300

def test_float_precision():
    assert math.isclose(0.1 + 0.2, 0.3, rel_tol=1e-9)

def test_bool_es_int():
    assert True + True == 2
    assert issubclass(bool, int)

@pytest.mark.parametrize("valor, tipo", [
    (42, int), (3.14, float), (True, bool), (None, type(None))
])
def test_tipos_primitivos(valor, tipo):
    assert isinstance(valor, tipo)

💡 Memoria y rendimiento

import sys
print(sys.getsizeof(1))        # 28 bytes
print(sys.getsizeof(2**1000))  # ~160 bytes (crece con el número)
print(sys.getsizeof(3.14))     # 24 bytes

• int tiene overhead variable: un entero pequeño cabe en 28 bytes, uno grande crece
• float siempre ocupa 24 bytes (doble precisión)
• bool ocupa 28 bytes (es subclase de int)
• Small integer caching: enteros -5 a 256 son singletons

✅ Buenas prácticas

• ✅ Usa isinstance(x, int) en vez de type(x) == int
• ⚠️ No compares floats con == — usa math.isclose()
• ❌ No asumas que is funciona para comparar números fuera del rango -5 a 256

🏗️ Metodología

• En scripts de datos, prefiere Decimal del módulo decimal para dinero o precisión exacta
• Para números grandes, int nativo es suficiente (no hay overflow)
• En computación científica, numpy ofrece tipos más compactos (np.int32, np.float32)

🔗 Para saber más

• Python docs — Numeric Types
• Real Python — Python Numbers
• IEEE 754 Wikipedia

Compuestos

¿Qué es?

Los tipos compuestos (o contenedores) agrupan múltiples valores. Python ofrece listas, tuplas, diccionarios, conjuntos y más. Son como diferentes tipos de mochilas: algunas mantienen el orden, otras son más rápidas para buscar, otras no permiten duplicados.

🔗 Python docs — Data Structures

Sintaxis básica

from array import array
datos = bytearray(b"hola")
datos[0] = 77  # b'mola'

arr = array('i', [1, 2, 3, 4])

🧪 Cómo probarlo

import pytest

def test_lista_mutable():
    a = [1, 2, 3]
    a.append(4)
    assert a == [1, 2, 3, 4]

def test_tupla_inmutable():
    t = (1, 2, 3)
    with pytest.raises(TypeError):
        t[0] = 99

def test_set_elimina_duplicados():
    assert {1, 2, 2, 3} == {1, 2, 3}

def test_dict_acceso():
    d = {"a": 1, "b": 2}
    assert d["a"] == 1
    with pytest.raises(KeyError):
        _ = d["z"]

💡 Memoria y rendimiento

import sys
print(sys.getsizeof([]))        # 56 bytes + elementos
print(sys.getsizeof([1, 2, 3])) # 88 bytes
print(sys.getsizeof({}))        # 72 bytes
print(sys.getsizeof(set()))     # 216 bytes

• list: O(1) acceso por índice, O(n) búsqueda
• dict/set: O(1) promedio en búsqueda, inserción, borrado
• tuple: más ligera que list (inmutable, menor overhead)
• array.array: ~4 bytes por entero frente a ~28 bytes de list[int]

✅ Buenas prácticas

• ✅ Prefiere list.append() sobre list += [item] (evita crear nueva lista)
• ⚠️ No uses listas como valores por defecto en funciones — usa None
• ❌ No modifiques una lista mientras la iteras — crea una copia

🏗️ Metodología

• list: colección ordenada que cambia de tamaño (pila, cola)
• tuple: coordenadas, claves de diccionario, datos inmutables
• dict: búsqueda rápida por clave, mapeos
• set: membresía, operaciones de conjunto (unión, intersección)

🔗 Para saber más

• Python docs — Built-in Types
• Real Python — Lists vs Tuples
• Python Wiki — Time Complexity

Mutabilidad

¿Qué es?

La mutabilidad determina si un objeto puede cambiar después de creado. Es como la diferencia entre escribir en una pizarra (mutable — puedes borrar y reescribir) y escribir en piedra (inmutable — necesitas una piedra nueva para cambiar el mensaje).

🔗 Python docs — mutable

Sintaxis básica

a = [1, 2, 3]  # mutable
b = a
a.append(4)
print(b)  # [1, 2, 3, 4] — b también cambió

s = "hola"     # inmutable
s += " mundo"  # nueva cadena, la original no se modifica

🧪 Cómo probarlo

import pytest

def test_mutable_compartido():
    a = [1, 2, 3]
    b = a
    a.append(4)
    assert b == [1, 2, 3, 4]
    assert a is b

def test_inmutable_nuevo_objeto():
    s = "hola"
    original_id = id(s)
    s += " mundo"
    assert id(s) != original_id

def test_mutable_default_arg():
    def fn(items=[]):
        items.append(1)
        return items
    assert fn() == [1]
    assert fn() == [1, 1]

💡 Memoria y rendimiento

• Mutables: se pasan por referencia (sin copia) — eficiente pero peligroso
• Inmutables: cualquier “cambio” crea un nuevo objeto (más memoria, predecible)
• Default args mutables: se evalúan una vez en definición, no en llamada — causa bugs sutiles

✅ Buenas prácticas

• ✅ Usa tuple para datos que no deben cambiar (coordenadas, settings)
• ⚠️ Nunca uses list o dict como valor por defecto de un parámetro
• ❌ No asumas que modificar un mutable dentro de una función no afecta al exterior

🏗️ Metodología

• Datos inmutables = más seguros en concurrencia (no hay race conditions)
• En APIs públicas, prefiere devolver tuplas o frozenset en vez de listas
• En algoritmos que requieren muchos cambios, usa mutables por rendimiento

🔗 Para saber más

• Real Python — mutable vs immutable
• Python docs — objects

Strings en detalle

¿Qué es?

Las cadenas en Python 3 son secuencias inmutables de caracteres Unicode. Cada carácter es un código Unicode de hasta 4 bytes, lo que permite representar cualquier idioma y símbolo del mundo.

🔗 Wikipedia — Unicode

Sintaxis básica

texto = "Español ñ"
bytes_utf8 = texto.encode("utf-8")
bytes_latin = texto.encode("latin-1")
texto_recuperado = bytes_utf8.decode("utf-8")

print("\u00F1")
print("\N{LATIN SMALL LETTER N WITH TILDE}")

nombre = "Ana"
edad = 30
print(f"{nombre} tiene {edad} años")
print(f"{nombre:>10}")
print(f"{edad:03d}")
print(f"{1000_000:,}")

ruta = r"C:\Users\nombre\archivo.txt"  # raw string

🧪 Cómo probarlo

import pytest

def test_codificacion_utf8():
    texto = "Español ñ"
    encoded = texto.encode("utf-8")
    assert isinstance(encoded, bytes)
    assert encoded.decode("utf-8") == texto

def test_f_string():
    nombre = "Ana"
    assert f"Hola {nombre}" == "Hola Ana"

@pytest.mark.parametrize("entrada, esperado", [
    ("hola", "HOLA"), ("MUNDO", "mundo"), ("Python", "PYTHON")
])
def test_upper_lower(entrada, esperado):
    resultado = entrada.upper() if esperado.isupper() else entrada.lower()
    assert resultado == esperado

💡 Memoria y rendimiento

• Cada objeto str tiene overhead (~49 bytes + 1-4 bytes por carácter)
• String interning: cadenas cortas con forma de identificador se cachean automáticamente
• La concatenación con + en bucles es O(n²) — prefiere join()

✅ Buenas prácticas

• ✅ Prefiere f-strings sobre % o .format() (más legibles, más rápidas)
• ⚠️ No anides f-strings en Python < 3.12 — causan SyntaxError
• ❌ No concatenes strings en bucles — usa ''.join(lista)

🏗️ Metodología

• Para manipulación intensiva de texto, considera io.StringIO como buffer
• Para búsquedas complejas, usa re.compile() una vez
• Para datos binarios, usa bytes o bytearray, no strings

🔗 Para saber más

• Python docs — Text Sequence Type
• Real Python — Python String Formatting
• Unicode HOWTO

Memoria y objetos

¿Qué es?

Python no tiene variables al estilo C. Tiene nombres que referencian objetos en memoria. Es como una guía telefónica: los nombres (variables) apuntan a números (objetos). Varios nombres pueden apuntar al mismo número.

🔗 Python docs — data model

Sintaxis básica

import sys

x = 42
print(id(x))

a = [1, 2]
b = [1, 2]
print(a == b)  # True (mismo valor)
print(a is b)  # False (distinto objeto)

print(sys.getsizeof(1))           # 28 bytes
print(sys.getsizeof("a"))         # 50 bytes
print(sys.getsizeof([]))          # 56 bytes

🧪 Cómo probarlo

import pytest
import sys

def test_identidad_vs_igualdad():
    a = [1, 2]
    b = [1, 2]
    assert a == b
    assert a is not b

def test_small_integer_caching():
    assert 256 is 256

def test_getsizeof_crece_con_elementos():
    size_vacia = sys.getsizeof([])
    size_con = sys.getsizeof([1, 2, 3])
    assert size_con > size_vacia

💡 Memoria y rendimiento

• Reference counting: cuando el contador llega a 0, el objeto se libera inmediatamente
• GC cíclico: detecta ciclos de referencias
• __slots__ elimina el __dict__ (~50% menos memoria)
• sys.getsizeof() mide el objeto, no sus contenidos anidados

✅ Buenas prácticas

• ✅ Usa is para comparar con None (x is None), no ==
• ⚠️ No uses is para comparar números o strings — usa ==
• ❌ No asumas que del libera memoria inmediatamente

🏗️ Metodología

• Para millones de objetos, usa __slots__ o array.array/numpy.ndarray
• Para datos temporales grandes, el GC cíclico libera automáticamente
• En scripts de corta duración, gc.disable() puede mejorar rendimiento

🔗 Para saber más

• Python docs — gc
• CPython internals (Real Python)
• Python docs — sys.getsizeof

Type casting

¿Qué es?

Convertir un valor de un tipo a otro. Python hace conversiones implícitas mínimas (tipado fuerte) y requiere conversiones explícitas (casting) para la mayoría de los casos.

🔗 Python docs — built-in functions

Sintaxis básica

int("42")          # 42
float("3.14")      # 3.14
str(42)            # "42"
list("hola")       # ['h', 'o', 'l', 'a']
tuple([1, 2, 3])   # (1, 2, 3)
set([1, 2, 2, 3])  # {1, 2, 3}

def safe_int(valor, default=0):
    try:
        return int(valor)
    except (ValueError, TypeError):
        return default

print(safe_int("abc"))  # 0

🧪 Cómo probarlo

import pytest

def test_casting_explicito():
    assert int("42") == 42
    assert str(42) == "42"
    assert list("abc") == ["a", "b", "c"]

def test_casting_seguro():
    assert safe_int("abc") == 0
    assert safe_int("42") == 42

@pytest.mark.parametrize("entrada", ["abc", None, 3.14])
def test_int_raise(entrada):
    with pytest.raises((ValueError, TypeError)):
        int(entrada)

💡 Memoria y rendimiento

• int() y float() son O(n) para strings largos (parsean carácter por carácter)
• list() y tuple() copian el iterable completo — O(n) en tiempo y memoria
• Las conversiones crean nuevos objetos; el original no se modifica

✅ Buenas prácticas

• ✅ Siempre maneja excepciones al convertir entradas de usuario
• ⚠️ No confíes en conversiones implícitas — sé explícito con int(), str()
• ❌ No uses eval() para convertir strings a tipos — es inseguro

🏗️ Metodología

• Para parsing de datos masivos, prefiere validación temprana con try/except
• En APIs, usa Pydantic para validación y casting automático
• En ETL, maneja errores de casting con logging

🔗 Para saber más

• Real Python — Python Type Conversion
• Python docs — built-in functions

Control de flujo y modularidad

Condicionales

¿Qué es?

Las estructuras condicionales permiten ejecutar diferentes bloques de código según condiciones booleanas. Python ofrece if/elif/else, ternarios y match/case (3.10+). Es como un semáforo: el camino que tomas depende del color que veas.

🔗 Wikipedia — Estructuras de control

Sintaxis básica

edad = 18
if edad < 12:
    categoria = "niño"
elif edad < 18:
    categoria = "adolescente"
elif edad < 65:
    categoria = "adulto"
else:
    categoria = "senior"

categoria = "mayor" if edad >= 18 else "menor"

def procesar_comando(comando: str) -> str:
    match comando.lower().split():
        case ["salir"]:
            return "Saliendo..."
        case ["suma", *numeros]:
            total = sum(int(n) for n in numeros)
            return f"Total: {total}"
        case ["info", ("usuario" | "user") as entidad, id_]:
            return f"Buscando {entidad} con id {id_}"
        case _:
            return "Comando no reconocido"

🧪 Cómo probarlo

import pytest

@pytest.mark.parametrize("edad, esperado", [
    (5, "niño"), (12, "adolescente"), (18, "adulto"), (70, "senior")
])
def test_categorias(edad, esperado):
    if edad < 12:
        cat = "niño"
    elif edad < 18:
        cat = "adolescente"
    elif edad < 65:
        cat = "adulto"
    else:
        cat = "senior"
    assert cat == esperado

def test_match_case():
    assert procesar_comando("salir") == "Saliendo..."
    assert procesar_comando("suma 1 2 3") == "Total: 6"
    assert procesar_comando("info usuario 42") == "Buscando usuario con id 42"

💡 Memoria y rendimiento

• if/elif es O(1) por condición (evaluación lazy)
• match/case es similar en rendimiento a if/elif
• Cadenas muy largas de elif (>10) deberían ser un dict de funciones

✅ Buenas prácticas

• ✅ Usa match/case para pattern matching estructural (Python 3.10+)
• ⚠️ No encadenes más de 5 elif — refactoriza a un dict de dispatch
• ❌ No uses if x: para comprobar None — usa if x is not None:

🏗️ Metodología

• Condicionales simples: if/elif/else es suficiente
• Múltiples variantes de un algoritmo: patrón Strategy con funciones
• Múltiples condiciones sobre el mismo valor: match/case
• Búsquedas en tablas: dict como dispatch table

🔗 Para saber más

• Python docs — Control Flow
• PEP 636 — match/case
• Real Python — Conditional Statements

Bucles

¿Qué es?

Los bucles ejecutan un bloque de código repetidamente. Python ofrece for (sobre iterables) y while (condicional), más for/else que ejecuta código si no hubo break.

🔗 Python docs — for

Sintaxis básica

for i, valor in enumerate(["a", "b", "c"], start=1):
    print(f"{i}: {valor}")

contador = 0
while contador < 5:
    contador += 1

for n in range(100):
    if n % 2 == 0:
        continue
    if n > 10:
        break

for n in range(2, 10):
    for divisor in range(2, int(n**0.5) + 1):
        if n % divisor == 0:
            break
    else:
        print(f"{n} es primo")

🧪 Cómo probarlo

import pytest

def test_for_sobre_lista():
    resultado = []
    for i, v in enumerate(["a", "b"], 1):
        resultado.append(f"{i}:{v}")
    assert resultado == ["1:a", "2:b"]

def test_while_condicion():
    contador = 0
    while contador < 3:
        contador += 1
    assert contador == 3

def test_for_else_sin_break():
    resultado = []
    for n in range(2, 5):
        pass
    else:
        resultado.append("completado")
    assert resultado == ["completado"]

💡 Memoria y rendimiento

• for en Python es más lento que en C porque itera a través del protocolo de iteración
• Los bucles anidados profundos son candidatos a refactorizar con itertools.product

✅ Buenas prácticas

• ✅ Prefiere for sobre while cuando recorres colecciones
• ⚠️ No modifiques la lista que estás iterando — itera sobre una copia
• ❌ No uses while True sin una condición de salida clara

🏗️ Metodología

• Para transformar colecciones, prefiere comprehensions o map/filter
• Para operaciones costosas dentro del bucle, extrae a una función
• En procesamiento de datos grande, considera numpy vectorizado

🔗 Para saber más

• Python docs — Loops
• Real Python — Python Loops

Comprehensions

¿Qué es?

Las comprehensions son una forma concisa de crear secuencias aplicando una expresión a cada elemento de un iterable, opcionalmente filtrando. Es azúcar sintáctico sobre bucles for, más legible y ligeramente más rápido.

🔗 Python docs — list comprehensions

Sintaxis básica

cuadrados = [x**2 for x in range(10) if x % 2 == 0]
cuadrados_dict = {x: x**2 for x in range(5)}
pares_unicos = {x % 3 for x in range(10)}
suma_cuadrados = sum(x**2 for x in range(1_000_000))

🧪 Cómo probarlo

import pytest

def test_list_comprehension():
    resultado = [x**2 for x in range(5) if x % 2 == 0]
    assert resultado == [0, 4, 16]

def test_dict_comprehension():
    resultado = {x: x**2 for x in range(3)}
    assert resultado == {0: 0, 1: 1, 2: 2}

def test_generator_expression():
    total = sum(x for x in range(10) if x % 2 == 0)
    assert total == 20

💡 Memoria y rendimiento

• Las comprehensions son ~10-30% más rápidas que bucles for equivalentes
• Las expresiones generadoras ((...)) son lazy — no ocupan memoria hasta que se iteran

✅ Buenas prácticas

• ✅ Úsalas para transformaciones simples y filtros
• ⚠️ No anides comprehensions más de 2 niveles — usa bucles
• ❌ No abuses de ellas para efectos secundarios

🏗️ Metodología

• Para transformaciones simples: comprehension
• Para transformaciones complejas: pipeline con generadores
• Para datos masivos: expresión generadora (lazy)

🔗 Para saber más

• Real Python — Comprehensions
• Python docs — itertools

Excepciones

¿Qué es?

Las excepciones son el mecanismo de Python para manejar errores en tiempo de ejecución. Siguen el estilo EAFP (Easier to Ask Forgiveness than Permission): intenta la operación y maneja el error si ocurre.

🔗 Python docs — Errors and Exceptions

Sintaxis básica

try:
    archivo = open("datos.txt")
    datos = archivo.read()
except FileNotFoundError:
    print("Archivo no encontrado")
except PermissionError:
    print("Sin permisos")
else:
    print(f"Leídos {len(datos)} caracteres")
finally:
    archivo.close()

def dividir(a, b):
    if b == 0:
        raise ValueError("No se puede dividir por cero")
    return a / b

class SaldoInsuficienteError(Exception):
    def __init__(self, saldo: float, intento: float):
        self.saldo = saldo
        self.intento = intento
        super().__init__(f"Saldo insuficiente: ${saldo}, se requieren ${intento}")

try:
    int("no_numero")
except ValueError as e:
    raise RuntimeError("Error al procesar entrada") from e

🧪 Cómo probarlo

import pytest

def test_excepcion_esperada():
    with pytest.raises(ValueError, match="No se puede dividir por cero"):
        dividir(10, 0)

def test_excepcion_personalizada():
    with pytest.raises(SaldoInsuficienteError) as exc:
        raise SaldoInsuficienteError(50, 100)
    assert exc.value.saldo == 50

def test_try_except_else():
    resultado = []
    try:
        resultado.append("try")
    except:
        pass
    else:
        resultado.append("else")
    finally:
        resultado.append("finally")
    assert resultado == ["try", "else", "finally"]

💡 Memoria y rendimiento

• Lanzar excepciones es relativamente caro (construcción del traceback)
• El bloque try sin excepción tiene overhead casi nulo
• No uses excepciones para control de flujo normal

✅ Buenas prácticas

• ✅ Sé específico con los tipos de excepción que capturas
• ⚠️ No captures Exception genérica sin una razón muy concreta
• ❌ No uses except: pass — como mínimo, registra el error

🏗️ Metodología

• EAFP es el estilo Pythonic: intenta y maneja errores después
• Para APIs públicas, documenta las excepciones que puede lanzar cada función
• En programas grandes, crea una jerarquía de excepciones personalizadas

🔗 Para saber más

• Python docs — Built-in Exceptions
• Real Python — Python Exceptions
• PEP 3134 — Exception Chaining

Módulos y paquetes

¿Qué es?

Un módulo es un archivo .py que puede contener funciones, clases y variables. Un paquete es un directorio con __init__.py que agrupa módulos relacionados. Es la unidad de organización del código en Python.

🔗 Python docs — Modules

Sintaxis básica

mi_paquete/
├── __init__.py
├── __main__.py
├── modulo_a.py
└── subpaquete/
    ├── __init__.py
    └── modulo_b.py

from mi_paquete.subpaquete import modulo_b
from mi_paquete import modulo_a
from . import modulo_a
from .subpaquete import modulo_b

import sys
print(sys.path)

🧪 Cómo probarlo

import pytest
import sys
from pathlib import Path

def test_sys_path_es_lista():
    assert isinstance(sys.path, list)
    assert "" in sys.path or Path.cwd() in sys.path

def test_import_relativo(tmp_path):
    pkg = tmp_path / "mipkg"
    pkg.mkdir()
    (pkg / "__init__.py").write_text("")
    (pkg / "modulo.py").write_text("VALOR = 42")
    sys.path.insert(0, str(tmp_path))
    from mipkg.modulo import VALOR
    assert VALOR == 42
    sys.path.pop(0)

💡 Memoria y rendimiento

• import carga el módulo en sys.modules — las siguientes importaciones son instantáneas
• from modulo import * puede cargar símbolos no deseados (usa __all__)

✅ Buenas prácticas

• ✅ Usa imports absolutos siempre que sea posible
• ⚠️ No uses from modulo import * fuera de __init__.py
• ❌ No tengas módulos con el mismo nombre que la stdlib (ej: json.py)

🏗️ Metodología

• Divide en módulos por responsabilidad (un módulo = una preocupación)
• Usa __init__.py para exportar la API pública del paquete
• Para proyectos grandes, estructura en subpaquetes

🔗 Para saber más

• Python docs — Packages
• Real Python — Python Modules and Packages
• PEP 420 — Implicit Namespace Packages

Sistema de archivos (File System I/O)

Lectura/escritura clásica

¿Qué es?

El sistema de archivos permite leer y escribir datos en el disco. Python ofrece la función open() con múltiples modos para texto y binario. Es como un archivador: abres el cajón (archivo), lees o escribes documentos, y lo cierras cuando terminas.

🔗 Python docs — File I/O

Sintaxis básica

with open("ejemplo.txt", "w", encoding="utf-8") as f:
    f.write("Hola mundo\n")
    f.writelines(["línea 2\n", "línea 3\n"])

with open("ejemplo.txt", "r", encoding="utf-8") as f:
    contenido = f.read()
    lineas = f.readlines()

with open("imagen.jpg", "rb") as f:
    datos = f.read(1024)

with open("datos.bin", "wb+") as f:
    f.write(b"\x00\x01\x02")
    f.seek(0)
    print(f.read())

🧪 Cómo probarlo

import pytest
from pathlib import Path

def test_escritura_lectura(tmp_path):
    archivo = tmp_path / "test.txt"
    with open(archivo, "w", encoding="utf-8") as f:
        f.write("contenido")
    with open(archivo, "r", encoding="utf-8") as f:
        assert f.read() == "contenido"

def test_binary_mode(tmp_path):
    archivo = tmp_path / "data.bin"
    with open(archivo, "wb") as f:
        f.write(b"\x00\xff")
    with open(archivo, "rb") as f:
        assert f.read() == b"\x00\xff"

def test_archivo_no_existe():
    with pytest.raises(FileNotFoundError):
        open("/no/existe.txt")

💡 Memoria y rendimiento

• read() carga todo el archivo en memoria — peligroso para archivos grandes
• Usa for linea in f: para streaming (carga una línea a la vez)
• El buffering por defecto (4096-8192 bytes) es óptimo para la mayoría de casos

✅ Buenas prácticas

• ✅ Siempre usa with open() — cierra el archivo automáticamente
• ⚠️ No leas archivos completos si son grandes — usa iteración línea por línea
• ❌ No especifiques encoding en modo binario

🏗️ Metodología

• Archivos pequeños (< 100 MB): read()/write() sin problemas
• Archivos grandes: streaming línea por línea o en fragmentos
• Procesamiento por lotes: iter(f.readline, '') para archivos enormes

🔗 Para saber más

• Real Python — File Handling
• Python docs — open()

pathlib

¿Qué es?

pathlib es la forma moderna y orientada a objetos de manejar rutas de archivos. Reemplaza a os.path con una API más limpia y multiplataforma. En lugar de strings, usas objetos Path.

🔗 Python docs — pathlib

Sintaxis básica

from pathlib import Path

ruta = Path("/usr/local/bin/python3")
print(ruta.name, ruta.stem, ruta.parent)

p = Path("datos")
p.mkdir(parents=True, exist_ok=True)

archivo = Path("datos/notas.txt")
archivo.write_text("contenido", encoding="utf-8")
texto = archivo.read_text(encoding="utf-8")

for py in Path("src").rglob("*.py"):
    print(py)

from pathlib import PurePath
pp = PurePath("/usr/local/bin")
print(pp.joinpath("python3"))

🧪 Cómo probarlo

import pytest
from pathlib import Path

def test_path_propiedades():
    ruta = Path("/usr/local/bin/python3")
    assert ruta.name == "python3"
    assert ruta.stem == "python3"
    assert ruta.parent == Path("/usr/local/bin")

def test_mkdir_y_escritura(tmp_path):
    d = tmp_path / "subdir"
    d.mkdir()
    f = d / "test.txt"
    f.write_text("hola")
    assert f.read_text() == "hola"

def test_glob(tmp_path):
    (tmp_path / "a.py").write_text("")
    (tmp_path / "b.txt").write_text("")
    archivos_py = list(tmp_path.glob("*.py"))
    assert len(archivos_py) == 1
    assert archivos_py[0].name == "a.py"

### Tempfile

#### ¿Qué es?
El módulo `tempfile` crea archivos y directorios temporales que se limpian automáticamente. Útil para tests, caché en disco, y procesamiento de datos intermedios.

🔗 [Python docs — tempfile](https://docs.python.org/3/library/tempfile.html)

#### Sintaxis básica
```python
import tempfile
from pathlib import Path

with tempfile.TemporaryFile(mode="w+") as f:
    f.write("datos temporales")
    f.seek(0)
    print(f.read())

with tempfile.NamedTemporaryFile(suffix=".csv", delete=True) as f:
    print(f.name)

with tempfile.TemporaryDirectory() as tmpdir:
    p = Path(tmpdir) / "archivo.txt"
    p.write_text("temporal")
    print(p.read_text())

🧪 Cómo probarlo

import pytest
import tempfile
from pathlib import Path

def test_temporary_file():
    with tempfile.TemporaryFile(mode="w+") as f:
        f.write("test data")
        f.seek(0)
        assert f.read() == "test data"

def test_temporary_directory():
    with tempfile.TemporaryDirectory() as tmpdir:
        p = Path(tmpdir) / "test.txt"
        p.write_text("contenido")
        assert p.exists()
    assert not Path(tmpdir).exists()

💡 Memoria y rendimiento

• Los archivos temporales se crean en /tmp (Linux) o %TEMP% (Windows)
• El overhead de crear/eliminar archivos temporales es mínimo

✅ Buenas prácticas

• ✅ Úsalos en tests para evitar limpieza manual
• ⚠️ No asumas una ubicación específica para los archivos temporales
• ❌ No crees archivos temporales en el directorio de trabajo

🏗️ Metodología

• Tests: tmp_path fixture de pytest
• Caché: TemporaryDirectory para conjuntos de archivos
• Archivos grandes temporales: NamedTemporaryFile(delete=False)

🔗 Para saber más

• Real Python — tempfile
• pytest tmp_path docs

Streams en memoria

¿Qué es?

io.StringIO y io.BytesIO son buffers en memoria que se comportan como archivos. Permiten usar la misma API de archivos sin tocar el disco. Ideales para tests y mockear I/O.

🔗 Python docs — io

Sintaxis básica

import io

buffer = io.StringIO()
buffer.write("línea 1\nlínea 2\n")
buffer.seek(0)
print(buffer.read())
print(buffer.getvalue())

buf = io.BytesIO()
buf.write(b"\x00\x01\x02")
buf.seek(0)
print(buf.read())

def procesar_archivo(f: io.TextIOBase) -> int:
    return len(f.read())

🧪 Cómo probarlo

import pytest
import io

def test_stringio_como_archivo():
    f = io.StringIO("contenido de prueba")
    assert f.read() == "contenido de prueba"

def test_bytesio_binario():
    buf = io.BytesIO()
    buf.write(b"\x01\x02\x03")
    buf.seek(0)
    assert buf.read() == b"\x01\x02\x03"

def test_mock_archivo_con_stringio():
    def contar_lineas(f):
        return len(f.readlines())
    f = io.StringIO("a\nb\nc\n")
    assert contar_lineas(f) == 3

💡 Memoria y rendimiento

• StringIO y BytesIO operan en RAM — rápidos pero limitados por memoria disponible
• Para buffers muy grandes (>100 MB), considera archivos temporales
• getvalue() devuelve el contenido completo — O(n) en tiempo

✅ Buenas prácticas

• ✅ Úsalos para mockear archivos en tests
• ⚠️ No uses StringIO para datos binarios — usa BytesIO
• ❌ No olvides seek(0) después de escribir antes de leer

🏗️ Metodología

• Tests: mockea archivos reales con StringIO/BytesIO
• Procesamiento: úsalos como buffers intermedios
• Logging: logging.StreamHandler(io.StringIO()) para capturar logs

🔗 Para saber más

• Python docs — io.StringIO
• Real Python — StringIO

CSV y JSON

¿Qué es?

CSV (Comma-Separated Values) y JSON (JavaScript Object Notation) son los formatos de datos estructurados más comunes. Python incluye módulos para leerlos y escribirlos en la stdlib.

🔗 Wikipedia — CSV, Wikipedia — JSON

Sintaxis básica

import csv, json

with open("datos.csv", "w", newline="", encoding="utf-8") as f:
    writer = csv.writer(f)
    writer.writerow(["nombre", "edad"])
    writer.writerows([["Ana", 30], ["Luis", 25]])

with open("datos.csv", "r", encoding="utf-8") as f:
    reader = csv.DictReader(f)
    for fila in reader:
        print(fila["nombre"], fila["edad"])

datos = {"usuarios": [{"nombre": "Ana", "edad": 30}]}
with open("datos.json", "w", encoding="utf-8") as f:
    json.dump(datos, f, indent=2, ensure_ascii=False)

🧪 Cómo probarlo

import pytest, csv, json, io

def test_csv_escritura_lectura():
    buffer = io.StringIO()
    writer = csv.writer(buffer)
    writer.writerow(["nombre", "edad"])
    writer.writerow(["Ana", "30"])
    buffer.seek(0)
    reader = csv.DictReader(buffer)
    rows = list(reader)
    assert rows[0]["nombre"] == "Ana"
    assert rows[0]["edad"] == "30"

def test_json_serializacion():
    data = {"clave": "valor", "numero": 42}
    serializado = json.dumps(data)
    deserializado = json.loads(serializado)
    assert deserializado == data

💡 Memoria y rendimiento

• csv.DictReader carga una fila a la vez — eficiente para archivos grandes
• json.load() carga todo el archivo en memoria — O(n) en RAM
• Para datasets enormes, considera formatos binarios como Parquet

✅ Buenas prácticas

• ✅ Usa newline="" al escribir CSV para evitar filas en blanco extra
• ⚠️ No asumas que CSV tiene un encoding específico — especifícalo siempre
• ❌ No uses eval() para deserializar JSON — usa json.loads()

🏗️ Metodología

• CSV: datos tabulares simples, intercambio con hojas de cálculo
• JSON: APIs, configuración, intercambio entre servicios
• Para datos complejos: JSON con esquemas (Pydantic) para validación

🔗 Para saber más

• Python docs — csv
• Python docs — json
• Real Python — CSV

Archivos binarios con struct

¿Qué es?

El módulo struct convierte datos Python a bytes y viceversa usando formatos compactos. Es el estándar para leer/escribir archivos binarios, protocolos de red y datos de C.

🔗 Python docs — struct

Sintaxis básica

import struct

datos_binarios = struct.pack("If", 42, 3.14)
numero, flotante = struct.unpack("If", datos_binarios)

struct.pack_into("H", bytearray(b"\x00\x00\x00\x00"), 2, 1024)

🧪 Cómo probarlo

import pytest, struct

def test_pack_unpack():
    packed = struct.pack("If", 42, 3.14)
    n, f = struct.unpack("If", packed)
    assert n == 42
    assert abs(f - 3.14) < 0.001

def test_pack_into():
    buf = bytearray(8)
    struct.pack_into("I", buf, 0, 255)
    struct.pack_into("I", buf, 4, 65535)
    assert struct.unpack_from("I", buf, 0)[0] == 255
    assert struct.unpack_from("I", buf, 4)[0] == 65535

💡 Memoria y rendimiento

• struct.pack es extremadamente rápido (escrito en C)
• Los formatos compactos de struct son más eficientes que JSON o pickle
• Sin alineación: struct.pack("II", 1, 2) ocupa 8 bytes exactos

✅ Buenas prácticas

• ✅ Usa estructuras de tamaño fijo para archivos binarios
• ⚠️ Respeta el alignment nativo
• ❌ No asumas el mismo endianness en todas las plataformas

🏗️ Metodología

• struct para formatos binarios simples
• numpy para arrays grandes (más rápido y flexible)
• pickle para serializar objetos Python arbitrarios

🔗 Para saber más

• Python docs — struct
• Real Python — struct

Algoritmos y estructuras de datos

Búsqueda

¿Qué es?

La búsqueda localiza un elemento dentro de una colección. Python soporta búsqueda lineal (list.index, in) que es O(n), y búsqueda binaria (bisect) que es O(log n) en datos ordenados.

🔗 Wikipedia — Búsqueda binaria

Sintaxis básica

import bisect

datos = [1, 3, 5, 7, 9, 11]

print(datos.index(7))          # 3 (lineal)
pos = bisect.bisect_left(datos, 7)  # 3 (binaria)

print(7 in [1, 3, 5, 7])      # O(n)
print(7 in {1, 3, 5, 7})      # O(1)

🧪 Cómo probarlo

import pytest, bisect

def test_busqueda_lineal():
    datos = [1, 3, 5, 7]
    assert datos.index(5) == 2
    with pytest.raises(ValueError):
        datos.index(99)

def test_busqueda_binaria():
    datos = [1, 3, 5, 7, 9]
    pos = bisect.bisect_left(datos, 5)
    assert datos[pos] == 5

def test_in_operator():
    assert 3 in [1, 2, 3]
    assert 3 in {1, 2, 3}
    assert "k" in {"k": 1}

💡 Memoria y rendimiento

• list.index(): O(n) tiempo, O(1) memoria extra
• bisect.bisect_left(): O(log n) tiempo, O(1) memoria extra
• in en set/dict: O(1) promedio, O(n) peor caso

✅ Buenas prácticas

• ✅ Si buscas frecuentemente, convierte la lista a set
• ⚠️ bisect requiere datos ordenados
• ❌ No abuses de in en listas grandes para búsquedas repetitivas

🏗️ Metodología

• Búsqueda única: list.index() o in es suficiente
• Búsquedas múltiples: convierte a set/dict (O(1))
• Búsqueda en datos ordenados: bisect (O(log n))

🔗 Para saber más

• Python docs — bisect
• Big O Cheat Sheet

Ordenación

¿Qué es?

Python incluye Timsort, un algoritmo híbrido estable (O(n log n)) que combina Merge Sort y Insertion Sort. Es el algoritmo de ordenación por defecto en sorted() y list.sort().

🔗 Wikipedia — Timsort

Sintaxis básica

numeros = [3, 1, 4, 1, 5]
ordenados = sorted(numeros)
inverso = sorted(numeros, reverse=True)
numeros.sort()

palabras = ["python", "java", "c", "rust"]
sorted(palabras, key=len)

from operator import attrgetter
class Usuario:
    def __init__(self, nombre, edad):
        self.nombre, self.edad = nombre, edad
usuarios = [Usuario("Ana", 30), Usuario("Luis", 25)]
sorted(usuarios, key=attrgetter("edad"))

#### 🧪 Cómo probarlo
```python
import pytest

def test_sorted():
    assert sorted([3, 1, 2]) == [1, 2, 3]

def test_sorted_reverse():
    assert sorted([1, 2, 3], reverse=True) == [3, 2, 1]

def test_sort_inplace():
    nums = [3, 1, 2]
    nums.sort()
    assert nums == [1, 2, 3]

def test_sort_key():
    palabras = ["aa", "b", "ccc"]
    assert sorted(palabras, key=len) == ["b", "aa", "ccc"]

def test_estabilidad():
    datos = [(1, "a"), (2, "b"), (1, "c")]
    ordenados = sorted(datos, key=lambda x: x[0])
    assert ordenados[0][1] == "a"

💡 Memoria y rendimiento

• Timsort: O(n log n) peor caso, O(n) mejor caso (datos ya ordenados)
• sorted() devuelve una nueva lista (O(n) memoria extra)
• list.sort() ordena in-place (O(1) memoria extra)
• Estable: elementos iguales mantienen su orden relativo

✅ Buenas prácticas

• ✅ Usa key en vez de cmp (no existe cmp en Python 3)
• ⚠️ Si ordenas objetos, implementa __lt__ o usa attrgetter
• ❌ No redefinas sorted — usa key para personalizar

🏗️ Metodología

• Lista pequeña (< 1000 elementos): cualquier método funciona
• Lista grande pero ya casi ordenada: Timsort rinde mejor que QuickSort
• Ordenación estable: necesaria cuando hay criterios múltiples

🔗 Para saber más

• Python docs — sorting
• Wikipedia — Timsort

Estructuras de datos de la stdlib

¿Qué es?

Además de listas, dicts y sets, la stdlib incluye estructuras especializadas: deque (cola doble), defaultdict (dict con valor por defecto), Counter (contador), heapq (cola de prioridad) y más.

🔗 Python docs — collections

Sintaxis básica

from collections import deque, defaultdict, Counter, ChainMap
from heapq import heappush, heappop, nlargest

d = deque([1, 2, 3])
d.append(4)
d.appendleft(0)
d.pop()
d.popleft()

dd = defaultdict(list)
dd["frutas"].append("manzana")

frecuencia = Counter("python es genial")
print(frecuencia.most_common(3))

heap = []
heappush(heap, 3)
heappush(heap, 1)
heappush(heap, 2)
print(heappop(heap))

🧪 Cómo probarlo

import pytest
from collections import deque, defaultdict, Counter
from heapq import heappush, heappop

def test_deque():
    d = deque([1, 2])
    d.appendleft(0)
    d.append(3)
    assert list(d) == [0, 1, 2, 3]

def test_defaultdict():
    dd = defaultdict(int)
    dd["a"] += 1
    assert dd["a"] == 1
    assert dd["b"] == 0

def test_counter():
    c = Counter("abbccc")
    assert c.most_common(1) == [("c", 3)]

def test_heapq():
    h = []
    heappush(h, 5)
    heappush(h, 1)
    heappush(h, 3)
    assert heappop(h) == 1

💡 Memoria y rendimiento

• deque: O(1) en ambos extremos (vs O(n) en list para el inicio)
• defaultdict: mismo rendimiento que dict, sin overhead por valores ausentes
• Counter: O(n) para construir, O(n log n) para most_common
• heapq: O(log n) push/pop, O(1) para ver el mínimo

✅ Buenas prácticas

• ✅ Usa deque para colas (FIFO) y pilas (LIFO)
• ⚠️ No uses list.pop(0) — es O(n); usa deque.popleft()
• ❌ No confundas set con Counter — Counter guarda frecuencias

🏗️ Metodología

• deque: colas, historial, buffers deslizantes
• defaultdict: agrupar elementos, acumular valores
• Counter: análisis de frecuencias, estadísticas
• heapq: prioridades, top-N elementos
• ChainMap: configuración por capas

🔗 Para saber más

• Python docs — collections
• Python docs — heapq
• Real Python — deque

itertools y functools

¿Qué es?

itertools proporciona iteradores eficientes para composición de datos (producto cartesiano, permutaciones, agrupación). functools ofrece herramientas para funciones de orden superior (parciales, memoización, sobrecarga).

🔗 Python docs — itertools, functools

Sintaxis básica

from itertools import chain, cycle, permutations, combinations, groupby, product, accumulate
from functools import reduce, partial, cache, singledispatch

list(chain([1, 2], [3, 4]))
list(zip(range(5), cycle("AB")))
list(permutations("ABC", 2))
list(combinations("ABC", 2))
list(accumulate([1, 2, 3, 4]))

@cache
def fibonacci(n):
    return n if n < 2 else fibonacci(n-1) + fibonacci(n-2)

@singledispatch
def procesar(x):
    raise NotImplementedError
@procesar.register(str)
def _(x): return f"Texto: {x}"
@procesar.register(int)
def _(x): return f"Número: {x}"

🧪 Cómo probarlo

import pytest
from itertools import chain, accumulate
from functools import partial, cache

def test_chain():
    assert list(chain([1, 2], [3, 4])) == [1, 2, 3, 4]

def test_accumulate():
    assert list(accumulate([1, 2, 3, 4])) == [1, 3, 6, 10]

def test_partial():
    def potencia(base, exp): return base ** exp
    cuadrado = partial(potencia, exp=2)
    assert cuadrado(5) == 25

def test_cache():
    llamadas = 0
    @cache
    def suma(a, b):
        nonlocal llamadas
        llamadas += 1
        return a + b
    assert suma(1, 2) == 3
    assert suma(1, 2) == 3
    assert llamadas == 1

💡 Memoria y rendimiento

• itertools funciones son lazy — no crean listas intermedias
• chain evita concatenar listas (O(1) vs O(n) memoria)
• cache (3.9+) es memoización sin límite
• groupby requiere datos ordenados por la clave

✅ Buenas prácticas

• ✅ Usa itertools para evitar bucles anidados y listas intermedias
• ⚠️ groupby solo agrupa elementos consecutivos — ordena primero
• ❌ No abuses de reduce si una comprehension es más legible

🏗️ Metodología

• chain: concatenar múltiples iterables sin copiar
• groupby: procesar datos agrupados (logs, eventos)
• cache: funciones costosas con llamadas repetidas
• singledispatch: sobrecarga de funciones por tipo sin herencia

🔗 Para saber más

• Real Python — itertools
• Python docs — functools

Complejidad Big O

¿Qué es?

Big O describe cómo crece el tiempo de ejecución (o memoria) de un algoritmo según el tamaño de la entrada. Es el lenguaje universal para hablar de rendimiento de algoritmos.

🔗 Wikipedia — Big O

Sintaxis básica

🧪 Cómo probarlo

import pytest
import time

def test_big_o_lineal():
    n = 100_000
    lista = list(range(n))
    inicio = time.perf_counter()
    99999 in lista
    t_lista = time.perf_counter() - inicio

    conjunto = set(lista)
    inicio = time.perf_counter()
    99999 in conjunto
    t_set = time.perf_counter() - inicio

    assert t_set < t_lista

💡 Memoria y rendimiento

• list.append() es O(1) amortizado — ocasionalmente O(n) cuando redimensiona
• dict/set tienen factor de carga ~2/3 — ocupan más memoria que listas
• No optimices prematuramente — primero perfila con datos reales

✅ Buenas prácticas

• ✅ Elige la estructura según la operación dominante
• ⚠️ No optimices prematuramente
• ❌ No asumas que O(1) en teoría significa rápido en la práctica

🏗️ Metodología

• Búsqueda intensiva: set/dict (O(1))
• Cola FIFO: deque (O(1))
• Prioridad: heapq (O(log n))
• Ordenación única: sorted() (Timsort O(n log n))

🔗 Para saber más

• Python Wiki — Time Complexity
• Big O Cheat Sheet
• Real Python — Big O

Conceptos clave explicados a fondo

Decoradores

¿Qué es?

Un decorador es una función que envuelve a otra para extender su comportamiento sin modificar su código fuente. Es el patrón Decorator integrado en la sintaxis del lenguaje con @. Como ponerle una funda a tu móvil: el móvil sigue siendo el mismo, pero ahora tiene protección extra.

🔗 Python docs — Decorators

Sintaxis básica

from functools import wraps
import time

def medir_tiempo(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        inicio = time.perf_counter()
        resultado = func(*args, **kwargs)
        fin = time.perf_counter()
        print(f"{func.__name__} tardó {fin - inicio:.4f}s")
        return resultado
    return wrapper

@medir_tiempo
def calcular():
    return sum(range(10_000_000))

def repetir(n: int):
    def decorador(func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            for _ in range(n):
                func(*args, **kwargs)
        return wrapper
    return decorador

@repetir(3)
def saludar():
    print("Hola!")

🧪 Cómo probarlo

import pytest
from functools import wraps

def test_decorador_simple():
    llamado = []
    def decorador(func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            llamado.append(1)
            return func(*args, **kwargs)
        return wrapper

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

    assert suma(2, 3) == 5
    assert len(llamado) == 1

def test_decorador_con_argumentos():
    def repetir(n):
        def decorador(func):
            @wraps(func)
            def wrapper(*args, **kwargs):
                for _ in range(n):
                    func(*args, **kwargs)
            return wrapper
        return decorador

    resultados = []
    @repetir(3)
    def registrar():
        resultados.append("ok")

    registrar()
    assert len(resultados) == 3

💡 Memoria y rendimiento

• Cada nivel de decoración añade overhead de llamada a función
• @wraps es importante pero añade mínima sobrecarga
• Cadenas de decoradores (>5) pueden afectar legibilidad y rendimiento

✅ Buenas prácticas

• ✅ Siempre usa @functools.wraps en decoradores
• ⚠️ No anides más de 3-4 decoradores — la legibilidad se resiente
• ❌ No uses decoradores para efectos secundarios en tiempo de importación

🏗️ Metodología

• Decoradores para concerns transversales: logging, timing, caché, autorización
• En APIs web: FastAPI usa decoradores (@app.get())
• En proyectos grandes: considera decoradores de clase

🔗 Para saber más

• PEP 318 — Decorators
• Real Python — Primer on Decorators
• Python docs — functools.wraps

El GIL (Global Interpreter Lock)

¿Qué es?

El GIL es un mutex que protege el intérprete de CPython: solo un thread ejecuta bytecode Python a la vez. Esto significa que threading no sirve para paralelismo CPU-bound, pero sí para I/O-bound. Es como un turno en una tienda: aunque haya varios dependientes, solo un cliente puede ser atendido a la vez.

🔗 Real Python — GIL

Sintaxis básica

import threading, time, multiprocessing

def contar(n):
    while n > 0:
        n -= 1

t1 = threading.Thread(target=contar, args=(10_000_000,))
t2 = threading.Thread(target=contar, args=(10_000_000,))
inicio = time.time()
t1.start(); t2.start()
t1.join(); t2.join()
print(time.time() - inicio)

p1 = multiprocessing.Process(target=contar, args=(10_000_000,))
p2 = multiprocessing.Process(target=contar, args=(10_000_000,))

🧪 Cómo probarlo

import pytest, time, threading

def test_gil_io_bound():
    import urllib.request
    urls = ["https://httpbin.org/delay/1"] * 3

    def descargar(url):
        urllib.request.urlopen(url, timeout=5)

    threads = [threading.Thread(target=descargar, args=(u,)) for u in urls]
    inicio = time.time()
    for t in threads: t.start()
    for t in threads: t.join()
    duracion = time.time() - inicio
    assert duracion < 3

💡 Memoria y rendimiento

• Threading CPU-bound: peor que secuencial (contienda por el GIL)
• Threading I/O-bound: hasta 10x más rápido que secuencial
• multiprocessing: paralelismo real, pero mayor overhead de memoria
• asyncio: cooperativo, sin GIL (un solo hilo, sin contienda de lock)

✅ Buenas prácticas

• ✅ I/O-bound → asyncio o threading
• ⚠️ CPU-bound → multiprocessing o librerías C (numpy) que liberan el GIL
• ❌ No mezcles asyncio con threading sin entender las implicaciones

🏗️ Metodología

• I/O (HTTP, BD, archivos): asyncio (más eficiente que threads)
• CPU puro: multiprocessing
• CPU + I/O: asyncio con ProcessPoolExecutor
• Librerías C (numpy, pandas): liberan el GIL automáticamente

🔗 Para saber más

• Python docs — GIL
• Real Python — GIL
• PEP 703 — free-threaded Python

Duck typing

¿Qué es?

“Si camina como pato y habla como pato, entonces es un pato”. Python no mira el tipo nominal del objeto, sino su comportamiento: si tiene el método que necesitas, funciona.

🔗 Wikipedia — Duck typing

Sintaxis básica

class Pato:
    def hablar(self): return "Cuac"

class Persona:
    def hablar(self): return "Hola"

def hacer_hablar(cosa):
    print(cosa.hablar())

hacer_hablar(Pato())     # Cuac
hacer_hablar(Persona())  # Hola

from typing import Protocol

class Hablador(Protocol):
    def hablar(self) -> str: ...

🧪 Cómo probarlo

import pytest

def test_duck_typing():
    class Perro:
        def sonido(self): return "Guau"
    class Gato:
        def sonido(self): return "Miau"

    def hacer_sonido(animal):
        return animal.sonido()

    assert hacer_sonido(Perro()) == "Guau"
    assert hacer_sonido(Gato()) == "Miau"

    class Coche:
        def sonido(self): return "Brum"
    assert hacer_sonido(Coche()) == "Brum"

💡 Memoria y rendimiento

• Duck typing tiene overhead: cada llamada a método busca el atributo en el diccionario del objeto
• Protocol es solo para type checkers — no tiene impacto en runtime

✅ Buenas prácticas

• ✅ Usa Protocol para documentar interfaces esperadas
• ⚠️ No confíes en duck typing para APIs públicas sin documentar
• ❌ No abuses de hasattr() para comprobar capacidades — prefiere EAFP

🏗️ Metodología

• Duck typing para código interno y tests
• Protocol para interfaces públicas y APIs
• ABC para jerarquías de clases con implementación compartida

🔗 Para saber más

• PEP 544 — Protocols
• Python docs — duck typing

EAFP vs LBYL

¿Qué es?

Python prefiere EAFP (Easier to Ask Forgiveness than Permission): intenta la operación y captura la excepción si falla. El enfoque alternativo es LBYL (Look Before You Leap): verifica antes de hacer la operación.

🔗 Python glossary — EAFP

Sintaxis básica

# LBYL
if os.path.exists(archivo):
    with open(archivo) as f:
        ...

# EAFP — Pythonic
try:
    with open(archivo) as f:
        ...
except FileNotFoundError:
    print("Archivo no encontrado")

🧪 Cómo probarlo

import pytest

def test_eafp_mas_rapido():
    datos_validos = {"a": 1}
    import time

    def lbyl(d):
        if "a" in d:
            return d["a"]
        return None

    def eafp(d):
        try:
            return d["a"]
        except KeyError:
            return None

    inicio = time.perf_counter()
    for _ in range(100_000):
        lbyl(datos_validos)
    t_lbyl = time.perf_counter() - inicio

    inicio = time.perf_counter()
    for _ in range(100_000):
        eafp(datos_validos)
    t_eafp = time.perf_counter() - inicio

    assert t_eafp < t_lbyl * 2

💡 Memoria y rendimiento

• EAFP es más rápido cuando el caso exitoso es común
• LBYL es más rápido cuando el fallo es común
• Construir una excepción es caro (~50μs)

✅ Buenas prácticas

• ✅ Usa EAFP para operaciones que esperas que funcionen la mayoría del tiempo
• ⚠️ No uses EAFP si la condición previa es barata y el error es caro
• ❌ No uses EAFP para control de flujo normal

🏗️ Metodología

• APIs de archivos y red: EAFP (los errores son esperados)
• Validación de datos externos: LBYL primero, luego EAFP
• Operaciones atómicas: EAFP evita race conditions

🔗 Para saber más

• Python glossary — EAFP
• Stack Overflow — EAFP vs LBYL

Peculiaridades del lenguaje

¿Qué es?

Python tiene peculiaridades que lo hacen único: chaining de comparaciones, unpacking con *, for...else, _ como throwaway, y type hints no vinculantes.

🔗 Python docs — Expressions

Sintaxis básica

# Chaining
if 1 < x < 10:
    ...

# Unpacking
primero, *resto, ultimo = [1, 2, 3, 4, 5]

# for...else
for n in range(2, 10):
    for divisor in range(2, int(n**0.5) + 1):
        if n % divisor == 0:
            break
    else:
        print(f"{n} es primo")

# Type hints no vinculantes
def suma(a: int, b: int) -> int:
    return a + b
suma("hola", "mundo")  # funciona

🧪 Cómo probarlo

import pytest

def test_chaining():
    x = 5
    assert 1 < x < 10

def test_unpacking():
    primero, *resto, ultimo = [1, 2, 3, 4]
    assert primero == 1
    assert resto == [2, 3]
    assert ultimo == 4

def test_type_hints_no_vinculantes():
    def suma(a: int, b: int) -> int:
        return a + b
    assert suma("hola", " mundo") == "hola mundo"

💡 Memoria y rendimiento

• Chaining de comparaciones no tiene overhead adicional
• Unpacking es O(n) pero implementado en C — muy rápido
• Type hints se descartan en runtime — no tienen impacto

✅ Buenas prácticas

• ✅ Usa chaining para rangos (0 <= x < 100)
• ⚠️ No abuses de unpacking con muchos elementos
• ❌ No confíes en type hints para validación en runtime

🏗️ Metodología

• Chaining: mejora legibilidad en rangos y comparaciones múltiples
• Unpacking: intercambio de variables, división de secuencias
• for...else: búsquedas con flag de encontrado

🔗 Para saber más

• Python docs — Expressions
• Real Python — Python’s for-else Loop

POO avanzada: herencia, protocolos y patrones

Herencia y MRO

¿Qué es?

Python soporta herencia múltiple. El MRO (Method Resolution Order) determina el orden en que se buscan los métodos. Python usa el algoritmo C3 linearization para resolver conflictos.

🔗 Python docs — MRO

Sintaxis básica

class A:
    def metodo(self): return "A"

class B(A):
    def metodo(self): return "B"

class C(A):
    def metodo(self): return "C"

class D(B, C):
    pass

d = D()
print(d.metodo())          # "B"
print(D.__mro__)           # (D, B, C, A, object)

🧪 Cómo probarlo

import pytest

def test_mro():
    class A:
        def metodo(self): return "A"
    class B(A):
        def metodo(self): return "B"
    class C(A):
        def metodo(self): return "C"
    class D(B, C):
        pass

    d = D()
    assert d.metodo() == "B"
    assert D.__mro__[1] == B

def test_super_sigue_mro():
    class A:
        def nombre(self): return "A"
    class B(A):
        def nombre(self): return "B" + super().nombre()
    class C(A):
        def nombre(self): return "C" + super().nombre()
    class D(B, C):
        def nombre(self): return "D" + super().nombre()

    assert D().nombre() == "DBCA"

💡 Memoria y rendimiento

• El MRO se calcula una vez en la definición de la clase
• super() es ligeramente más lento que llamar al método directamente
• El MRO se almacena en __mro__ (tupla) — O(1) acceso

✅ Buenas prácticas

• ✅ Usa super().__init__() en lugar de ClaseBase.__init__(self)
• ⚠️ La herencia múltiple es compleja — prefiere composición o mixins
• ❌ No crees diamantes profundos (>3 niveles) sin entender el MRO

🏗️ Metodología

• Herencia simple para “es un” (Animal → Perro)
• Mixins para “tiene la capacidad de” (Exportable, Serializable)
• Composición para “tiene un” (Coche → Motor, Ruedas)
• Protocols para “puede ser usado como”

🔗 Para saber más

• Python docs — Inheritance
• Real Python — super()

ABC y Protocolos

¿Qué es?

ABC (Abstract Base Class) define interfaces mediante herencia explícita. Protocol (PEP 544) define interfaces por estructura: si un objeto tiene los métodos, implementa el protocolo.

🔗 PEP 544 — Protocols

Sintaxis básica

from abc import ABC, abstractmethod
from typing import Protocol

class Animal(ABC):
    @abstractmethod
    def hacer_sonido(self) -> str: ...

class Perro(Animal):
    def hacer_sonido(self) -> str: return "Guau"

class Volador(Protocol):
    def volar(self) -> None: ...

class Pajaro:
    def volar(self) -> None:
        print("Volando")

def lanzar(objeto: Volador):
    objeto.volar()

lanzar(Pajaro())  # OK

🧪 Cómo probarlo

import pytest
from abc import ABC, abstractmethod
from typing import Protocol

def test_abc_no_instanciable():
    class Base(ABC):
        @abstractmethod
        def metodo(self): ...
    with pytest.raises(TypeError):
        Base()

def test_protocol_estructural():
    class Imprimible(Protocol):
        def imprimir(self) -> str: ...
    class Doc:
        def imprimir(self) -> str: return "doc"
    def procesar(x: Imprimible):
        return x.imprimir()
    assert procesar(Doc()) == "doc"

💡 Memoria y rendimiento

• ABC y Protocol tienen zero overhead en runtime
• isinstance() con ABC registrado es más caro que sin él

✅ Buenas prácticas

• ✅ Usa ABC cuando hay implementación compartida (template method)
• ⚠️ Usa Protocol cuando solo importa la interfaz
• ❌ No mezcles ABC y Protocol en la misma jerarquía sin necesidad

🏗️ Metodología

• Frameworks: ABC para hooks que el usuario debe implementar
• Librerías: Protocol para tipos genéricos sin acoplar
• Tests: Protocol para mockear dependencias fácilmente

🔗 Para saber más

• Python docs — abc
• Real Python — Python Protocols

Dataclasses

¿Qué es?

@dataclass genera automáticamente __init__, __repr__, __eq__ (y opcionalmente __hash__, __lt__). Elimina el boilerplate de clases que solo almacenan datos.

🔗 Python docs — dataclasses

Sintaxis básica

from dataclasses import dataclass, field
from typing import List

@dataclass
class Usuario:
    nombre: str
    email: str
    edad: int = 0
    tags: List[str] = field(default_factory=list)
    activo: bool = field(default=True, repr=False)

    def __post_init__(self):
        if self.edad < 0:
            raise ValueError("La edad no puede ser negativa")

🧪 Cómo probarlo

import pytest
from dataclasses import dataclass

def test_dataclass_basico():
    @dataclass
    class Punto:
        x: int
        y: int

    p = Punto(1, 2)
    assert p.x == 1
    assert p.y == 2
    assert repr(p) == "Punto(x=1, y=2)"
    assert Punto(1, 2) == Punto(1, 2)

def test_dataclass_frozen():
    @dataclass(frozen=True)
    class Inmutable:
        valor: int
    i = Inmutable(42)
    with pytest.raises(AttributeError):
        i.valor = 99

def test_default_factory():
    @dataclass
    class Caja:
        items: list = None
    c = Caja()
    assert c.items is None

💡 Memoria y rendimiento

• Las dataclasses son clases Python normales — mismo overhead
• frozen=True usa __setattr__ más lento
• __slots__ no es compatible directamente con dataclasses

✅ Buenas prácticas

• ✅ Usa default_factory para valores mutables
• ⚠️ No uses list/dict como valor por defecto
• ❌ No abuses de dataclasses para objetos con mucha lógica de negocio

🏗️ Metodología

• DTOs, configuraciones, resultados: dataclasses son perfectas
• Objetos de dominio con comportamiento: clases normales
• Validación compleja: __post_init__ o Pydantic

🔗 Para saber más

• Real Python — Data Classes
• Python docs — dataclasses

Métodos mágicos

¿Qué es?

Los métodos mágicos (dunder methods) son métodos con doble guion bajo que permiten que tus objetos se comporten como tipos nativos de Python.

🔗 Python docs — Special method names

Sintaxis básica

class ListaPersonalizada:
    def __init__(self, datos=None):
        self._datos = datos or []

    def __getitem__(self, idx):      # objeto[0]
        return self._datos[idx]

    def __setitem__(self, idx, val): # objeto[0] = "nuevo"
        self._datos[idx] = val

    def __len__(self):               # len(objeto)
        return len(self._datos)

    def __iter__(self):              # for x in objeto:
        return iter(self._datos)

    def __contains__(self, item):    # item in objeto
        return item in self._datos

    def __call__(self, *args):       # objeto(args)
        print(f"Llamado con {args}")

    def __enter__(self):             # with objeto as x:
        return self

    def __exit__(self, *args): pass

    def __str__(self):               # str(objeto)
        return str(self._datos)

    def __repr__(self):              # repr(objeto)
        return f"ListaPersonalizada({self._datos!r})"

🧪 Cómo probarlo

import pytest

def test_metodos_magicos():
    class Contenedor:
        def __init__(self, items):
            self._items = items
        def __getitem__(self, idx):
            return self._items[idx]
        def __len__(self):
            return len(self._items)
        def __contains__(self, item):
            return item in self._items
        def __str__(self):
            return f"Contenedor({self._items})"

    c = Contenedor([1, 2, 3])
    assert c[0] == 1
    assert len(c) == 3
    assert 2 in c
    assert str(c) == "Contenedor([1, 2, 3])"

💡 Memoria y rendimiento

• Los métodos mágicos se buscan en la clase (no en la instancia)
• __call__ añade overhead de llamada a función
• Cada método mágico tiene propósitos específicos

✅ Buenas prácticas

• ✅ Implementa __repr__ siempre (útil para debugging)
• ⚠️ Si implementas __eq__, considera implementar __hash__
• ❌ No implementes __del__ a menos que sea estrictamente necesario

🏗️ Metodología

• __str__ vs __repr__: __repr__ para debugging, __str__ para usuario
• __enter__/__exit__: para context managers personalizados
• __getitem__/__len__: para objetos que parecen colecciones

🔗 Para saber más

• Python docs — Special Methods
• Real Python — Magic Methods

Patrones de diseño en Python

¿Qué es?

Los patrones de diseño son soluciones reutilizables a problemas comunes. Python simplifica muchos patrones gracias a funciones como ciudadanos de primera clase, duck typing y módulos como singletons.

🔗 Wikipedia — Patrón de diseño

Sintaxis básica

class Plugin:
    _registry = {}
    def __init_subclass__(cls, **kwargs):
        super().__init_subclass__(**kwargs)
        cls._registry[cls.__name__.lower()] = cls

class PluginPDF(Plugin):
    def ejecutar(self): return "PDF"

def crear_plugin(tipo: str) -> Plugin:
    return Plugin._registry[tipo]()

🧪 Cómo probarlo

import pytest

def test_strategy_con_funciones():
    def ordenar_asc(datos): return sorted(datos)
    def ordenar_desc(datos): return sorted(datos, reverse=True)

    class Analizador:
        def __init__(self, estrategia):
            self.estrategia = estrategia
        def analizar(self, datos):
            return self.estrategia(datos)

    a = Analizador(ordenar_desc)
    assert a.analizar([3, 1, 2]) == [3, 2, 1]

def test_observer():
    llamado = []
    class Observable:
        def __init__(self):
            self._obs = []
        def conectar(self, cb):
            self._obs.append(cb)
        def notificar(self, dato):
            for cb in self._obs:
                cb(dato)

    obs = Observable()
    obs.conectar(lambda d: llamado.append(d))
    obs.notificar("test")
    assert llamado == ["test"]