Archivos y excepciones en Python

Un archivo de texto conserva la información después de que un programa se detenga. Python usa un objeto de archivo, devuelto por open(), para trabajar con esa información. La apertura conecta con el archivo; una operación de lectura recupera su texto.

Elige qué leer

El modo predeterminado es "r", de lectura. Un nombre sin ruta se busca en el directorio de trabajo actual. Si no se encuentra allí, open() lanza FileNotFoundError.

with open("fruit.txt", encoding="utf-8") as f:
    text = f.read()

Supón que el archivo tiene tres líneas, «apple», «banana» y «cherry», todas con terminador de línea. text es 'apple\nbanana\ncherry\n'. La secuencia de escape \n representa un carácter de salto de línea. La última línea también puede terminar sin un salto de línea.

readline() devuelve '' al final del archivo. Una línea en blanco con terminador de línea devuelve '\n', por lo que una línea en blanco y el final del archivo son distintos.

Sigue la posición

La lectura hace avanzar la posición en el archivo. Después de que f.read() haya consumido el archivo, otra llamada devuelve ''; un bucle sobre ese mismo objeto ya no tiene nada que recorrer. Vuelve a abrir el archivo para empezar de nuevo o conserva el texto o las líneas que necesites en una variable. read() y readlines() cargan en memoria lo que queda del archivo. Recorrer directamente el archivo permite procesar un archivo grande línea a línea.

Las líneas conservan sus caracteres de salto de línea. print(line) añade su propio salto, lo que puede dejar líneas en blanco adicionales en pantalla. Usa print(line, end="") para mantener el espaciado original o elimina el terminador de línea antes de imprimir. line.rstrip("\n") elimina los saltos de línea finales; line.strip() también elimina los espacios de ambos extremos.

Convierte el texto en números

Incluso los dígitos llegan como cadenas. Este archivo contiene las puntuaciones «72», «85» y «90»:

scores = []
with open("scores.txt", encoding="utf-8") as f:
    for line in f:
        scores.append(int(line))
total = sum(scores)
print(total, round(total / len(scores), 2))

La lista es [72, 85, 90], por lo que el programa imprime 247 82.33. int() acepta espacios y saltos de línea alrededor. Una cadena vacía o una palabra como "forty" lanza ValueError.

Lee los caracteres con la codificación correcta

Una codificación relaciona los caracteres con los bytes almacenados. UTF-8 puede representar caracteres como «é» y emojis. Usa encoding="utf-8" de forma explícita para los archivos UTF-8. Python 3.15 activa el modo UTF-8 de forma predeterminada; las instalaciones anteriores pueden usar una codificación local. Una codificación incorrecta puede producir texto ilegible o UnicodeDecodeError. Indicar la codificación explícitamente no convierte en UTF-8 un archivo guardado con otra codificación.

El bloque with cierra el archivo cuando termina. Un archivo cerrado no se puede leer: otro f.read() lanza ValueError.

Un archivo abierto utiliza recursos del sistema operativo. El texto que se está escribiendo también puede esperar en una memoria intermedia antes de llegar al archivo. Cerrar libera los recursos y vuelca la salida pendiente de esa memoria. Una sentencia with organiza esa liberación en un punto claro del código.

Lee dentro y usa el resultado después

with open("notes.txt", encoding="utf-8") as f:
    text = f.read()
print(len(text))

Los dos puntos inician el bloque. La línea con sangría se ejecuta mientras f está abierto. Cuando la ejecución llega al print() sin sangría, el archivo ya se ha cerrado, pero text sigue siendo una cadena normal. El nombre f aún hace referencia al objeto de archivo; ahora f.closed es True.

El mismo patrón sirve para una lista:

with open("fruit.txt", encoding="utf-8") as f:
    lines = f.readlines()
for line in lines:
    print(line.strip().upper())

El bucle usa datos ya leídos y guardados en lines. Mover f.readlines() fuera del bloque intentaría leer un archivo cerrado y lanzaría ValueError.

Libera recursos cuando la ejecución cambia de dirección

Considera una función que devuelve la primera línea:

def first_line(path):
    with open(path, encoding="utf-8") as f:
        return f.readline().rstrip("\n")

El valor de retorno se prepara dentro del bloque. Después, Python sale del bloque y cierra el archivo antes de que el código que realizó la llamada reciba ese valor. El archivo también se cierra cuando una excepción sale del bloque. Nunca se llegaría a un f.close() manual situado después de una sentencia que falla.

Los objetos de archivo admiten este comportamiento porque son gestores de contexto: objetos que organizan la preparación y la liberación de recursos en torno a un bloque with. Puedes usar ese comportamiento sin escribir tu propio gestor de contexto.

Abre juntos un archivo de entrada y otro de salida

with open("in.txt", encoding="utf-8") as src, open("out.txt", "w", encoding="utf-8") as dst:
    for line in src:
        dst.write(line.upper())

Cada línea de entrada se convierte en mayúsculas y se escribe en la salida. Ambos archivos se cierran cuando termina el bloque. Si falla la segunda apertura, el primer archivo, ya gestionado por with, se cierra cuando Python sale de la sentencia.

Liberar recursos y recuperarse de errores cumplen funciones distintas

with no captura los errores de archivo. Si open() no encuentra notes.txt, lanza FileNotFoundError antes de ejecutar el cuerpo. Si la conversión de una línea con int() falla dentro del cuerpo, el archivo se cierra y la excepción sigue propagándose hacia fuera. Se necesita una cláusula except coincidente para recuperarse o mostrar un mensaje.

