Módulo 4: Archivos y rutas con la biblioteca estándar

Hasta ahora los datos de los proyectos han vivido dentro de archivos .py. Los programas reales suelen recibir y producir información fuera del código:

CSV con productos
        ↓
Lectura y conversión
        ↓
Validación y transformación
        ↓
JSON con datos aceptados
        ↓
Reporte de resultados y respaldo

Trabajar con archivos no consiste únicamente en llamar a open(). Una solución profesional debe responder:

• ¿La ruta funciona en diferentes sistemas operativos?
• ¿Qué codificación utiliza el texto?
• ¿El programa sobrescribirá un archivo existente?
• ¿Cómo se validan los tipos leídos desde CSV?
• ¿Qué ocurre si el JSON está incompleto o mal formado?
• ¿Puede verse una operación antes de copiar o mover?
• ¿Se conserva el archivo original?

En este módulo utilizarás administradores de contexto, pathlib, csv, json, las partes realmente útiles de os y operaciones básicas de shutil.

Principio del módulo: un programa que trabaja con archivos debe proteger primero los datos y realizar después la operación.

Al completar el módulo serás capaz de:

• Abrir y cerrar archivos correctamente mediante with.
• Elegir entre los modos r, w, a y x.
• Indicar codificación UTF-8 de forma explícita.
• Leer texto completo, por líneas y mediante iteración.
• Escribir texto sin producir saltos de línea inesperados.
• Construir rutas portables con pathlib.Path.
• Consultar nombres, extensiones, carpetas y metadatos.
• Crear carpetas y localizar archivos con glob() y rglob().
• Leer y escribir CSV mediante DictReader y DictWriter.
• Convertir explícitamente los tipos leídos desde CSV.
• Leer y producir JSON legible con caracteres Unicode.
• Diferenciar load(), loads(), dump() y dumps().
• Utilizar os.getenv() para configuración opcional.
• Reconocer os.path al leer código existente y preferir pathlib en código nuevo.
• Copiar y mover archivos mediante shutil con comprobaciones previas.
• Crear respaldos sin sobrescribir versiones anteriores.
• Diseñar un modo de vista previa o dry run.
• Construir un gestor local de catálogo completamente basado en la biblioteca estándar.

Necesitas poder:

• crear funciones y módulos sencillos;
• trabajar con listas y diccionarios;
• normalizar cadenas;
• utilizar comprensiones y generadores;
• aplicar Counter, defaultdict y otras herramientas anteriores;
• comprender un try/except básico.

El manejo completo de excepciones se desarrollará en el Módulo 6. Aquí utilizarás únicamente capturas específicas indispensables para leer archivos externos sin ocultar errores inesperados.

Desarrollarás un programa que procese un catálogo CSV dentro de un entorno controlado:

gestor_catalogo/
├── entrada/
│   └── catalogo.csv
├── respaldos/
│   └── catalogo_respaldo_20260802_143000.csv
└── resultados/
    ├── catalogo_limpio.json
    ├── registros_rechazados.json
    └── reporte.txt

Antes de escribir, copiar o mover, el programa mostrará una vista previa:

VISTA PREVIA
----------------------------------------------------------------------------
[CREAR CARPETA] resultados
[COPIAR] entrada/catalogo.csv → respaldos/catalogo_respaldo_...
[ESCRIBIR] resultados/catalogo_limpio.json
[ESCRIBIR] resultados/registros_rechazados.json
[ESCRIBIR] resultados/reporte.txt

No se realizó ningún cambio. Ejecuta sin --simular para continuar.

Los retos opcionales y la personalización visual del reporte requieren tiempo adicional.

Archivos de texto y administradores de contexto

Cuando abres un archivo, el sistema operativo asigna un recurso al programa. Ese recurso debe cerrarse aunque la lectura falle o el código tome otro camino.

Forma manual:

archivo = open("notas.txt", mode="r", encoding="utf-8")
contenido = archivo.read()
archivo.close()

Forma recomendada:

with open("notas.txt", mode="r", encoding="utf-8") as archivo:
    contenido = archivo.read()

Al salir del bloque with, Python cierra el archivo automáticamente.

No utilices w hasta confirmar que sobrescribir es realmente la acción deseada. Para una salida que debe ser nueva, x puede ser más seguro.

with open("reporte.txt", "r", encoding="utf-8") as archivo:
    contenido = archivo.read()

