Mis apuntes · Aprende Python desde PHP

Se guardan solos en este navegador mientras escribes. Puedes usar Markdown. Al descargarlos, la primera línea es tu enlace personal al curso.

Lección 42 de 47 · Proyecto final: CRUD de tareas con SQLite ✦ WebMCP implementado

Fase 1: el esquema en SQLite y las migraciones

10 min de lectura 4 retos

Empieza el proyecto final: la app de tareas de verdad, con base de datos, API y despliegue. En esta primera fase montas las carpetas del proyecto, eliges SQLite (que ya viene dentro de Python) y escribes las migraciones que crean la tabla tareas.

¿De dónde vienen los nombres?

sqlite3 = SQLite = SQL + lite (ligero); el 3 es la versión del formato de fichero
El módulo de la biblioteca estándar que habla con SQLite. Es tu PDO con el driver pdo_sqlite, pero ya instalado.
execute = inglés execute (ejecutar)
Lanza una sentencia SQL. Es el $pdo->exec() y el $pdo->query() de PHP en uno solo.
commit = inglés commit (confirmar, comprometerse)
Confirma los cambios pendientes de la transacción: hasta que no haces commit, solo existen para tu conexión.
lastrowid = inglés last row id (id de la última fila)
El id que SQLite acaba de dar al último INSERT. Es el $pdo->lastInsertId() de PHP.
migración = del latín migrare (cambiar de sitio): pasar la base de datos de una versión a la siguiente
Un cambio en el esquema guardado como código, con un número para saber el orden.
En 4 ideas
1/4

El proyecto se reparte en carpetas por capa: app/domain, app/application y app/infrastructure, con el arranque en app/main.py. Es tu src/Domain, src/Application y src/Infrastructure de un PHP con DDD.

1 · El plan: seis fases y una carpeta por capa

Hasta ahora has visto el lenguaje pieza a pieza. Ahora toca montar algo entero. Piensa en una casa: primero los cimientos (la base de datos), luego las paredes (el dominio), las tuberías (el repositorio), las habitaciones (los casos de uso), la puerta de la calle (la API) y por último la mudanza (el despliegue).

  1. Fase 1: el esquema en SQLite y las migraciones (esta lección).
  2. Fase 2: el dominio, la entidad Tarea y sus reglas.
  3. Fase 3: el repositorio, un Protocol con dos versiones: SQLite y en memoria.
  4. Fase 4: los casos de uso: crear, listar, completar y borrar.
  5. Fase 5: la API con FastAPI, servida con uvicorn.
  6. Fase 6: tests con pytest y despliegue con Docker.

Cada fase parte del código de la anterior. Así queda el proyecto cuando acabes:

tareas/
├── requirements.txt              ← el composer.json
├── Dockerfile
├── app/
│   ├── main.py                   ← el public/index.php: crea la app
│   ├── domain/                   ← Tarea, Prioridad, errores, el Protocol del repositorio
│   ├── application/              ← CrearTarea, ListarTareas, CompletarTarea, BorrarTarea
│   └── infrastructure/
│       ├── sqlite/               ← migraciones y RepositorioSqlite
│       └── api/                  ← rutas, modelos pydantic y dependencias
└── tests/                        ← pytest
CarpetaQué va dentroEn un PHP con DDD
app/main.pyCrea la aplicación y enchufa las rutaspublic/index.php + el contenedor de dependencias
app/domainLa entidad Tarea, sus reglas y sus erroressrc/Domain
app/applicationLo que la app sabe hacer, un caso de uso por acciónsrc/Application (los services o handlers)
app/infrastructure/sqliteCómo se guardan las tareas (SQL)src/Infrastructure/Repository
app/infrastructure/apiRutas, modelos de entrada y salidasrc/Infrastructure/Http (controladores)
requirements.txtLas dependencias y sus versionescomposer.json

Equivalencia POO · PHP → Python

Cada carpeta con un fichero __init__.py es un paquete (lo viste en el módulo 09). La ruta del import hace de namespace y de use a la vez.