La ausencia de los dos puntos al final de la línea de with provoca SyntaxError.

La escritura empieza con una decisión sobre los datos existentes. El modo controla si Python lee, sustituye, amplía o crea un archivo. Decide antes de llamar a open(), porque la sustitución ocurre de inmediato.

Elige el modo

Abrir la única copia de datos importantes con "w" destruye su contenido anterior aunque no se ejecute después ningún write(). Usa un archivo de salida separado mientras aprendes a transformar datos. "x" es útil cuando se debe impedir la sustitución de un archivo existente.

Añadir "b", como en "rb", selecciona el modo binario para bytes sin procesar. Los modos de texto trabajan con cadenas y una codificación; los modos binarios no aceptan el argumento encoding.

Decide dónde terminan las líneas

with open("todo.txt", "w", encoding="utf-8") as f:
    f.write("buy milk\n")
    f.write("call Sam\n")

El archivo tiene las dos líneas «buy milk» y «call Sam». write() añade exactamente la cadena recibida, sin ningún separador automático. Sin los saltos de línea, el archivo contendría "buy milkcall Sam" en una sola línea.

write() devuelve el número de caracteres escritos. Por ejemplo, f.write("Ana,92\n") devuelve 7. Es un conteo de caracteres, no necesariamente el número de bytes codificados en disco. Acepta una cadena; f.write(42) lanza TypeError. Convierte primero los números, por ejemplo con f.write(f"{score}\n").

Compara las funciones de ayuda para la salida

print() puede escribir en un archivo:

with open("total.txt", "w", encoding="utf-8") as f:
    print("Total:", 247, file=f)

El texto de salida es "Total: 247\n". print() convierte sus argumentos, los separa con espacios y añade un salto de línea final de forma predeterminada.

writelines() recibe una secuencia de cadenas, pero no inserta terminadores de línea. f.writelines(["a", "b"]) escribe "ab". Para obtener un elemento por línea, incluye un salto de línea en cada cadena o une las cadenas con "\n" y añade un salto de línea final.

Conserva las ejecuciones anteriores

with open("log.txt", "a", encoding="utf-8") as f:
    f.write("Program started\n")

Si al principio no existe el archivo, dos ejecuciones producen dos líneas. Con "w", cada ejecución sustituiría la entrada anterior. El modo de adición al final no añade un salto de línea ausente: si el texto existente termina a mitad de una línea, el texto nuevo empieza inmediatamente después.

Para un informe, recorre pares como [("Ana", 92), ("Ben", 78)] y escribe f"{name}: {score}\n". El formato se aplica antes de escribir, por lo que f"{82.333:.1f}" produce el texto "82.3". Después, al terminar el bloque, with cierra la salida y vuelca el texto pendiente de la memoria intermedia.

Muchas tareas con archivos consisten en un bucle con una decisión dentro. Lee una línea, elimina los espacios que sobren, decide si interesa y actualiza un resultado. Mantener estos pasos separados facilita comprobar un programa.

Procesa un registro de actividad

Supón que server.log contiene estos registros, con una línea en blanco antes del último:

2026-03-01 08:14 INFO Server started
2026-03-01 08:20 ERROR Disk almost full
2026-03-01 09:02 INFO User login: maya
2026-03-01 09:15 WARNING Slow response
2026-03-01 10:40 ERROR Database timeout

2026-03-01 11:05 INFO Backup finished

Cada registro no vacío tiene una fecha, una hora, un nivel y un mensaje. Divide solo tres veces para mantener unido el mensaje:

errors = 0
with open("server.log", encoding="utf-8") as f:
    for line in f:
        line = line.strip()
        if not line:
            continue
        parts = line.split(maxsplit=3)
        if parts[2] == "ERROR":
            errors += 1
            print(parts[3])
print(errors, "errors")

Para el segundo registro, parts[2] es "ERROR" y parts[3] es "Disk almost full". Se imprime ese mensaje y el contador sube a 1. El error posterior lo sube a 2. El programa imprime ambos mensajes y después «2 errors».

Busca en la parte adecuada

Buscar en cualquier posición también encontraría «INFO No ERRORS today». Comprobar el campo de nivel responde con más precisión a la pregunta sobre el registro de actividad.

Después de strip(), una línea en blanco es ""; dividirla da []. Acceder a parts[2] lanzaría entonces IndexError. continue salta esa línea antes de cualquier acceso por índice. Un registro no vacío pero incompleto también necesita una comprobación de longitud cuando puedan aparecer registros así.

Cuenta categorías o escribe un archivo filtrado

Un diccionario guarda un conteo por nivel. Para cada registro, asigna level = parts[2] y después counts[level] = counts.get(level, 0) + 1. Para el registro de actividad anterior, los conteos son {'INFO': 3, 'ERROR': 2, 'WARNING': 1}. El valor predeterminado 0 inicia una categoría la primera vez que aparece.

Para guardar los registros coincidentes, abre un destino separado en la misma sentencia with y escribe una línea cuando coincida su nivel. Conserva la line original si el espaciado importa; si escribes texto limpio, vuelve a añadir su salto de línea. Nunca abras el propio origen con "w": se vaciaría antes de empezar a leer.

Observa los caracteres invisibles

