27. Leer y escribir en archivos

Hasta ahora, todos los datos en nuestros programas han sido temporales: almacenados en variables que desaparecen cuando el programa termina. Para crear programas que recuerden información entre ejecuciones, necesitamos trabajar con archivos. Los archivos nos permiten guardar datos en el disco y leerlos de nuevo más tarde, habilitando desde ajustes de configuración hasta el almacenamiento de datos de usuarios.

En este capítulo, aprenderás cómo leer y escribir archivos de texto en Python. Empezaremos por entender las rutas de archivo y cómo Python localiza archivos, luego avanzaremos por abrir, leer, escribir y cerrar archivos correctamente. Aprenderás sobre diferentes modos de archivo, la codificación de texto y cómo manejar errores comunes que ocurren durante las operaciones con archivos.

27.1) Rutas de archivo y el directorio de trabajo actual

Antes de poder trabajar con archivos, necesitamos entender cómo Python los localiza en el sistema de archivos de tu computadora.

27.1.1) Comprender las rutas de archivo

Una ruta de archivo es la dirección de un archivo en tu computadora. Le dice a Python exactamente dónde encontrar un archivo. Hay dos tipos de rutas:

Las rutas absolutas especifican la ubicación completa desde la raíz del sistema de archivos:

• Windows: C:\Users\Alice\Documents\data.txt
• macOS/Linux: /home/alice/documents/data.txt

Las rutas relativas especifican una ubicación relativa al directorio de trabajo actual:

• data.txt (archivo en el directorio actual)
• reports/sales.txt (archivo en un subdirectorio)
• ../config.txt (archivo en el directorio padre)

El directorio de trabajo actual (CWD) es la carpeta donde Python busca archivos cuando usas rutas relativas. Cuando ejecutas un script de Python, el CWD es el directorio desde el cual ejecutaste el comando, no necesariamente donde se encuentra el archivo del script.

Por ejemplo:

# Directory structure:
/home/alice/
  └── projects/
      └── script.py
 
# Running from the projects folder:
$ cd /home/alice/projects
$ python script.py
# CWD is /home/alice/projects
 
# Running from the parent folder:
$ cd /home/alice
$ python projects/script.py
# CWD is /home/alice (not where script.py is!)

Puedes comprobar el directorio de trabajo actual con:

import os
 
# Obtener el directorio de trabajo actual
current_dir = os.getcwd()
print(f"Current directory: {current_dir}")

Output:

Current directory: /home/alice/projects/file_demo

La función os.getcwd() devuelve la ruta absoluta del directorio de trabajo actual. Esto es útil para entender dónde buscará Python los archivos cuando uses rutas relativas.

Comprender el directorio de trabajo actual es importante porque determina dónde buscará Python cuando uses una ruta relativa como "data.txt". Si ejecutas tu script desde /home/alice/projects/ y abres "data.txt", Python busca /home/alice/projects/data.txt.

27.1.2) Usar rutas relativas de forma eficaz

Al trabajar con archivos, las rutas relativas suelen ser más convenientes que las rutas absolutas porque hacen que tu código sea portable: funciona independientemente de dónde esté ubicada la carpeta del proyecto en distintas computadoras.

Aquí tienes patrones comunes de rutas relativas:

# Archivo en el directorio de trabajo actual
filename = "student_grades.txt"
 
# Archivo en un subdirectorio (carpeta data dentro del directorio actual)
filename = "data/student_grades.txt"
 
# Archivo en el directorio padre
filename = "../shared_data.txt"

Para los ejemplos de este capítulo, usaremos principalmente nombres de archivo simples como "data.txt". Esto significa:

• Los archivos de datos deberían estar en el mismo directorio donde ejecutas el comando de Python
• Si tu script está en /home/alice/projects/ y ejecutas python script.py desde ese directorio, Python buscará data.txt en /home/alice/projects/

Este enfoque mantiene los ejemplos claros y centrados en las operaciones con archivos en lugar de la navegación por rutas. Si obtienes un FileNotFoundError, usa os.getcwd() para comprobar dónde está buscando Python los archivos.