Sin encoding, Python utiliza una configuración dependiente del entorno. Un archivo con ñ, tildes o símbolos puede funcionar en un equipo y fallar en otro.

UTF-8 es una elección apropiada para los materiales del curso.

Leer todo

with open("reporte.txt", "r", encoding="utf-8") as archivo:
    contenido = archivo.read()

Es apropiado para archivos pequeños cuyo contenido completo necesitas en memoria.

Leer una línea

with open("reporte.txt", "r", encoding="utf-8") as archivo:
    primera_linea = archivo.readline()

La línea suele conservar \n al final.

Leer todas las líneas

with open("reporte.txt", "r", encoding="utf-8") as archivo:
    lineas = archivo.readlines()

Construye una lista completa.

Iterar directamente

with open("reporte.txt", "r", encoding="utf-8") as archivo:
    for numero, linea in enumerate(archivo, start=1):
        print(numero, linea.rstrip("\n"))

Esta opción procesa una línea a la vez y suele ser preferible para archivos grandes.

No utilices strip() automáticamente si los espacios exteriores forman parte del dato. En este ejemplo solo se retira el salto final con rstrip("\n").

lineas = ["Primera línea", "Segunda línea", "Tercera línea"]

with open("salida.txt", "w", encoding="utf-8") as archivo:
    for linea in lineas:
        archivo.write(f"{linea}\n")

write() no añade un salto automáticamente. print() puede escribir en un archivo:

with open("salida.txt", "w", encoding="utf-8") as archivo:
    for linea in lineas:
        print(linea, file=archivo)

with open("salida.txt", "w", encoding="utf-8") as archivo:
    archivo.writelines(["uno", "dos", "tres"])

Resultado:

unodostres

Debes incluir los saltos:

archivo.writelines(f"{linea}\n" for linea in lineas)

Después de read(), el cursor queda al final:

with open("notas.txt", "r", encoding="utf-8") as archivo:
    print(archivo.read())
    print(archivo.read())

La segunda lectura devuelve una cadena vacía. Puedes volver al inicio con archivo.seek(0), pero con frecuencia es más claro guardar el contenido o abrir nuevamente según la necesidad.

Los archivos externos pueden desaparecer entre la comprobación y la apertura. Una validación previa ayuda, pero no elimina todos los errores. Cuando debas responder de forma controlada, captura la excepción específica:

ruta = "notas.txt"

try:
    with open(ruta, "r", encoding="utf-8") as archivo:
        contenido = archivo.read()
except FileNotFoundError:
    print(f"No se encontró el archivo: {ruta}")

No utilices except: ni captures Exception solo para ocultar cualquier problema. try, except, else, finally y el diseño completo de errores se estudiarán en el Módulo 6.

Rutas modernas con pathlib

from pathlib import Path

ruta = Path("entrada") / "catalogo.csv"
print(ruta)

El operador / une partes utilizando las reglas del sistema operativo. Evita concatenar separadores manualmente:

Evita

ruta = "entrada/" + nombre_archivo

## 2.2 Rutas relativas y absolutas

ruta_relativa = Path("entrada/catalogo.csv") ruta_absoluta = ruta_relativa.resolve()

print(Path.cwd()) print(ruta_absoluta)

Una ruta relativa se interpreta desde el directorio de trabajo actual, que no siempre coincide con la carpeta del script.

Si los recursos deben localizarse junto al archivo `.py`:

CARPETA_PROYECTO = Path(__file__).resolve().parent RUTA_ENTRADA = CARPETA_PROYECTO / "entrada" / "catalogo.csv"

En un intérprete interactivo puede no existir `__file__`. Dentro de un script sí.

## 2.3 Inspeccionar una ruta

ruta = Path("entrada/catalogo.csv")

print(ruta.name) print(ruta.stem) print(ruta.suffix) print(ruta.parent)

Salida conceptual:

catalogo.csv catalogo .csv entrada

Para múltiples extensiones:

ruta = Path("respaldo.tar.gz") print(ruta.suffix) print(ruta.suffixes)

## 2.4 Comprobar el tipo de destino

if ruta.exists(): print("La ruta existe")

if ruta.is_file(): print("Es un archivo")

if ruta.is_dir(): print("Es una carpeta")

`exists()` no sustituye el manejo de errores. El estado puede cambiar antes de abrir o copiar.

## 2.5 Crear carpetas

salida = Path("resultados") salida.mkdir(parents=True, exist_ok=True)