print(repr(line)) hace visibles los espacios finales y los saltos de línea, por ejemplo 'Disk full \n'. strip() elimina ambos, mientras que rstrip("\n") conserva los espacios. La lectura normal de texto convierte los terminadores de línea reconocidos de Windows, Unix y los Mac antiguos en "\n". Una última línea sin terminador sigue sin tenerlo. Un nombre de archivo recogido mediante input("File name: ").strip() permite que el mismo bucle trabaje con distintos archivos de entrada.

Una ruta describe una ubicación en un árbol de carpetas. Puede comenzar en la raíz de ese árbol o en el directorio de trabajo actual del programa. Un archivo puede existir en el equipo y aun así no encontrarse en la ubicación que solicita tu programa.

Lee una ruta desde su punto de partida

Supón que una carpeta llamada project contiene una carpeta scripts y otra data. Ejecutas python scripts/report.py mientras trabajas en project. Abrir "data/notes.txt" busca dentro de project/data, aunque el archivo de programa esté en project/scripts.

Si, en cambio, inicias el mismo archivo de programa mientras trabajas dentro de project/scripts, esa ruta relativa apunta al interior de project/scripts/data. El archivo de programa no se ha movido; ha cambiado el punto de partida.

from pathlib import Path
print(Path.cwd())

Esto imprime el directorio de trabajo actual. os.getcwd() después de import os proporciona la misma información como cadena. Los editores y las herramientas de ejecución pueden elegir un directorio de trabajo, así que compruébalo cuando la ubicación no esté clara.

Muévete por las carpetas

En una ruta relativa, . significa la carpeta actual y .. su carpeta padre. Desde project/scripts, ../data/notes.txt sube a project y después baja a data. Añadir .. sin comprobar la carpeta de partida puede llevar a un programa a la ubicación equivocada.

Una ruta absoluta es útil para identificar una ubicación exacta, pero una ruta como C:/Users/Maya/Desktop/data.csv vincula el código compartido a las carpetas de una persona. Usa una ruta relativa con un punto de partida claro o construye la ruta desde la carpeta del propio archivo de programa cuando los datos deban estar allí.

Conserva intactas las barras invertidas de Windows

Windows suele mostrar barras invertidas entre carpetas. En una cadena normal de Python, una barra invertida inicia una secuencia de escape: \n se convierte en un salto de línea y \t en una tabulación. Por tanto, el literal "C:\new\table.txt" no contiene la ruta que querías.

Estas formas conservan la ruta deseada:

raw = r"C:\new\table.txt"
escaped = "C:\\new\\table.txt"
forward = "C:/new/table.txt"

Python en Windows acepta barras normales. Una cadena sin procesar impide que las barras invertidas se conviertan en secuencias de escape, pero no puede terminar en una sola barra invertida. Por ejemplo, r"C:\data\" tiene una sintaxis no válida.

Comprueba el nombre además de la carpeta

Busca diferencias de escritura y extensiones ocultas: un archivo mostrado como «notes.txt» puede llamarse realmente «notes.txt.txt». Las mayúsculas y minúsculas también importan. Linux suele distinguir Data.csv de data.csv; la configuración habitual de Windows y macOS no lo hace. Respetar las mayúsculas y minúsculas reales permite que un proyecto funcione en distintos sistemas.

El módulo estándar pathlib da a cada ruta su propio objeto. Un Path permite unir nombres de carpetas, examinar un nombre de archivo y realizar tareas habituales con archivos sin construir manualmente cadenas con separadores.

Une y examina

from pathlib import Path
p = Path("reports") / "2026" / "sales.csv"
print(p.name)
print(p.stem)
print(p.suffix)
print(p.parent)

Los tres primeros resultados son «sales.csv», «sales» y «.csv». La carpeta padre es la ruta reports/2026, que se muestra con el separador del sistema. Aquí / une partes de una ruta; no divide números. La función anterior os.path.join() también une partes de rutas representadas como cadenas.

Un Path describe una ubicación incluso antes de que exista algo en ella. p.exists() comprueba si hay algo en esa ubicación. p.is_file() y p.is_dir() distinguen un archivo de un directorio. Una comprobación de existencia no puede garantizar una apertura posterior: el archivo puede desaparecer o el acceso puede cambiar entre ambas operaciones. Maneja los errores de apertura cuando el programa necesite recuperarse.

Lee o escribe un archivo pequeño

open() acepta un Path directamente. Para un archivo pequeño, estos métodos también gestionan la apertura y el cierre:

p = Path("greeting.txt")
p.write_text("Hello\n", encoding="utf-8")
text = p.read_text(encoding="utf-8")

text pasa a ser "Hello\n". write_text() sustituye el contenido existente, igual que abrir con "w"; no sirve para añadir al final. read_text() carga el archivo completo, así que usa un bucle sobre el archivo cuando necesites procesar uno grande línea a línea.

Parte de la carpeta del archivo de programa

Un archivo de datos suministrado junto a un archivo de programa debe localizarse a partir de este, independientemente del directorio de trabajo:

base = Path(__file__).resolve().parent
scores_path = base / "data" / "scores.txt"
with open(scores_path, encoding="utf-8") as f:
    scores = f.readlines()

__file__ identifica el archivo de programa. resolve() convierte su ruta en absoluta y parent selecciona la carpeta que lo contiene. En una consola interactiva, __file__ no está definido, por lo que este patrón se usa en un archivo de programa.