27.1.3) Separadores de ruta entre sistemas operativos

Los distintos sistemas operativos usan distintos caracteres para separar directorios en las rutas:

• Windows usa barras invertidas: data\reports\sales.txt
• macOS y Linux usan barras normales: data/reports/sales.txt

Python gestiona esto automáticamente cuando usas barras normales en tu código: funcionan en todos los sistemas operativos:

# Esto funciona en Windows, macOS y Linux
filename = "data/reports/sales.txt"

Python convierte las barras normales al separador apropiado para tu sistema operativo.

27.2) Abrir y cerrar archivos

Para trabajar con un archivo, primero debemos abrirlo, lo que crea una conexión entre nuestro programa y el archivo en el disco. Cuando terminamos, debemos cerrarlo para liberar recursos del sistema y asegurarnos de que todos los datos se guarden correctamente.

27.2.1) La función open()

La función open() crea un objeto de archivo que representa la conexión a un archivo. En su forma más simple, proporcionas el nombre del archivo:

# Abrir un archivo para lectura (el modo predeterminado)
file = open("message.txt")

Esto abre el archivo message.txt en el directorio actual. La función open() devuelve un objeto de archivo, que almacenamos en la variable file. Este objeto proporciona métodos para leer del archivo o escribir en él.

Sin embargo, este enfoque básico tiene un problema crítico: si ocurre un error después de abrir el archivo, es posible que el archivo nunca se cierre. Veamos por qué es importante cerrar los archivos.

27.2.2) Por qué es importante cerrar los archivos

Cuando abres un archivo, el sistema operativo asigna recursos para mantener esa conexión. Si no cierras el archivo:

• Es posible que los datos no se guarden: al escribir en archivos, los datos a menudo se almacenan en búfer en memoria y solo se escriben en el disco cuando se cierra el archivo
• Se desperdician recursos del sistema: cada archivo abierto consume memoria y descriptores (file handles)
• Otros programas podrían quedar bloqueados: algunos sistemas impiden que otros programas accedan a un archivo que ya está abierto

Para cerrar un archivo, llama a su método close():

file = open("message.txt")
# ... trabajar con el archivo ...
file.close()  # Liberar recursos y asegurar que los datos se guarden

27.2.3) El problema de cerrar manualmente

Cerrar archivos manualmente es propenso a errores. Si ocurre una excepción entre abrir y cerrar, es posible que la llamada a close() nunca se ejecute:

file = open("data.txt")
result = process_data(file)  # Si esto lanza una excepción...
file.close()  # ...¡esto nunca se ejecuta!

Este es un problema tan común que Python ofrece una solución mejor: la sentencia with, que aprenderemos en la Sección 27.4. Por ahora, entiende que abrir y cerrar archivos manualmente requiere atención cuidadosa para asegurar que siempre se llame a close().

27.2.4) Comprobar si un archivo está abierto

Un objeto de archivo tiene un atributo closed que te dice si el archivo está cerrado:

file = open("data.txt")
print(file.closed)  # Output: False
 
file.close()
print(file.closed)  # Output: True

Una vez que un archivo está cerrado, intentar leer de él o escribir en él generará un error:

file = open("data.txt")
file.close()
 
# Esto lanza ValueError: I/O operation on closed file
content = file.read()

El mensaje de error indica claramente el problema: estás intentando realizar una operación de E/S (entrada/salida) en un archivo que ya está cerrado.

27.3) Comprender los modos de archivo (r, w, a, texto vs binario) y la codificación

Al abrir un archivo, puedes especificar un modo(mode) que determina qué operaciones están permitidas y cómo se trata el archivo. Comprender los modos es crucial para trabajar correctamente con archivos.

27.3.1) Modo de texto vs modo binario

Los archivos se pueden abrir en dos modos fundamentales:

El modo de texto (el predeterminado) trata el archivo como si contuviera texto. Python automáticamente:

• Convierte los finales de línea a \n independientemente de la plataforma
• Gestiona la codificación de texto (convirtiendo entre bytes y strings)
• Permite leer y escribir strings

El modo binario trata el archivo como bytes sin procesar. Python:

• Lee y escribe objetos bytes, no strings
• No hace conversiones ni interpretaciones
• Se usa para imágenes, audio, vídeo y otros archivos no textuales

Para este capítulo, nos centraremos en el modo de texto, que es el que usarás con más frecuencia. El modo binario se indica añadiendo 'b' a la cadena de modo (como 'rb' o 'wb'), pero no lo necesitaremos para archivos de texto.

27.3.2) Los tres modos de archivo principales

Python proporciona tres modos principales para abrir archivos de texto:

El modo lectura ('r'): abre un archivo solo para lectura:

file = open("data.txt", "r")  # o simplemente open("data.txt")

• El archivo debe existir ya, o Python lanza FileNotFoundError
• Puedes leer del archivo pero no puedes escribir en él
• Este es el modo predeterminado si no especificas uno

El modo escritura ('w'): abre un archivo para escritura:

file = open("output.txt", "w")

• Crea el archivo si no existe
• Borra todo el contenido existente si el archivo ya existe
• Puedes escribir en el archivo pero no puedes leer de él
• Úsalo cuando quieras crear un archivo nuevo o reemplazar completamente uno existente

El modo anexar ('a'): abre un archivo para añadir al final:

file = open("log.txt", "a")

• Crea el archivo si no existe
• Conserva el contenido existente y añade nuevo contenido al final
• Puedes escribir en el archivo pero no puedes leer de él
• Úsalo cuando quieras añadir a un archivo existente sin perder su contenido actual

Aquí tienes una comparación de cómo estos modos afectan a un archivo existente:

# Supón que data.txt contiene: "Hello\nWorld\n"
 
# Modo lectura - contenido sin cambios
file = open("data.txt", "r")
file.close()
# El archivo todavía contiene: "Hello\nWorld\n"
 
# Modo escritura - contenido borrado
file = open("data.txt", "w")
file.write("New content\n")
file.close()
# El archivo ahora contiene: "New content\n"
 
# Modo anexar - contenido conservado, nuevo contenido añadido
file = open("data.txt", "a")
file.write("Added line\n")
file.close()
# El archivo ahora contiene: "New content\nAdded line\n"

27.3.3) Comprender la codificación de texto

Cuando trabajas con archivos de texto, Python necesita saber cómo convertir entre los bytes almacenados en el disco y los caracteres de string en tu programa. Este proceso de conversión se llama codificación(encoding).

La codificación más común es UTF-8, que puede representar cualquier carácter de cualquier idioma. Es la codificación predeterminada en Python 3 y el estándar para archivos de texto modernos.

# Especificar explícitamente la codificación UTF-8 (aunque normalmente es la predeterminada)
file = open("data.txt", "r", encoding="utf-8")

¿Por qué importa la codificación? Considera este archivo de texto que contiene un nombre con un carácter acentuado:

# Escribir un archivo con caracteres especiales
file = open("names.txt", "w", encoding="utf-8")
file.write("José\n")
file.write("François\n")
file.write("Müller\n")
file.close()
 
# Leerlo de vuelta
file = open("names.txt", "r", encoding="utf-8")
content = file.read()
file.close()
print(content)

Output:

José
François
Müller

Si intentas abrir un archivo con la codificación incorrecta, podrías ver caracteres corruptos o recibir un error. Usa siempre UTF-8 para archivos nuevos a menos que tengas un motivo específico para usar una codificación diferente.

27.3.4) Variaciones adicionales de modo

Python proporciona caracteres de modo adicionales que pueden combinarse con los modos principales:

Los modos plus permiten tanto lectura como escritura:

• 'r+' - Lectura y escritura (el archivo debe existir)
• 'w+' - Escritura y lectura (borra el contenido existente)
• 'a+' - Anexar y lectura (conserva el contenido existente)