PHPPythonQuién lo ve
namespace App\Domain;El fichero app/domain/tarea.pyEl nombre sale de la ruta: no se declara
use App\Domain\Tarea;from app.domain.tarea import TareaCualquiera que tenga app en su ruta de búsqueda
@internal en un docblock (solo un aviso)Un guion bajo delante: _conexion, _interno.pyNadie lo impide: es un acuerdo entre personas
Autoload PSR-4 de Composersys.path y las carpetas con __init__.pyEl intérprete lo resuelve al hacer import

¿Por qué? · En PHP no existe

¿Por qué tres capas y no un solo fichero? En PHP también se puede, y falla igual

Con todo en un fichero, el SQL, las reglas del negocio y las rutas se mezclan: para cambiar de SQLite a MySQL tienes que tocar también el código que decide qué es una tarea válida.

Con capas, el dominio no sabe nada de la base de datos ni de la web y puedes probarlo con un assert, sin servidor. Cada capa solo mira hacia dentro: la API conoce los casos de uso, los casos de uso conocen el dominio, y el dominio no conoce a nadie.

2 · SQLite sin instalar nada: el módulo sqlite3

SQLite es una base de datos que cabe en un fichero, por ejemplo tareas.db. No hay servidor que instalar ni usuario ni contraseña: es como una libreta en vez de una biblioteca entera. Para una app de tareas sobra. Y en Python no hay que instalar ningún driver: el módulo sqlite3 viene con el propio lenguaje.

Esta es la dinámica de siempre: conectas, ejecutas SQL y lees filas. Usamos la ruta especial ":memory:", una base de datos que vive solo mientras dura el programa: perfecta para probar, y la única que funciona en el navegador. Pulsa Ejecutar:

Pythonmain.py
import sqlite3

# En PHP: $pdo = new PDO("sqlite::memory:");
conexion = sqlite3.connect(":memory:")

conexion.execute(
    "CREATE TABLE tareas (id INTEGER PRIMARY KEY AUTOINCREMENT, titulo TEXT NOT NULL)"
)

# En PHP: $pdo->prepare("INSERT INTO tareas (titulo) VALUES (?)")->execute(["Comprar pan"]);
conexion.execute("INSERT INTO tareas (titulo) VALUES (?)", ("Comprar pan",))
conexion.execute("INSERT INTO tareas (titulo) VALUES (?)", ("Llamar al banco",))

# En PHP: foreach ($pdo->query("SELECT id, titulo FROM tareas") as $fila) { ... }
for fila in conexion.execute("SELECT id, titulo FROM tareas"):
    print(fila)

conexion.close()
PHP 8.5tareas.php
<?php
declare(strict_types=1);

$pdo = new PDO("sqlite::memory:");
$pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);

$pdo->exec("CREATE TABLE tareas (id INTEGER PRIMARY KEY AUTOINCREMENT, titulo TEXT NOT NULL)");

$insertar = $pdo->prepare("INSERT INTO tareas (titulo) VALUES (?)");
$insertar->execute(["Comprar pan"]);
$insertar->execute(["Llamar al banco"]);

foreach ($pdo->query("SELECT id, titulo FROM tareas") as $fila) {
    echo $fila["id"] . " " . $fila["titulo"] . PHP_EOL;
}
Pythontareas.py
import sqlite3

conexion = sqlite3.connect(":memory:")
conexion.execute(
    "CREATE TABLE tareas (id INTEGER PRIMARY KEY AUTOINCREMENT, titulo TEXT NOT NULL)"
)

conexion.execute("INSERT INTO tareas (titulo) VALUES (?)", ("Comprar pan",))
conexion.execute("INSERT INTO tareas (titulo) VALUES (?)", ("Llamar al banco",))

for id, titulo in conexion.execute("SELECT id, titulo FROM tareas"):
    print(id, titulo)
  1. sqlite3.connect(...) devuelve la conexión: es tu PDO. No hay new ni setAttribute: los errores de SQL ya llegan como excepciones (sqlite3.OperationalError), que en PDO hay que pedir con ERRMODE_EXCEPTION.
  2. conexion.execute(sql, parametros) hace de prepare() + execute() en una línea. Los parámetros van en una tupla, por eso ("Comprar pan",) lleva coma: sin ella sería solo un texto entre paréntesis.
  3. Un SELECT devuelve algo que se recorre con for; cada fila es una tupla que se desempaqueta directamente: for id, titulo in ....

