CursosEmpresasBlogLiveConfPrecios

Persistencia de datos con CSV en Python

Clase 32 de 49 • Curso Práctico de Python: Creación de un CRUD

Resumen

Convertir una lista de clientes en memoria a un almacenamiento persistente es clave para crear herramientas útiles. Aquí se explica, paso a paso, cómo usar el módulo de csv, la función global open y los context managers de Python para leer y escribir una tabla de clientes en un archivo CSV, además de automatizar el flujo de carga y guardado.

¿Cómo persistir datos en Python con CSV y open?

La transición va de un string “didáctico” a datos tabulares en un archivo CSV. Con open(path, mode) abrimos un archivo, y con csv lo representamos como filas y columnas. Al inicio del programa se cargan los clientes desde disco y, al finalizar, se guardan de vuelta. Así, la información deja de perderse entre ejecuciones.

¿Qué es open y cómo usarlo con context managers?

  • open recibe un path y regresa un objeto archivo.
  • Es indispensable cerrarlo para que se escriba a disco y no dejar datos en memoria.
  • Con context managers usando la palabra clave with se garantiza el cierre automático al salir del bloque.

Ejemplo básico:

with open('.clients.csv', mode='r') as f:
    data = f.read()
# al salir del with, el archivo se cierra de forma segura

¿Qué modos de archivo y por qué importan?

  • Modos más comunes: 'r' (read) y 'w' (write).
  • Existen modos binarios además de lectura y escritura.
  • Se indican con el parámetro opcional mode de open.

¿Cómo leer y escribir con DictReader y DictWriter?

El módulo de csv permite dos enfoques: como listas (filas indexadas por posición) o como diccionarios mediante csv.DictReader, que usa nombres de campos. Para este caso, se define un esquema con llaves: nombre, compañía, email y posición. La tabla se guarda en un archivo llamado .clients.csv (se menciona el prefijo con punto tal como se describe). También se usa os para eliminar y renombrar archivos al guardar con seguridad usando un archivo temporal .tmp.

¿Cómo inicializar clientes desde el almacenamiento?

  • Se define la tabla y el esquema de campos.
  • Se usa csv.DictReader con fieldnames para construir diccionarios por fila.
  • Se llena la lista global de clientes al iniciar el programa.
import csv

CLIENT_TABLE = '.clients.csv'
CLIENT_SCHEMA = ['name', 'company', 'email', 'position']
clients = []

def initialize_clients_from_storage():
    with open(CLIENT_TABLE, mode='r') as f:
        reader = csv.DictReader(f, fieldnames=CLIENT_SCHEMA)
        for row in reader:
            clients.append(row)

¿Cómo guardar clientes a almacenamiento de forma segura?

  • Se escribe primero en una tabla temporal con extensión .tmp.
  • Se usa csv.DictWriter con fieldnames y writerows para volcar toda la lista de una vez.
  • Luego se elimina el archivo original y se renombra el temporal al nombre final con os.
import os
import csv

def save_clients_to_storage():
    tmp_table = f'{CLIENT_TABLE}.tmp'
    with open(tmp_table, mode='w') as f:
        writer = csv.DictWriter(f, fieldnames=CLIENT_SCHEMA)
        writer.writerows(clients)

    os.remove(CLIENT_TABLE)
    os.rename(tmp_table, CLIENT_TABLE)

Uso en el punto de entrada:

if __name__ == '__main__':
    initialize_clients_from_storage()
    # aquí van los comandos: create, list, update, delete, search
    save_clients_to_storage()

¿Cómo se valida el flujo con create, list, update, delete y search?

El ciclo práctico muestra cómo el programa ya “recuerda” la información:

  • arranca vacío, se ejecuta el comando de listado y no hay clientes.
  • se usa create para registrar a “David Aroesti” en la compañía Platzi, email “david@david.com”, posición “teacher”.
  • se vuelve a listar y el cliente aparece.
  • se prueba update con el UID 0 y se cambia el nombre a “José David Aroesti”; el resto se mantiene.
  • se ejecuta delete con el UID 0 y la lista queda vacía.
  • se agrega “Tom” (Platzi, “tom@tom.com”, “ingeniero”) y luego search confirma si “Tom” existe; buscar “James” indica que no está.

¿Qué habilidades y keywords practica este ejercicio?

  • Persistencia de datos con CSV mediante el módulo de csv.
  • Manejo de archivos con open: mode='r' y mode='w'.
  • Uso de context managers con with para cierre automático.
  • Lectura con csv.DictReader y escritura con csv.DictWriter.
  • Definición de fieldnames según un schema: name, company, email, position.
  • Flujo de inicio/fin: initialize al arrancar, save al terminar.
  • Escritura segura con archivo temporal .tmp, os.remove y os.rename.
  • Trabajo con datos tabulares: analogía con Excel, Spreadsheets, MySQL y Postgres.

¿Te funcionó con una solución distinta o con otros nombres de campos? Comparte cómo lo adaptaste y, si lo sabes, explica por qué se usa un nombre de archivo con punto inicial para enriquecer el intercambio.