Para principiantes, es más claro abrir un archivo una vez para leer y por separado para escribir en lugar de usar modos plus. Nos quedaremos con los modos simples ('r', 'w', 'a') en este capítulo.

27.4) Usar with para gestionar archivos automáticamente

La sentencia with ofrece una forma más limpia y segura de trabajar con archivos. Cierra automáticamente el archivo cuando terminas, incluso si ocurre un error.

27.4.1) La sintaxis de la sentencia with

Así es como se usa with para abrir un archivo:

with open("data.txt", "r") as file:
    content = file.read()
    print(content)
# El archivo se cierra automáticamente aquí

La sintaxis tiene varias partes:

• with - Palabra clave que inicia el gestor de contexto
• open("data.txt", "r") - Abre el archivo
• as file - Crea una variable para referenciar el objeto de archivo
• : - Comienza el bloque con sangría
• Bloque con sangría - Código que trabaja con el archivo
• Después del bloque - El archivo se cierra automáticamente

El beneficio clave: Python garantiza que el archivo se cerrará cuando termine el bloque with, independientemente de cómo termine (normalmente, con un return o debido a una excepción).

27.4.2) Por qué with es mejor que cerrar manualmente

Compara estos dos enfoques:

# Cierre manual: arriesgado
file = open("data.txt", "r")
content = file.read()
result = process(content)  # Si esto lanza una excepción...
file.close()  # ...esto nunca se ejecuta
 
# Usando with: seguro
with open("data.txt", "r") as file:
    content = file.read()
    result = process(content)  # Incluso si esto lanza una excepción...
# ...el archivo igualmente se cierra automáticamente

La sentencia with usa el protocolo de gestor de contexto(context manager) de Python (que exploraremos en detalle en el Capítulo 28). Por ahora, piénsalo como una garantía: "Limpiaré este recurso cuando termines, pase lo que pase."

27.4.3) Trabajar con múltiples archivos

Puedes abrir múltiples archivos en una sola sentencia with:

with open("input.txt", "r") as infile, open("output.txt", "w") as outfile:
    content = infile.read()
    outfile.write(content.upper())
# Ambos archivos se cierran automáticamente aquí

Esto es útil cuando necesitas leer de un archivo y escribir en otro simultáneamente. Se garantiza que ambos archivos se cierren correctamente, incluso si ocurre un error.

27.4.4) El objeto de archivo solo es válido dentro del bloque with

Una vez que termina el bloque with, el archivo se cierra y ya no puedes usar el objeto de archivo:

with open("data.txt", "r") as file:
    content = file.read()
    print("Inside with block:", file.closed)  # Output: Inside with block: False
 
print("Outside with block:", file.closed)  # Output: Outside with block: True
 
# This raises ValueError: I/O operation on closed file
more_content = file.read()

Este comportamiento es intencional: evita que uses accidentalmente un archivo cerrado. Si necesitas el contenido del archivo fuera del bloque with, guárdalo en una variable (como content arriba) antes de que termine el bloque.

A partir de este punto en el capítulo, usaremos with para todas las operaciones con archivos. Es el enfoque recomendado y lo que deberías usar en tu propio código.

27.5) Leer archivos de texto

Ahora que entendemos cómo abrir archivos de forma segura con with, exploremos las diferentes maneras de leer contenido desde archivos de texto.

27.5.1) Leer el archivo completo con read()

El método read() lee todo el contenido del archivo como un único string:

with open("message.txt", "r") as file:
    content = file.read()
    print(content)

Si message.txt contiene:

Welcome to Python!
This is a text file.
It has multiple lines.

Output:

Welcome to Python!
This is a text file.
It has multiple lines.

El método read() incluye todos los caracteres de nueva línea (\n) del archivo. Cuando imprimes el string, Python muestra cada línea en una línea separada debido a estos caracteres de nueva línea.

También puedes leer un número específico de caracteres pasando un número a read():