Localiza archivos y prepara carpetas de salida

for p in sorted(Path("logs").glob("*.txt")):
    text = p.read_text(encoding="utf-8")
    print(p.name, len(text.splitlines()))

glob("*.txt") selecciona las rutas coincidentes en logs. iterdir() produce las entradas de la carpeta sin ese filtro de patrón. Ordenarlas hace que el orden sea predecible. splitlines() cuenta las líneas del texto sin tratar el terminador de línea final como una línea vacía adicional.

La escritura crea un archivo, pero no las carpetas padre que falten. Prepáralas primero:

folder = Path("output") / "daily"
folder.mkdir(parents=True, exist_ok=True)
(folder / "report.txt").write_text("Ready\n", encoding="utf-8")

parents=True crea las carpetas que falten por encima de daily. exist_ok=True acepta un directorio que ya exista. No convierte un archivo normal existente en una carpeta.

Un archivo CSV almacena una tabla como texto. Sus registros son filas y sus campos son los valores de las columnas. Las comas suelen separar los campos, pero los campos entrecomillados pueden contener comas e incluso saltos de línea. Usa el módulo csv para mantener unidos esos valores.

Deja que el lector gestione las comillas

name,quiz1,quiz2
Ana,8,9
Ben,7,6
"Lopez, Maria",10,8

La primera fila es una cabecera que contiene los nombres de las columnas. La última fila de datos tiene tres campos, no cuatro: la coma dentro del nombre entrecomillado pertenece al nombre. Una comilla doble dentro de un campo entrecomillado se escribe dos veces. Dividir cada línea con split(",") ignoraría esas reglas y separaría el nombre en partes.

import csv
with open("grades.csv", newline="", encoding="utf-8") as f:
    reader = csv.reader(f)
    header = next(reader)
    for row in reader:
        average = (int(row[1]) + int(row[2])) / 2
        print(row[0], average)

El lector devuelve listas de cadenas. next(reader) consume la cabecera una vez y deja que el bucle procese los datos. El programa imprime «Ana 8.5», «Ben 6.5» y «Lopez, Maria 9.0». En la primera fila de datos, convertir "8" y "9" permite obtener un total de 17; después, dividir entre 2 da 8,5.

Coordina el manejo del archivo y la lectura de la tabla

Abre los archivos CSV con newline="" para que el módulo csv gestione por sí mismo los terminadores de línea. Esto importa cuando un campo entrecomillado incluye un salto de línea. Un registro CSV puede abarcar varias líneas físicas del archivo, por lo que dividir línea a línea no sustituye a un lector CSV.

El comportamiento predeterminado del lector mantiene los valores como cadenas. Sin conversión, sumar row[1] + row[2] une "8" y "9" para formar "89". Si olvidas saltar la cabecera, se intenta convertir "quiz1" y se lanza ValueError.

Si el archivo puede estar vacío, next(reader, None) consume la cabecera si existe y devuelve None en caso contrario. Una línea CSV completamente en blanco se convierte en []. Salta esas filas con if not row: continue antes de acceder por índice. Una fila no vacía con pocos campos también necesita una comprobación de longitud; saltar solo las filas en blanco no protege row[2] frente a todos los registros incompletos.

Ajusta la lectura al formato del archivo

reader = csv.reader(f, delimiter=";", skipinitialspace=True)

Esto selecciona el punto y coma como separador y elimina los espacios inmediatamente posteriores. Elige el separador que use realmente el archivo; cambiarlo no convierte las comas decimales en puntos decimales. float("2,50") sigue lanzando ValueError.

Algunas exportaciones de hojas de cálculo empiezan con una marca de orden de bytes UTF-8. Leerlas con encoding="utf-8" puede dejar "\ufeff" al principio del primer campo y convertir la cabecera "name" en "\ufeffname". Para ese formato, encoding="utf-8-sig" elimina el marcador; también puede leer archivos UTF-8 sin él.

Un escritor CSV convierte los valores en campos correctamente separados y entrecomillados. Proporciónale filas como secuencias de valores y deja que gestione los signos de separación y las comillas. Así evitas una salida que parece correcta hasta que un nombre o mensaje contiene una coma.

Escribe una cabecera y los datos

import csv
with open("summary.csv", "w", newline="", encoding="utf-8") as f:
    writer = csv.writer(f)
    writer.writerow(["name", "average"])
    writer.writerow(["Ana", 8.5])
    writer.writerow(["Lopez, Maria", 9.0])

El archivo contiene las filas name,average, Ana,8.5 y "Lopez, Maria",9.0. El escritor convierte los números en texto. Entrecomilla el nombre que contiene una coma y duplica cualquier comilla doble dentro de un campo entrecomillado. None se convierte en un campo vacío, por lo que volver a leer el archivo no recupera None automáticamente.

writerow() recibe una fila. writerows() recibe una secuencia de filas, como [["Ana", 8.5], ["Ben", 6.5]]. En cambio, pasar "Ana" directamente a writerow() le proporciona tres caracteres y produce A,n,a. Usa ["Ana"] para una fila de un campo.

Deja que CSV controle los terminadores de línea

Usa newline="" al abrir la salida. El escritor predeterminado termina los registros con "\r\n". Permitir además la conversión de saltos de línea del modo texto puede añadir un retorno de carro adicional en Windows y producir líneas en blanco no deseadas en algunos lectores. El argumento newline evita esa segunda capa de conversión.