¿Por qué? · En PHP no existe

¿Por qué los parámetros van aparte, con ?, y no dentro del texto del SQL?

Si pegas el título dentro del texto (f"... VALUES ('{titulo}')"), un título como O'Brien rompe la consulta, y uno escrito con mala idea cambia lo que hace: es la inyección SQL. Con ?, la base de datos recibe el SQL por un lado y los valores por otro, y los valores nunca se interpretan como SQL.

En PHP ya lo sabes por prepare(); en Python es igual de importante y más fácil de olvidar, porque una f-string compila y funciona en la demo. Lo veremos roto en la fase 3.

3 · El esquema: la tabla tareas

El esquema es el plano de la base de datos: qué tablas hay y qué columnas lleva cada una. La nuestra tiene una sola, tareas. Es SQL normal, el mismo que escribirías para PHP:

Pythonmain.py
CREATE_TAREAS = """
CREATE TABLE tareas (
    id        INTEGER PRIMARY KEY AUTOINCREMENT,
    titulo    TEXT    NOT NULL,
    prioridad INTEGER NOT NULL DEFAULT 1,
    hecha     INTEGER NOT NULL DEFAULT 0,
    creada_en TEXT    NOT NULL
)
"""

SQLite tiene muy pocos tipos. No hay BOOLEAN ni DATETIME: un sí/no se guarda como 0 o 1, y una fecha como texto (2026-11-19T10:00:00+00:00). Es como apuntar «hecha: 1» en una libreta: el qué significa lo decide tu programa.

ColumnaTipo en SQLiteTipo en Python al leerEn la Tarea
idINTEGERintid: int | None
tituloTEXTstrtitulo: str
prioridadINTEGER (0, 1, 2)intprioridad: Prioridad (el enum del módulo 05)
hechaINTEGER (0 o 1)inthecha: bool
creada_enTEXTstrNo está: la pone el repositorio

Así que leer una fila es traducir. Primero llega una fila con números y texto, y luego la conviertes en una tarea. Con row_factory = sqlite3.Row las filas se leen por nombre de columna, como el FETCH_ASSOC de PDO. Pulsa Ejecutar:

Pythonmain.py
import sqlite3

conexion = sqlite3.connect(":memory:")
# En PHP: $pdo->setAttribute(PDO::ATTR_DEFAULT_FETCH_MODE, PDO::FETCH_ASSOC);
conexion.row_factory = sqlite3.Row

conexion.execute("""
CREATE TABLE tareas (
    id        INTEGER PRIMARY KEY AUTOINCREMENT,
    titulo    TEXT    NOT NULL,
    prioridad INTEGER NOT NULL DEFAULT 1,
    hecha     INTEGER NOT NULL DEFAULT 0,
    creada_en TEXT    NOT NULL
)
""")
conexion.execute(
    "INSERT INTO tareas (titulo, prioridad, hecha, creada_en) VALUES (?, ?, ?, ?)",
    ("Comprar pan", 2, 0, "2026-11-19T10:00:00+00:00"),
)
conexion.execute(
    "INSERT INTO tareas (titulo, hecha, creada_en) VALUES (?, ?, ?)",
    ("Llamar al banco", 1, "2026-11-19T10:05:00+00:00"),
)

for fila in conexion.execute("SELECT id, titulo, prioridad, hecha FROM tareas"):
    # En PHP: $hecha = (bool) $fila['hecha'];
    hecha = bool(fila["hecha"])
    print(f"#{fila['id']} {fila['titulo']:<16} prioridad={fila['prioridad']} hecha={hecha}")

¿Por qué? · En PHP no existe

¿Por qué hecha es INTEGER y no BOOLEAN? En PHP con MySQL sí existe

SQLite decide el tipo por el valor que guardas, no por la columna: es de tipado flexible. Por eso no tiene tipos fijos para sí/no ni para fechas, y se guarda lo que haga falta (0/1, texto ISO).

Lo bueno: es sencillísimo. Lo malo: nada te impide meter "talvez" en hecha. Por eso la traducción bool(fila["hecha"]) se hace en un único sitio (el repositorio, fase 3) y el resto del programa solo ve un bool.

4 · Migraciones: el historial de la base de datos