with open("message.txt", "r") as file:
    first_ten = file.read(10)  # Leer los primeros 10 caracteres
    print(f"First 10 characters: '{first_ten}'")

Output:

First 10 characters: 'Welcome to'

Leer el archivo completo es simple y funciona bien para archivos pequeños. Sin embargo, para archivos grandes (megabytes o gigabytes), leer todo de una vez puede consumir demasiada memoria. Para esos casos, leer línea por línea es más eficiente.

27.5.2) Leer línea por línea con readline()

El método readline() lee una sola línea del archivo, incluyendo el carácter de nueva línea al final:

with open("message.txt", "r") as file:
    line1 = file.readline()
    line2 = file.readline()
    line3 = file.readline()
    print(f"Line 1: {line1}")
    print(f"Line 2: {line2}")
    print(f"Line 3: {line3}")

Output:

Line 1: Welcome to Python!
 
Line 2: This is a text file.
 
Line 3: It has multiple lines.
 

Observa las líneas en blanco adicionales en la salida. Cada línea leída del archivo termina con \n, y print() añade otra nueva línea. Para evitar esto, usa el método rstrip() para eliminar el espacio en blanco final:

with open("message.txt", "r") as file:
    line1 = file.readline().rstrip()
    line2 = file.readline().rstrip()
    print(f"Line 1: {line1}")
    print(f"Line 2: {line2}")

Output:

Line 1: Welcome to Python!
Line 2: This is a text file.

Cuando readline() llega al final del archivo, devuelve un string vacío "". Esto te permite detectar cuándo no hay más líneas que leer:

with open("message.txt", "r") as file:
    while True:
        line = file.readline()
        if line == "":  # Fin del archivo
            break
        print(line.rstrip())

Sin embargo, hay una forma más pythónica de leer archivos línea por línea.

27.5.3) Iterar sobre líneas con un bucle for

Los objetos de archivo son iterables(iterable), lo que significa que puedes iterar sobre ellos directamente con un bucle(loop) for. Esta es la manera más común y pythónica de leer un archivo línea por línea:

with open("message.txt", "r") as file:
    for line in file:
        print(line.rstrip())

Output:

Welcome to Python!
This is a text file.
It has multiple lines.

Este enfoque es:

• Más limpio: no hay necesidad de readline() ni de comprobar strings vacíos
• Más eficiente: Python lee el archivo en bloques, sin cargar todo el archivo en memoria
• Más pythónico: usa la iteración, que es un concepto central de Python

Cada iteración del bucle lee la siguiente línea del archivo. Cuando no hay más líneas, el bucle termina automáticamente.

27.5.4) Leer todas las líneas en una lista con readlines()

El método readlines() lee todas las líneas del archivo y las devuelve como una lista de strings:

with open("message.txt", "r") as file:
    lines = file.readlines()
 
print(f"Number of lines: {len(lines)}")
for i, line in enumerate(lines, start=1):
    print(f"Line {i}: {line.rstrip()}")

Output:

Number of lines: 3
Line 1: Welcome to Python!
Line 2: This is a text file.
Line 3: It has multiple lines.

Cada elemento en la lista es un string que contiene una línea del archivo, incluyendo su carácter de nueva línea. Esto es útil cuando necesitas:

• Acceder a líneas por índice: lines[0], lines[1], etc.
• Procesar líneas múltiples veces
• Conocer el número total de líneas antes de procesar

Sin embargo, al igual que read(), readlines() carga todo el archivo en memoria. Para archivos grandes, iterar con un bucle for es más eficiente en cuanto a memoria.

27.6) Escribir y anexar a archivos de texto

Escribir en archivos es tan importante como leer de ellos. Python proporciona métodos simples para crear archivos nuevos o modificar archivos existentes.

27.6.1) Escribir en un archivo con write()

Para escribir en un archivo, ábrelo en modo escritura ('w') y usa el método write():

with open("output.txt", "w") as file:
    file.write("Hello, World!\n")
    file.write("This is a new file.\n")