Transforma un archivo en otro

with open("grades.csv", newline="", encoding="utf-8") as src, open("summary.csv", "w", newline="", encoding="utf-8") as dst:
    reader = csv.reader(src)
    writer = csv.writer(dst)
    next(reader)
    writer.writerow(["name", "average"])
    for row in reader:
        average = (int(row[1]) + int(row[2])) / 2
        writer.writerow([row[0], round(average, 2)])

Para las filas de calificaciones «Ana,8,9», «Ben,7,6» y "Lopez, Maria",10,8, las medias respectivas son 8,5; 6,5; 9,0. El lector elimina el entrecomillado CSV del valor del campo de entrada; el escritor vuelve a añadir las comillas necesarias en la salida. round() controla el valor numérico escrito, aunque no obliga a mostrar dos cifras decimales. Usa un formato como f"{average:.2f}" cuando quieras exactamente dos cifras.

Añade al final sin repetir la cabecera

Antes de abrir un archivo para añadir contenido al final, comprueba si necesita cabecera:

from pathlib import Path
p = Path("sales.csv")
needs_header = not p.exists() or p.stat().st_size == 0
with open(p, "a", newline="", encoding="utf-8") as f:
    writer = csv.writer(f)
    if needs_header:
        writer.writerow(["item", "quantity"])
    writer.writerow(["coffee", 4])

Un archivo existente pero vacío también necesita cabecera. Escribirla en cada ejecución coloca nombres de columnas en medio de los datos. Este patrón supone que un solo programa actualiza el archivo; comprobar su existencia no lo reserva frente a cambios de otros programas.

El código basado en posiciones, como row[2], depende del orden de las columnas. Un lector basado en diccionarios permite nombrar el valor que necesitas. Un diccionario relaciona claves con valores; aquí, la cabecera proporciona las claves y cada registro de datos proporciona sus valores.

Lee los campos por su nombre

import csv
with open("inventory.csv", newline="", encoding="utf-8") as f:
    reader = csv.DictReader(f)
    rows = list(reader)

Para la cabecera product,stock,price y la fila notebook,12,2.50, el primer diccionario es {'product': 'notebook', 'stock': '12', 'price': '2.50'}. reader.fieldnames proporciona los nombres de la cabecera. Esta se consume automáticamente; llamar a next(reader) saltaría el primer registro de datos.

Usa row["stock"] para seleccionar las existencias, aunque cambie el orden de las columnas. Conviértelo con int() para comparar cantidades. Los valores siguen siendo cadenas; los nombres de las columnas no proporcionan tipos numéricos al lector.

Filtra y calcula el total

Supón que la tabla contiene 12 cuadernos a un precio de 2,50; 3 bolígrafos a 1,20; 0 grapadoras a 7,95 y 25 carpetas a 0,80.

low = [r for r in rows if int(r["stock"]) < 5]
value = sum(int(r["stock"]) * float(r["price"]) for r in rows)

low contiene las filas de los bolígrafos y las grapadoras. El valor es 53,6 u.m.: los cuadernos aportan 30, los bolígrafos 3,6, las grapadoras 0 y las carpetas 20. El filtro usa las existencias, mientras que el total usa tanto las existencias como el precio.

Distingue las claves ausentes de los valores ausentes

Los nombres de la cabecera deben coincidir exactamente. Name y name son claves distintas. Un espacio después de una coma puede pasar a formar parte de una cabecera; skipinitialspace=True elimina los espacios inmediatamente posteriores a los separadores.

Una cabecera name,quiz1,quiz2 con los datos Ben,7 produce {'name': 'Ben', 'quiz1': '7', 'quiz2': None}. La clave existe, pero falta su valor. int(None) lanza TypeError. Un campo presente pero vacío es "", y convertirlo lanza ValueError. En cambio, una clave ausente de la cabecera provoca KeyError al consultarla.

Con los datos Cara,1,2,3, los campos adicionales se agrupan como None: ['3']; los campos con nombre siguen conteniendo "Cara", "1" y "2". Comprueba la estructura de una fila cuando la exactitud de los totales dependa de todos los campos.

Escribe las columnas seleccionadas

with open("reorder.csv", "w", newline="", encoding="utf-8") as f:
    writer = csv.DictWriter(f, fieldnames=["product", "stock"])
    writer.writeheader()
    for r in low:
        writer.writerow({"product": r["product"], "stock": r["stock"]})

fieldnames establece el orden de salida, independientemente del orden del diccionario. Las claves ausentes del diccionario se convierten en campos vacíos. Las claves adicionales lanzan ValueError de forma predeterminada: pasar un diccionario de inventario que contenga price a este escritor de dos columnas falla. Construye el diccionario más pequeño como se muestra o elige extrasaction="ignore" cuando quieras descartar los campos adicionales.

Una excepción es un objeto que señala un problema durante la ejecución. Lanzarla interrumpe la ejecución normal. Si ningún manejador se ocupa de ella, Python termina el programa con una traza de la excepción, un informe de las llamadas que llevaron al error.

Empieza por abajo

def average(values):
    return sum(values) / len(values)

def report():
    scores = []
    print(average(scores))

report()