- `parents=True` crea carpetas superiores faltantes.
- `exist_ok=True` evita un error si la carpeta ya existe.

Utiliza `exist_ok=True` solo cuando reutilizar la carpeta sea seguro. Si esperas una carpeta completamente nueva, un error puede revelar una colisión importante.

## 2.6 Buscar archivos

carpeta = Path("entrada")

for ruta_csv in carpeta.glob("*.csv"): print(ruta_csv)

`glob()` busca según el patrón en la ubicación indicada. `rglob()` incluye subcarpetas:

for ruta_json in carpeta.rglob("*.json"): print(ruta_json)

Ordena si el orden de procesamiento debe ser reproducible:

archivos = sorted(carpeta.rglob("*.json"))

## 2.7 Leer y escribir texto con `Path`

ruta = Path("reporte.txt")

contenido = ruta.read_text(encoding="utf-8") ruta.write_text("Reporte generado\n", encoding="utf-8")

Estos métodos son cómodos para archivos pequeños completos. `write_text()` sobrescribe. Para lectura por líneas, anexar o controlar opciones adicionales, utiliza `ruta.open()`:

with ruta.open("a", encoding="utf-8") as archivo: archivo.write("Nueva línea\n")

## 2.8 Metadatos básicos

informacion = ruta.stat()

print(informacion.st_size) print(informacion.st_mtime)

- `st_size` contiene el tamaño en bytes.
- `st_mtime` contiene la última modificación como marca temporal.

El tamaño en bytes no equivale necesariamente a la cantidad de caracteres.

## 2.9 Cambiar nombre sin sobrescribir silenciosamente

origen = Path("reporte_temporal.txt") destino = Path("reporte_final.txt")

if destino.exists(): print(f"No se renombró: el destino ya existe: {destino}") else: origen.rename(destino)

`replace()` puede sobrescribir según el sistema y la situación. No lo utilices si la política exige conservar cualquier archivo existente.

## 2.10 Verificar que una ruta permanezca en el entorno permitido

Si una ruta proviene del usuario y realizarás una operación importante, resuélvela y comprueba su relación con la carpeta esperada:

base = Path("gestor_catalogo").resolve() destino = (base / "resultados" / "reporte.txt").resolve()

if not destino.is_relative_to(base): print("La ruta de destino sale del entorno permitido")

`Path.is_relative_to()` comprueba la relación estructural. Comparar cadenas con `startswith()` no es una validación de rutas confiable.

---

Datos tabulares con CSV

Ejemplo:

codigo,nombre,precio,existencia
PRD-001,Teclado mecánico,32000,8
PRD-002,Ratón inalámbrico,14500,3

CSV no define tipos de Python. Los números se leen como cadenas y deben convertirse después de validar.

import csv
from pathlib import Path

ruta = Path("entrada/catalogo.csv")

with ruta.open("r", encoding="utf-8", newline="") as archivo:
    lector = csv.reader(archivo)

    for fila in lector:
        print(fila)

newline="" permite que el módulo csv gestione correctamente los saltos de línea, especialmente entre sistemas operativos.

with ruta.open("r", encoding="utf-8", newline="") as archivo:
    lector = csv.DictReader(archivo)

    for fila in lector:
        print(fila["codigo"], fila["nombre"])

La primera fila se utiliza como encabezado. Cada fila es un diccionario cuyas claves proceden de ese encabezado.

Comprueba los encabezados requeridos:

CAMPOS_REQUERIDOS = {
    "codigo",
    "nombre",
    "categoria",
    "precio",
    "existencia",
}

campos_recibidos = set(lector.fieldnames or [])
campos_faltantes = CAMPOS_REQUERIDOS - campos_recibidos

No dependas del orden si accederás por nombre.

def convertir_fila(fila):
    codigo = fila["codigo"].strip().upper()
    nombre = " ".join(fila["nombre"].split())
    precio = int(fila["precio"])
    existencia = int(fila["existencia"])

    return {
        "codigo": codigo,
        "nombre": nombre,
        "precio": precio,
        "existencia": existencia,
    }

int() puede producir ValueError. Captura esa excepción cerca de la fila que la provoca para poder reportar su número y conservar el resto:

try:
    precio = int(fila["precio"])
except ValueError:
    problemas.append("El precio debe ser un número entero")

No conviertas una cadena vacía a cero sin una regla explícita. Vacío y cero pueden significar cosas distintas.