Después de ejecutar este código, output.txt contiene:

Hello, World!
This is a new file.

Puntos importantes sobre write():

• Escribe un string en el archivo
• No añade automáticamente caracteres de nueva línea: debes incluir \n tú mismo
• Devuelve el número de caracteres escritos (aunque normalmente lo ignoramos)
• Si el archivo ya existe, el modo escritura borra todo el contenido existente antes de escribir

Veamos qué ocurre cuando escribimos en un archivo existente:

# Primero, crea un archivo con algo de contenido
with open("demo.txt", "w") as file:
    file.write("Original content\n")
 
# Ahora ábrelo de nuevo en modo escritura
with open("demo.txt", "w") as file:
    file.write("New content\n")
 
# Lee el archivo para ver qué contiene
with open("demo.txt", "r") as file:
    print(file.read())

Output:

New content

El contenido original desapareció. El modo escritura siempre empieza con un archivo vacío, tanto si está creando un archivo nuevo como si está sobrescribiendo uno existente.

27.6.2) Escribir múltiples líneas

Puedes llamar a write() varias veces para escribir múltiples líneas:

with open("shopping_list.txt", "w") as file:
    file.write("Apples\n")
    file.write("Bananas\n")
    file.write("Oranges\n")

27.6.3) Escribir datos desde colecciones

Una tarea común es escribir datos desde listas u otras colecciones en un archivo:

students = ["Alice", "Bob", "Carol", "David"]
 
with open("students.txt", "w") as file:
    for student in students:
        file.write(student + "\n")

Esto crea students.txt que contiene:

Alice
Bob
Carol
David

27.6.4) Anexar a un archivo

Cuando quieres añadir contenido al final de un archivo existente sin borrar lo que ya hay, usa el modo anexar ('a'):

# Crear un archivo con contenido inicial
with open("log.txt", "w") as file:
    file.write("Program started\n")
 
# Más tarde, anexar más contenido
with open("log.txt", "a") as file:
    file.write("Processing data\n")
    file.write("Processing complete\n")
 
# Leer el archivo para ver todo el contenido
with open("log.txt", "r") as file:
    print(file.read())

Output:

Program started
Processing data
Processing complete

El modo anexar es perfecto para archivos de registro, donde quieres mantener un registro continuo de eventos. Cada vez que abres el archivo en modo anexar, el nuevo contenido se añade al final, conservando todo lo que ya había.

27.7) Manejar errores comunes de E/S de archivos

Las operaciones con archivos pueden fallar por muchas razones: el archivo no existe, no tienes permiso para acceder a él, el disco está lleno o el archivo ya está abierto por otro programa. Aprender a manejar estos errores de forma adecuada hace que tus programas sean más robustos y fáciles de usar.

27.7.1) FileNotFoundError: cuando un archivo no existe

El error de archivos más común ocurre cuando intentas leer un archivo que no existe:

# ADVERTENCIA: Esto lanzará FileNotFoundError si data.txt no existe
with open("data.txt", "r") as file:
    content = file.read()

Si data.txt no existe, Python lanza:

FileNotFoundError: [Errno 2] No such file or directory: 'data.txt'

Para manejar esto de forma adecuada, usa un bloque try-except (como aprendimos en el Capítulo 25):

try:
    with open("data.txt", "r") as file:
        content = file.read()
        print(content)
except FileNotFoundError:
    print("Error: The file 'data.txt' was not found.")
    print("Please check the filename and try again.")

Output (if file doesn't exist):

Error: The file 'data.txt' was not found.
Please check the filename and try again.

Este enfoque evita que tu programa se bloquee y proporciona un mensaje útil al usuario.

27.7.2) PermissionError: cuando no puedes acceder a un archivo

A veces no tienes permiso para leer o escribir un archivo:

try:
    with open("/root/protected.txt", "r") as file:
        content = file.read()
except PermissionError:
    print("Error: You don't have permission to access this file.")

Los errores de permisos pueden ocurrir cuando:

• El archivo pertenece a otro usuario
• El archivo está en un directorio del sistema protegido
• El archivo está marcado como solo lectura y estás intentando escribir en él
• En Windows, el archivo está abierto en otro programa

27.7.3) IsADirectoryError: cuando intentas abrir un directorio

Si accidentalmente intentas abrir un directorio en lugar de un archivo:

try:
    with open("my_folder", "r") as file:
        content = file.read()
except IsADirectoryError:
    print("Error: 'my_folder' is a directory, not a file.")

Esto puede ocurrir cuando tienes tanto un archivo como un directorio con nombres similares, o cuando olvidas incluir el nombre del archivo en una ruta.

27.7.4) UnicodeDecodeError: cuando la codificación no coincide

Si intentas leer un archivo con la codificación incorrecta, podrías obtener un UnicodeDecodeError:

try:
    with open("data.txt", "r", encoding="utf-8") as file:
        content = file.read()
except UnicodeDecodeError:
    print("Error: The file encoding doesn't match UTF-8.")
    print("The file might use a different encoding.")

Este error ocurre cuando el archivo contiene bytes que no son UTF-8 válido. Si te encuentras con esto, el archivo podría:

• Estar usando una codificación diferente (como Latin-1 o Windows-1252)
• Ser un archivo binario que estás intentando leer como texto
• Estar corrupto

27.7.5) Manejar múltiples tipos de error

Puedes capturar múltiples tipos de error en un único bloque try-except:

filename = input("Enter filename: ")
 
try:
    with open(filename, "r") as file:
        content = file.read()
        print(content)
except FileNotFoundError:
    print(f"Error: '{filename}' does not exist.")
except PermissionError:
    print(f"Error: You don't have permission to read '{filename}'.")
except IsADirectoryError:
    print(f"Error: '{filename}' is a directory, not a file.")
except UnicodeDecodeError:
    print(f"Error: '{filename}' contains invalid text encoding.")

Esto proporciona mensajes de error específicos y útiles para cada tipo de problema. El usuario sabe exactamente qué salió mal y puede tomar la acción apropiada.

27.7.6) Usar un manejador de excepciones general

A veces quieres capturar cualquier error inesperado relacionado con archivos más allá de los tipos específicos que hemos cubierto. Puedes usar un manejador general de Exception como un catch-all después de tus manejadores específicos:

filename = input("Enter filename: ")
 
try:
    with open(filename, "r") as file:
        content = file.read()
        print(content)
except FileNotFoundError:
    print(f"Error: '{filename}' not found.")
except PermissionError:
    print(f"Error: No permission to read '{filename}'.")
except IsADirectoryError:
    print(f"Error: '{filename}' is a directory.")
except UnicodeDecodeError:
    print(f"Error: '{filename}' has invalid encoding.")
except Exception as e:
    print(f"Unexpected error reading file: {e}")

Esto asegura que tu programa maneje incluso errores que no anticipabas. La variable e contiene el objeto de excepción, que incluye un mensaje de error descriptivo. Imprimirlo le da al usuario detalles técnicos sobre lo que salió mal.

Trabajar con archivos es una habilidad fundamental en programación. Has aprendido a:

• Comprender las rutas de archivo y el directorio de trabajo actual
• Abrir y cerrar archivos correctamente
• Usar diferentes modos de archivo para leer, escribir y anexar
• Gestionar archivos automáticamente con la sentencia with
• Leer archivos usando varios métodos (read(), readline(), iteración, readlines())
• Escribir y anexar contenido a archivos
• Manejar errores comunes de E/S de archivos de forma adecuada

Estas habilidades te permiten crear programas que persisten datos entre ejecuciones, procesan archivos de texto, generan informes y mucho más. En el próximo capítulo, exploraremos los gestores de contexto(context managers) en profundidad, comprendiendo el mecanismo que hace que la sentencia with funcione y cómo crear tus propios gestores de contexto para gestionar recursos más allá de los archivos.