Una migración es un cambio en la base de datos guardado como código, con un número delante para saber el orden. Es como el historial de obras de una casa: «1, poner los cimientos; 2, abrir una ventana». Nunca se edita una obra antigua: si hace falta algo nuevo, se añade otra.

Nuestra primera migración crea la tabla; la segunda añade las etiquetas, guardadas como texto separado por comas (casa,urgente). Para saber cuáles ya están hechas, se apuntan en una tabla migraciones. El programa aplica en orden las que falten. Lo mismo que hacen Phinx o Laravel, escrito a mano:

PHP 8.5migrar.php
<?php
declare(strict_types=1);

$migraciones = [
    "001_crear_tareas" => "CREATE TABLE tareas (id INTEGER PRIMARY KEY AUTOINCREMENT, titulo TEXT NOT NULL)",
    "002_etiquetas" => "ALTER TABLE tareas ADD COLUMN etiquetas TEXT NOT NULL DEFAULT ''",
];

$pdo = new PDO("sqlite::memory:");
$pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
$pdo->exec("CREATE TABLE IF NOT EXISTS migraciones (
    nombre TEXT PRIMARY KEY, aplicada_en TEXT NOT NULL)");

$hechas = $pdo->query("SELECT nombre FROM migraciones")->fetchAll(PDO::FETCH_COLUMN);
ksort($migraciones);

foreach ($migraciones as $nombre => $sql) {
    if (in_array($nombre, $hechas, true)) {
        continue;
    }
    $pdo->beginTransaction();
    try {
        $pdo->exec($sql);
        $pdo->prepare("INSERT INTO migraciones VALUES (?, datetime('now'))")->execute([$nombre]);
        $pdo->commit();
        echo "aplicada: $nombre" . PHP_EOL;
    } catch (Throwable $e) {
        $pdo->rollBack();
        throw $e;
    }
}
Pythonmigrar.py
import sqlite3
from datetime import UTC, datetime

MIGRACIONES = {
    "001_crear_tareas": "CREATE TABLE tareas (id INTEGER PRIMARY KEY AUTOINCREMENT, titulo TEXT NOT NULL)",
    "002_etiquetas": "ALTER TABLE tareas ADD COLUMN etiquetas TEXT NOT NULL DEFAULT ''",
}


def migrar(conexion):
    conexion.execute(
        "CREATE TABLE IF NOT EXISTS migraciones (nombre TEXT PRIMARY KEY, aplicada_en TEXT NOT NULL)"
    )
    hechas = {fila[0] for fila in conexion.execute("SELECT nombre FROM migraciones")}
    for nombre in sorted(MIGRACIONES):
        if nombre in hechas:
            continue
        conexion.execute("BEGIN")
        try:
            conexion.execute(MIGRACIONES[nombre])
            conexion.execute(
                "INSERT INTO migraciones (nombre, aplicada_en) VALUES (?, ?)",
                (nombre, datetime.now(UTC).isoformat(timespec="seconds")),
            )
            conexion.commit()
        except Exception:
            conexion.rollback()
            raise
        print("aplicada:", nombre)


migrar(sqlite3.connect(":memory:"))

Mira lo que ya conoces: el try / except con raise al final hace de catch + throw (módulo 07), los ? son parámetros y la receta es la de siempre: mirar qué falta, aplicarlo y apuntarlo, todo o nada. Y ahora la prueba de que es seguro repetirla:

Pythonmain.py
import sqlite3
from datetime import UTC, datetime

MIGRACIONES = {
    "001_crear_tareas": """
        CREATE TABLE tareas (
            id        INTEGER PRIMARY KEY AUTOINCREMENT,
            titulo    TEXT    NOT NULL,
            prioridad INTEGER NOT NULL DEFAULT 1,
            hecha     INTEGER NOT NULL DEFAULT 0,
            creada_en TEXT    NOT NULL
        )
    """,
    "002_etiquetas": "ALTER TABLE tareas ADD COLUMN etiquetas TEXT NOT NULL DEFAULT ''",
}