DictReader puede colocar campos adicionales bajo la clave None. También puede asignar None a encabezados sin valor. Revisa:

if None in fila:
    problemas.append("La fila contiene columnas adicionales")

for campo in CAMPOS_REQUERIDOS:
    if fila.get(campo) is None:
        problemas.append(f"Falta el campo {campo}")

campos = ["codigo", "nombre", "precio", "existencia"]

with Path("salida.csv").open(
    "w",
    encoding="utf-8",
    newline="",
) as archivo:
    escritor = csv.DictWriter(archivo, fieldnames=campos)
    escritor.writeheader()
    escritor.writerows(productos)

DictWriter puede recibir claves adicionales. Define extrasaction="ignore" únicamente si descartarlas es una decisión consciente; de lo contrario, el error ayuda a detectar una estructura inesperada.

Evita:

archivo.write(f"{codigo},{nombre},{precio}\n")

Un nombre puede contener comas, comillas o saltos de línea. El módulo csv aplica el escapado correspondiente.

Algunos archivos utilizan punto y coma:

lector = csv.DictReader(archivo, delimiter=";")

No adivines el delimitador dentro de cada fila. Define la especificación de entrada o utiliza herramientas de detección solo después de comprender sus limitaciones.

Datos estructurados con JSON

{
  "codigo": "PRD-001",
  "nombre": "Teclado mecánico",
  "precio": 32000,
  "activo": true,
  "etiquetas": ["accesorio", "teclado"],
  "observacion": null
}

Correspondencias principales:

Las claves de los objetos JSON son cadenas.

load() lee desde un archivo abierto:

import json
from pathlib import Path

ruta = Path("configuracion.json")

with ruta.open("r", encoding="utf-8") as archivo:
    configuracion = json.load(archivo)

loads() interpreta una cadena:

texto_json = '{"simular": true, "limite": 10}'
configuracion = json.loads(texto_json)

La letra s puede recordarte string.

dump() escribe en un archivo abierto:

with Path("catalogo.json").open("w", encoding="utf-8") as archivo:
    json.dump(
        productos,
        archivo,
        ensure_ascii=False,
        indent=2,
    )

• ensure_ascii=False conserva caracteres como ñ y tildes de forma legible.
• indent=2 produce una estructura fácil de revisar.

dumps() devuelve una cadena:

texto = json.dumps(productos, ensure_ascii=False, indent=2)

Este JSON es sintácticamente correcto:

{"precio": -500, "existencia": "muchas"}

El programa aún debe validar las reglas del dominio. El módulo json comprueba la sintaxis, no que el precio sea positivo o la existencia sea entera.

try:
    with ruta.open("r", encoding="utf-8") as archivo:
        datos = json.load(archivo)
except json.JSONDecodeError as error:
    print(
        f"JSON inválido en línea {error.lineno}, "
        f"columna {error.colno}: {error.msg}"
    )

Captura FileNotFoundError por separado si también deseas informar un archivo ausente. No mezcles causas diferentes en un mensaje genérico.

Objetos como Path, datetime, Decimal y conjuntos no tienen una representación JSON automática:

datos = {"ruta": Path("catalogo.csv")}

Convierte de forma explícita según la regla:

datos = {"ruta": str(Path("catalogo.csv"))}

No utilices default=str sin analizarlo: puede ocultar conversiones importantes y producir formatos que después no podrás reconstruir de forma confiable.

Si el proceso falla durante la escritura, el archivo puede quedar incompleto. En proyectos posteriores aprenderás estrategias más completas. Para este módulo:

1. conserva la entrada;
2. evita sobrescribir una salida existente sin confirmación;
3. escribe en una carpeta de resultados;
4. valida los datos antes de abrir el destino con w;
5. crea primero el respaldo requerido.

Configuración, copias y operaciones seguras

import os
from pathlib import Path

valor = os.getenv("COA_CATALOGO_DIR")

if valor:
    carpeta_base = Path(valor)
else:
    carpeta_base = Path(__file__).resolve().parent

Una variable de entorno permite cambiar una ruta sin modificar el código. No guardes contraseñas ni datos sensibles en ejemplos, capturas o repositorios.

os.getenv() devuelve None si la variable no existe, o el valor predeterminado que indiques:

modo = os.getenv("COA_MODO", "simulacion")

print(os.name)