La traza termina con ZeroDivisionError: division by zero. Empieza ahí: el tipo identifica la clase de problema y el mensaje aporta detalles. La entrada inmediatamente superior apunta a la división en average(). Las entradas anteriores muestran la llamada desde report() y la llamada original a report(). La lista está vacía, por lo que su longitud es 0. La línea señalada como fallida es donde aparece el problema; la asignación anterior de la lista vacía explica cómo surgió.

Elige el tipo correspondiente

int("abc") recibe un tipo de entrada permitido, una cadena, pero no puede interpretar ese valor como un número entero. En cambio, "5" + 3 mezcla tipos incompatibles para la suma. Una cadena que contiene dígitos sigue siendo una cadena.

Las operaciones con archivos tienen tipos más específicos: FileNotFoundError para una ruta que no existe, PermissionError para un acceso denegado y FileExistsError al crear con "x" un archivo que ya existe. Abrir un directorio como un archivo normal puede lanzar IsADirectoryError. Descodificar bytes con una codificación incompatible puede lanzar UnicodeDecodeError.

Comprende el árbol genealógico

Las clases de excepción forman una jerarquía. Un manejador de una clase base puede capturar sus clases derivadas:

• OSError es la clase base de errores habituales del sistema de archivos, incluidos FileNotFoundError y PermissionError.
• LookupError es la clase base de IndexError y KeyError.
• ArithmeticError es la clase base de ZeroDivisionError.
• UnicodeDecodeError está bajo ValueError.

Estas ramas descienden de Exception, que desciende de BaseException. En cambio, KeyboardInterrupt y SystemExit descienden directamente de BaseException. Esa distinción permite que except Exception deje pasar la interrupción del usuario y la salida del programa.

Separa los problemas de sintaxis, ejecución y lógica

La ausencia de dos puntos o de un paréntesis de cierre puede impedir que Python analice un archivo de programa. El SyntaxError resultante ocurre antes de ejecutarlo, por lo que un try en ese mismo archivo no puede capturarlo. Una excepción de ejecución ocurre mientras se ejecuta código válido. Un error lógico produce una respuesta incorrecta sin lanzar necesariamente ninguna excepción, como dividir un total entre un conteo equivocado.

Una sentencia try ejecuta código que puede fallar y ofrece una ruta de recuperación a determinadas excepciones. El manejador debe corresponder al problema que el programa espera y al que sabe responder.

Sigue el flujo

while True:
    try:
        age = int(input("Age: "))
        break
    except ValueError:
        print("Please enter a whole number, like 34.")
print("Next year you will be", age + 1)

Escribir «twenty» hace que int() lance ValueError. Python omite el resto del try, incluido break, y ejecuta el manejador correspondiente. Después, el bucle vuelve a preguntar. Escribir «34» permite que el try termine mediante break, por lo que el programa sale del bucle e imprime «Next year you will be 35».

Un manejador no reanuda la ejecución en la sentencia que falló. La ejecución continúa después de la sentencia try, salvo que el propio manejador cambie ese flujo. Si ningún manejador coincide, la excepción se propaga hacia fuera.

Maneja de forma distinta los fallos distintos

try:
    result = int(a) / int(b)
except ValueError:
    print("Both values must be whole numbers.")
except ZeroDivisionError:
    print("The second value cannot be 0.")

Una conversión incorrecta y un divisor cero necesitan mensajes distintos. Si la respuesta debe ser idéntica, agrupa los tipos en una tupla: except (ValueError, ZeroDivisionError):. Los paréntesis funcionan en todas las versiones de Python 3. Python 3.14 también permite una lista sin paréntesis cuando no hay una parte as; la forma con tupla sigue siendo clara entre versiones.

Python comprueba las cláusulas de arriba abajo y ejecuta la primera coincidencia. Sitúa FileNotFoundError antes de su clase base OSError si un archivo ausente necesita una respuesta especial. Invertirlas hace que el manejador especial sea inalcanzable.

Usa el mensaje sin ocultar otros errores de programación

try:
    quantity = int(text)
except ValueError as err:
    print("Cannot read quantity:", err)

err es el objeto de excepción; imprimirlo muestra su mensaje. type(err).__name__ da el nombre de su clase. Python elimina la vinculación de err del manejador cuando este termina, así que copia su mensaje en otra variable dentro del bloque si lo necesitas después.

Mantén pequeño el try. Sitúa los cálculos posteriores fuera del manejador de conversión cuando sus fallos necesiten otro tratamiento. except Exception: puede ocultar errores de programación, como una variable no definida. Un except: sin tipo es aún más amplio: también captura KeyboardInterrupt y SystemExit.

Intenta la operación, no una imitación aproximada

Comprobar text.isdigit() no comprueba todo lo que acepta int(). "-5" y " 34" no pasan esa prueba, pero se convierten correctamente; "²" la pasa, pero no se convierte con int(). Intentar la conversión y capturar ValueError usa las reglas de la propia conversión.

Haz algo visible o deja constancia al manejar datos incorrectos. Un except ValueError: pass vacío puede dejar que el programa continúe con resultados ausentes y sin explicar qué salió mal.

Una sentencia try puede separar la operación que puede fallar, la recuperación, las tareas que se realizan si todo va bien y la liberación de recursos. Una excepción también puede salir de una función y ser manejada por el código que la llamó.

Da un bloque propio a las tareas que se realizan si todo va bien

try:
    x = 10 / int(text)
except ValueError:
    print("not a number")
except ZeroDivisionError:
    print("zero")
else:
    print("result", x)
finally:
    print("done")