def migrar(conexion):
    """Aplica en orden las migraciones que falten y devuelve sus nombres."""
    conexion.execute(
        "CREATE TABLE IF NOT EXISTS migraciones (nombre TEXT PRIMARY KEY, aplicada_en TEXT NOT NULL)"
    )
    hechas = {fila[0] for fila in conexion.execute("SELECT nombre FROM migraciones")}
    nuevas = []
    for nombre in sorted(MIGRACIONES):
        if nombre in hechas:
            continue
        conexion.execute("BEGIN")
        try:
            conexion.execute(MIGRACIONES[nombre])
            conexion.execute(
                "INSERT INTO migraciones (nombre, aplicada_en) VALUES (?, ?)",
                (nombre, datetime.now(UTC).isoformat(timespec="seconds")),
            )
            conexion.commit()
        except Exception:
            conexion.rollback()
            raise
        nuevas.append(nombre)
    return nuevas


conexion = sqlite3.connect(":memory:")
print("primera vez:", migrar(conexion))
print("segunda vez:", migrar(conexion))

columnas = [fila[1] for fila in conexion.execute("PRAGMA table_info(tareas)")]
print("columnas:", columnas)

¿Por qué? · En PHP no existe

¿Por qué BEGIN a mano? En PHP, beginTransaction() abría la transacción y ya está

El módulo sqlite3 de Python abre las transacciones solo antes de un INSERT, UPDATE o DELETE, y no antes de un CREATE TABLE o un ALTER TABLE. Si no hicieras nada, la tabla se crearía al instante y, si el INSERT en migraciones fallara, quedaría creada pero sin apuntar: la siguiente vez intentaría crearla otra vez y daría error.

Con conexion.execute("BEGIN") abres tú la transacción y el commit() o el rollback() cubren las dos sentencias a la vez: o se hace todo, o no se hace nada. SQLite sí admite cambios de esquema dentro de una transacción; es Python quien, por defecto, no la abre.

5 · Abrir la base de datos y probarlo

En la app real abrirás un fichero (tareas.db) y migrarás al arrancar, una sola vez. En los tests usarás ":memory:": una base nueva y vacía por prueba, sin ficheros que limpiar.

Pythonmain.py
import sqlite3

from app.infrastructure.sqlite.migraciones import migrar

# En PHP: $pdo = new PDO("sqlite:" . $ruta);
conexion = sqlite3.connect("tareas.db")
migrar(conexion)
$ python -c "import sqlite3; print(sqlite3.sqlite_version)"
3.46.1

La pregunta que te vas a hacer

Vale, pero… ¿y mis migraciones de Laravel o mi Doctrine?

En Python hay herramientas para todo, pero para empezar el SQL a mano es lo más claro: ves exactamente qué se ejecuta. Cuando el proyecto crezca, estas son las opciones más usadas:

Hora de practicar

Retos · 0/4 resueltos

Reto 1 de 4

Tu primera fila

La tabla tareas ya está creada, pero el programa cuenta 0 filas. Inserta la tarea Comprar pan (con un ?, nunca con una f-string) para que imprima 1. Es el $pdo->prepare(...)->execute([...]) de PHP.

Al pulsar Comprobar, unos tests ocultos prueban tu código en tu navegador, con Python 3.14.

Pythonmain.py · editable

Resumen

Lo que te llevas de esta lección

  1. Una carpeta por capa dentro de app/ y el arranque en app/main.py (en PHP, src/Domain, src/Infrastructure y public/index.php).
  2. sqlite3 viene con Python: sqlite3.connect("tareas.db") es tu new PDO("sqlite:tareas.db"), sin driver que instalar.
  3. Los valores van aparte, con ? y en una tupla ((titulo,)): nunca pegados con una f-string (en PHP, prepare() y execute([...])).
  4. SQLite guarda hecha como 0/1 y la fecha como texto: se traduce con bool(fila["hecha"]) (en PHP, (bool) $fila['hecha']).
  5. Migraciones numeradas con ceros, aplicadas en orden, apuntadas en una tabla y dentro de un BEGIN explícito (en PHP, Phinx o Laravel).

Para recordarlo: «Cero, Orden, Apunta»

CCeros
001_crear_tareas
OOrden
sorted(MIGRACIONES)
AApunta
INSERT INTO migraciones

Las tres reglas de una migración: nombre con Ceros delante, se aplican en Orden y cada una se Apunta para no repetirla nunca.