os.name puede ayudar en diagnósticos muy concretos, pero no debes llenar el código de decisiones por sistema si pathlib ya ofrece una operación portable.

Puedes encontrar:

ruta = os.path.join("entrada", "catalogo.csv")
nombre = os.path.basename(ruta)

Es válido, pero en código nuevo de este curso se prefiere:

ruta = Path("entrada") / "catalogo.csv"
nombre = ruta.name

No mezcles sin necesidad cadenas y objetos Path. Muchas funciones aceptan ambos, pero un estilo consistente reduce conversiones.

import shutil

origen = Path("entrada/catalogo.csv")
destino = Path("respaldos/catalogo.csv")

shutil.copy2(origen, destino)

• copy() copia contenido y permisos básicos.
• copy2() intenta conservar también metadatos.
• copytree() copia una carpeta completa.

No todos los metadatos pueden conservarse en todos los sistemas.

if destino.exists():
    print(f"No se creó el respaldo porque ya existe: {destino}")
else:
    shutil.copy2(origen, destino)

Para nombres únicos por fecha y hora:

from datetime import datetime

marca = datetime.now().strftime("%Y%m%d_%H%M%S")
destino = Path("respaldos") / f"catalogo_respaldo_{marca}.csv"

Este uso de datetime se limita a nombrar el respaldo. Las fechas, duraciones y zonas horarias se estudiarán en el Módulo 5.

Incluso con segundos puede existir una colisión si se ejecuta dos veces rápidamente. Comprueba siempre destino.exists() y crea otra versión o detén la operación.

shutil.copytree(origen_carpeta, destino_carpeta)

De forma predeterminada, falla si el destino existe. Esa protección es útil para respaldos. dirs_exist_ok=True permite combinar con una carpeta existente, pero puede reemplazar archivos; no lo utilices sin una política explícita.

shutil.move(origen, destino)

Mover cambia la ubicación del recurso y puede reemplazar un destino según la plataforma y el tipo de ruta. Antes de mover:

1. resuelve origen y destino;
2. comprueba que el origen exista;
3. comprueba que el destino no exista;
4. muestra la operación;
5. confirma que el destino permanece en el entorno permitido;
6. realiza la operación.

El proyecto principal crea copias y salidas nuevas. No necesita mover ni borrar datos.

def copiar_seguro(origen, destino, simular=True):
    print(f"[COPIAR] {origen} → {destino}")

    if simular:
        return False

    if not origen.is_file():
        print("No se copió: el origen no es un archivo")
        return False

    if destino.exists():
        print("No se copió: el destino ya existe")
        return False

    destino.parent.mkdir(parents=True, exist_ok=True)
    shutil.copy2(origen, destino)
    return True

La simulación no debe crear carpetas ni archivos. Solo debe mostrar lo que se realizaría.

Path.unlink(), Path.rmdir() y shutil.rmtree() eliminan información. No se utilizarán en los ejercicios ni en el proyecto.

Si un proyecto futuro necesita borrar:

• limita la operación a una carpeta concreta;
• resuelve la ruta absoluta;
• rechaza rutas amplias o inesperadas;
• muestra el objetivo exacto;
• utiliza confirmación explícita;
• prefiere una operación recuperable cuando exista.

Lectura de documentación y seguridad

Antes de utilizar una función de archivos, localiza en la documentación:

1. qué acepta como origen y destino;
2. si sobrescribe;
3. qué devuelve;
4. qué excepciones puede producir;
5. si su comportamiento cambia entre sistemas;
6. si conserva metadatos;
7. si opera sobre archivos, carpetas o ambos.

Para operaciones de disco, la documentación no es material opcional: forma parte de la comprobación de seguridad.

Videos recomendados

Los videos complementan la práctica; no reemplazan la documentación ni el desarrollo del proyecto.

Úsalo para reforzar la creación de objetos Path, la navegación entre carpetas y las operaciones habituales sobre rutas.

Presta especial atención a reader, DictReader, writer y a la diferencia entre el texto recibido y los tipos que necesita el programa.

Relaciona load() y dump() con archivos, y loads() y dumps() con cadenas.

Si la interfaz, la versión de Python o algún detalle menor del video difiere, conserva como referencia principal la documentación oficial enlazada a continuación.

Documentación y recursos de lectura