Con text = "4", el programa imprime «result 2.5» y «done». Con "abc", imprime «not a number» y «done»; con "0", imprime «zero» y «done».

else se ejecuta cuando el try termina normalmente sin una excepción. No se ejecuta después de que un manejador se recupere de un error. También se omite cuando return, break o continue sale antes de tiempo del try. Los errores lanzados dentro de else no son capturados por las cláusulas except anteriores de esa sentencia, por lo que las tareas de éxito no comparten por accidente los manejadores de la operación que puede fallar.

Libera recursos en todas las rutas de salida

finally se ejecuta cuando el control sale de la sentencia: después de que todo vaya bien, tras una excepción manejada y antes de que una excepción no manejada siga propagándose. También se ejecuta antes de completar un retorno pendiente.

def label():
    try:
        return "from try"
    finally:
        print("finally ran")

value = label()
print(value)

Esto imprime «finally ran» y después «from try». El retorno esperaba mientras se liberaban los recursos. Para los archivos, with ya proporciona el cierre, por lo que normalmente elimina la necesidad de cerrarlos manualmente en finally.

No incluyas una salida como return, break o continue en finally. Salir así del bloque de liberación de recursos puede descartar una excepción pendiente o sustituir un retorno. Python 3.14 y posteriores emiten un SyntaxWarning para este patrón. Limita ese bloque a liberar recursos.

Sigue una excepción hasta el código que realizó la llamada

def read_scores(path):
    with open(path, encoding="utf-8") as f:
        return [int(line) for line in f]

try:
    scores = read_scores("scores.txt")
except FileNotFoundError:
    print("The score file is missing.")

Si la apertura falla, read_scores() no tiene manejador, por lo que FileNotFoundError se propaga hasta la llamada dentro del try externo. El código que realizó la llamada la maneja e imprime el mensaje. Si una línea no es un número entero, un ValueError sigue la misma ruta, pero el manejador de archivos ausentes no coincide con él.

Elige el nivel que pueda dar una respuesta útil

Una función de lectura puede saber cómo obtener datos, pero no si un archivo ausente debe provocar otro intento, la omisión de una tarea o una detención controlada. Dejar que la excepción llegue al código que realiza la llamada e interactúa con el usuario deja allí esa decisión. Capturarla demasiado pronto y devolver una lista vacía puede ocultar la diferencia entre un archivo vacío y una lectura fallida.

Un programa gestiona un fallo de forma controlada cuando responde a un problema de manera controlada y útil. Puede volver a preguntar, informar de una fila omitida o detenerse con un mensaje claro. Elige esa respuesta según el uso que se vaya a dar al resultado.

Vuelve a intentarlo si el archivo no existe

while True:
    name = input("File name: ").strip()
    try:
        with open(name, encoding="utf-8") as f:
            text = f.read()
    except FileNotFoundError:
        print(f"No file named '{name}'. Please try again.")
    else:
        break
print(len(text.splitlines()), "lines")

Una apertura fallida omite la asignación y llega al manejador. El bucle vuelve a preguntar. Una lectura correcta llega a else, termina el bucle y deja text disponible para el conteo final. with cierra el archivo en cualquiera de las salidas de un bloque en el que se haya entrado.

Para distintos problemas con archivos, usa FileNotFoundError, después PermissionError y luego un manejador general de OSError si otros errores del sistema de archivos necesitan respuesta. Las cláusulas específicas deben ir primero. Descodificar bytes incorrectos es otro problema; un mensaje sobre una ruta ausente no lo describiría.

Maneja cada fila de datos por separado

Para un resumen rápido de ventas, supón que las filas CSV después de la cabecera son coffee,4, tea,two, muffin,3, cookie, y juice,5.

import csv
total = 0
skipped = 0
with open("sales.csv", newline="", encoding="utf-8") as f:
    reader = csv.reader(f)
    next(reader, None)
    for row in reader:
        try:
            if len(row) != 2:
                raise ValueError("expected two fields")
            quantity = int(row[1])
        except ValueError as err:
            skipped += 1
            print(f"sales.csv, ending line {reader.line_num}: {err}")
        else:
            total += quantity
print("Total:", total, "Skipped:", skipped)

Las cantidades válidas suman 12. Se rechazan la palabra «two» y la cantidad vacía, por lo que el conteo de filas omitidas es 2. La comprobación de la fila también convierte un número inesperado de campos en un error de datos comunicado antes de acceder por índice. Situar try dentro del bucle permite procesar el siguiente registro después de que uno falle; situar el bucle dentro de un único try haría que se saliera del bucle en el primer fallo.

Indica las ubicaciones con precisión

Para los cinco registros de una sola línea, los valores incorrectos terminan en las líneas 3 y 5 del archivo. Aquí enumerate(reader, start=2) coincidiría con esos números de línea, pero un salto de línea entrecomillado hace que un registro CSV abarque más de una línea. reader.line_num indica cuántas líneas físicas ha consumido el lector. Llamarla línea final mantiene la precisión de los mensajes para registros de varias líneas.

Decide si un resultado parcial es aceptable

Un conteo exploratorio rápido puede permitir omisiones comunicadas. Un total financiero o de calificaciones puede necesitar todos los registros: detente y pide datos corregidos en lugar de presentar un total parcial como completo. Indica el archivo, la ubicación y el problema para que pueda corregirse.