• 📖Entrada y salida: lectura y escritura de archivos
• 📖`pathlib`: rutas de sistemas de archivos orientadas a objetos
• 📖`csv`: lectura y escritura de archivos CSV
• 📖`json`: codificador y decodificador JSON
• 📖`os`: interfaces variadas del sistema operativo
• 📖`shutil`: operaciones de alto nivel con archivos

Si una página todavía no está traducida por completo, utiliza el selector de idioma o consulta la 📖versión en inglés de la documentación.

• 📖Python `pathlib`: rutas orientadas a objetos — Real Python
• 📖Tutorial oficial de entrada y salida

No intentes memorizar cada método. Trabaja así:

1. identifica la operación que necesitas;
2. busca el módulo correspondiente;
3. revisa la firma, los parámetros y las excepciones documentadas;
4. ejecuta el ejemplo mínimo en una carpeta de práctica;
5. adapta la solución y comprueba su efecto;
6. documenta cualquier operación que pueda reemplazar o mover información.

Material descargable

El módulo incluye un paquete de práctica con:

• catálogo principal con casos válidos, corregibles e inválidos;
• configuración JSON funcional;
• CSV con encabezados faltantes;
• JSON deliberadamente inválido;
• texto UTF-8 para comprobar caracteres;
• plantilla organizada del proyecto;
• guía de operaciones seguras;
• lista de comprobación para la entrega;
• carpetas separadas para resultados y respaldos.

Trabaja sobre una copia del paquete si deseas repetir el proyecto desde cero.

⬇️Descargar el entorno de práctica del Módulo 4

Errores comunes y cómo corregirlos

Glosario

Archivo de texto: archivo cuyo contenido se interpreta como caracteres mediante una codificación.

Codificación: regla que relaciona caracteres con bytes. En el curso se utiliza UTF-8.

Administrador de contexto: objeto utilizado por with para adquirir y liberar un recurso correctamente.

Ruta absoluta: ruta completa desde la raíz del sistema de archivos.

Ruta relativa: ruta expresada con respecto a otra ubicación.

Ruta resuelta: representación normalizada de una ruta después de interpretar elementos como .. y, según el sistema, enlaces simbólicos.

CSV: formato tabular de texto con valores separados por un delimitador.

Encabezado: primera fila que identifica las columnas de un CSV.

JSON: formato textual para representar objetos, colecciones y valores simples de manera interoperable.

Serializar: convertir un objeto a una representación que pueda almacenarse o transmitirse.

Deserializar: reconstruir datos a partir de su representación almacenada.

Metadatos: información asociada a un archivo, como ciertas fechas y permisos.

Respaldo: copia destinada a preservar el estado original de un archivo.

Sobrescritura: reemplazo del contenido de un archivo existente.

Modo de simulación: ejecución que muestra el plan sin aplicar cambios.

Variable de entorno: valor configurado fuera del programa y disponible para el proceso mediante el sistema operativo.

Resumen final

En este módulo aprendiste que trabajar con archivos no consiste únicamente en abrirlos. Un programa profesional debe conocer su ubicación, validar su formato, convertir los datos, preservar los originales y comunicar con claridad qué cambios realizará.

Ahora puedes:

• gestionar archivos con administradores de contexto;
• construir rutas portables mediante pathlib;
• leer y escribir texto con una codificación explícita;
• procesar CSV con encabezados y conversiones controladas;
• serializar y reconstruir datos mediante JSON;
• utilizar configuración externa con JSON y os.getenv();
• copiar archivos con shutil.copy2();
• impedir rutas fuera del entorno autorizado;
• evitar sobrescrituras accidentales;
• diseñar un modo de simulación auténtico;
• producir resultados y reportes útiles sin modificar la fuente.

• Completé las cinco prácticas guiadas.
• Entregué las tres actividades obligatorias.
• Puedo explicar read(), readlines() e iteración directa.
• Construyo rutas con Path sin separadores manuales.
• Recuerdo que un CSV entrega texto hasta que convierto sus valores.
• Puedo distinguir load, loads, dump y dumps.
• Probé el proyecto primero en modo de simulación.
• Confirmé que la simulación no genera cambios.
• Confirmé que el CSV original permanece intacto.
• Obtuve 6 registros aceptados y 6 rechazados con el archivo principal.
• Generé los tres resultados y el respaldo.
• Documenté las diez pruebas obligatorias.
• Obtuve al menos 8 de 10 en la evaluación.
• El proyecto fue aprobado.

Cuando todos los puntos estén completos, estarás preparado para continuar con el siguiente módulo de Python Práctico.