Después de import sys, sys.exit("Could not open sales.csv") escribe el mensaje en la salida de errores y termina con el código de salida 1. Lanza SystemExit, que except Exception no captura. Mantén los manejadores específicos para que un error de programación ajeno no se identifique erróneamente como un problema de archivo.

Una función debe avisar cuando no pueda producir un resultado válido. raise inicia una excepción en ese punto para que la ruta no válida no continúe como si la operación hubiera tenido éxito.

Comprueba antes de calcular

def withdraw(balance, amount):
    if amount <= 0:
        raise ValueError(f"amount must be positive, got {amount}")
    if amount > balance:
        raise ValueError(f"amount {amount} is more than the balance {balance}")
    return balance - amount

withdraw(100, 30) devuelve 70. withdraw(100, 150) lanza un error sobre el saldo; withdraw(100, -5) lanza un error sobre un importe no positivo. Ninguna de las llamadas que fallan llega a la resta.

Una excepción lanzada sigue las mismas reglas de manejo que un error incorporado. Si un manejador coincidente dentro de la función la captura, la ejecución puede continuar allí. En caso contrario, la excepción sale de la función y llega al código que la llamó. Si no se encuentra ningún manejador, Python muestra una traza de la excepción.

Deja que el código que realiza la llamada elija la respuesta

balance = 100
amount = 150
try:
    balance = withdraw(balance, amount)
except ValueError as err:
    print(f"Cannot withdraw: {err}")

La función informa de por qué no puede retirar el importe. El código que realiza la llamada decide mostrar un mensaje. Como la llamada a la función falla antes de devolver un valor, la asignación no sustituye el saldo anterior por un resultado. Otro código que la llamara podría pedir un importe menor o cancelar una transacción sin modificar la función.

En cambio, imprimir una advertencia dentro de la función y devolver None puede permitir que el código que la llama lleve un valor no válido a un cálculo posterior. Lanzar una excepción mantiene el fallo unido a su causa y proporciona al código que realiza la llamada una ruta de error diferenciada.

Elige un tipo con sentido

Un importe numérico negativo tiene un valor no aceptable. Una lista proporcionada donde se necesita un número tiene un tipo inadecuado. El tipo de excepción forma parte del comportamiento de la función: el código que la llama lo usa para seleccionar manejadores. No elijas un tipo solo porque te resulte familiar.

Escribe un mensaje útil

Un mensaje debe indicar qué se esperaba y qué se recibió. f"age must be between 0 and 130, got {age}" orienta hacia una corrección. Un mensaje como «error» no aporta detalles útiles. Centra el mensaje en la operación fallida; el código que interactúa con el usuario puede añadir el contexto general.

raise ValueError("amount must be positive") crea una excepción con un mensaje. raise ValueError también es válido y crea una sin mensaje. Una cadena simple no es una excepción: raise "error" lanza TypeError porque los objetos lanzados deben derivar de BaseException.

A veces una función detecta un error, pero no puede terminar de manejarlo. Puede necesitar propagar el mismo error, convertirlo en otro más útil o dar a un problema concreto del programa su propio tipo de excepción.

Vuelve a lanzar el error actual

def read_text(path):
    try:
        with open(path, encoding="utf-8") as f:
            return f.read()
    except FileNotFoundError:
        print(f"Missing: {path}")
        raise

El raise sin argumentos dentro del manejador vuelve a lanzar la excepción actual. Imprimir solo un mensaje terminaría el manejador y haría que la función devolviera None; relanzarla hace visible la lectura fallida al código que realizó la llamada. Un raise sin argumentos necesita una excepción activa que volver a lanzar.

Convierte la excepción conservando la causa

def read_price(row):
    try:
        text = row["price"]
    except KeyError as err:
        raise ValueError("row has no 'price' column") from err
    return float(text)

Una clave ausente se convierte en un ValueError con un mensaje sobre la fila. from err registra el KeyError original como su causa directa. La traza muestra el error original, el vínculo entre ambos y el nuevo error. El código que realiza la llamada puede manejar el tipo resultante mientras la depuración conserva la causa de nivel inferior.

Este manejador se limita a la consulta por clave. Un valor presente como "free" falla después en float(text) con su propio ValueError; no se informa falsamente de que falta una columna.

Define un tipo distinto

class InsufficientFundsError(ValueError):
    pass

Este patrón crea una clase de excepción personalizada. Por convención, el nombre termina en Error. El nombre entre paréntesis es su clase base, por lo que esta clase es un tipo de ValueError.

def withdraw(balance, amount):
    if amount > balance:
        raise InsufficientFundsError(
            f"balance {balance}, requested {amount}"
        )
    return balance - amount

try:
    withdraw(100, 150)
except InsufficientFundsError as err:
    print("Not enough money:", err)

El programa imprime «Not enough money: balance 100, requested 150». El código que realiza la llamada puede distinguir la falta de fondos de otro valor no válido. Si apareciera un manejador de ValueError antes de este manejador específico, el de la clase base lo capturaría primero.

Elige la clase base según el manejo deseado

Derivar de ValueError permite que tanto un manejador específico como otro más amplio de errores de valor capturen el tipo personalizado. Derivar directamente de Exception crea una rama separada de errores ordinarios, por lo que except ValueError no lo capturaría. Un tipo personalizado es útil cuando el código que realiza las llamadas necesita una respuesta distinta; un tipo incorporado y un mensaje claros bastan cuando no la necesita.