Manejo de Archivos en Python

El manejo de archivos en Python es una habilidad fundamental para cualquier programador, ya que permite la lectura y escritura de datos en archivos, facilitando la persistencia de información. Este documento explora las diversas técnicas y métodos disponibles en Python para trabajar con archivos, incluyendo la apertura, lectura, escritura y cierre de archivos, así como el manejo de excepciones y la manipulación de archivos en diferentes formatos.

Abrir archivos (open())

La función open() en Python se utiliza para abrir archivos y trabajar con ellos. Esta función es fundamental para la manipulación de archivos, permitiendo tanto la lectura como la escritura de datos. A continuación, se describe en detalle cómo se utiliza open() en Python.

Sintaxis Básica Open()

                  
                    open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)

Parámetros:

file: Una cadena que representa el nombre del archivo que se desea abrir. Puede ser una ruta relativa o absoluta.
mode: Una cadena que indica el modo en que se abre el archivo. Los modos más comunes son:
- 'r': Modo lectura (por defecto). Abre el archivo para leer, y genera un error si el archivo no existe.
- 'w': Modo escritura. Abre el archivo para escribir. Si el archivo existe, su contenido será sobrescrito. Si no existe, se creará.
- 'a': Modo añadir. Abre el archivo para agregar contenido al final. Si el archivo no existe, se creará.
- 'b': Modo binario. Se debe usar junto con otros modos, como 'rb' o 'wb', para trabajar con archivos binarios.
- 'x': Modo exclusivo. Crea un nuevo archivo, pero genera un error si el archivo ya existe.
- 't': Modo texto (por defecto). Se puede usar junto con otros modos como 'rt' o 'wt'. Este es el modo predeterminado para trabajar con archivos de texto.
- 'r+': Modo lectura y escritura. Abre el archivo para leer y escribir, pero no lo crea si no existe.
- 'w+': Modo escritura y lectura. Si el archivo no existe, se creará. Si existe, se sobrescribirá.
- 'a+': Modo lectura y escritura. Permite añadir contenido al final del archivo, sin borrar lo existente.
buffering: Un entero que especifica el tamaño del búfer. Un valor de 0 indica que no se utiliza buffering, 1 indica buffering de línea, y cualquier otro valor positivo indica el tamaño del búfer en bytes.
encoding: Una cadena que especifica la codificación del archivo. Solo se utiliza en modo texto.
errors: Una cadena que especifica cómo manejar los errores de codificación. Solo se utiliza en modo texto.
newline: Una cadena que especifica cómo se manejan los caracteres de nueva línea. Solo se utiliza en modo texto.
closefd: Un booleano que indica si se debe cerrar el descriptor de archivo cuando se cierre el archivo.
opener: Un llamable que devuelve un descriptor de archivo abierto.

Ejemplos de uso de open()

Abrir un archivo para lectura ('r'):

                
                  # Abrir un archivo en modo lectura
                  archivo = open('mi_archivo.txt', 'r')
                  # Leer el contenido del archivo
                  contenido = archivo.read()
                  print(contenido)
                  # Cerrar el archivo
                  archivo.close()

Abrir un archivo para escritura ('w'):

                
                  # Abrir un archivo en modo escritura (sobrescribe si existe)
                  archivo = open('mi_archivo.txt', 'w')
                  # Escribir en el archivo
                  archivo.write('Hola, este es un nuevo contenido.')
                  # Cerrar el archivo
                  archivo.close()

Abrir un archivo para añadir contenido ('a'):

                
                  # Abrir un archivo en modo añadir (agrega al final)
                  archivo = open('mi_archivo.txt', 'a')
                  # Añadir contenido al final del archivo
                  archivo.write('\nEsta línea se agrega al final.')
                  # Cerrar el archivo
                  archivo.close()

Leer un archivo línea por línea:

                
                  # Abrir un archivo en modo añadir (agrega al final)
                  archivo = open('mi_archivo.txt', 'a')
                  # Añadir contenido al final del archivo
                  archivo.write('\nEsta línea se agrega al final.')
                  # Cerrar el archivo
                  archivo.close()

Abrir un archivo en modo binario ('rb'):

                
                  # Abrir un archivo binario en modo lectura
                  archivo = open('imagen.png', 'rb')
                  # Leer el contenido binario del archivo
                  contenido_binario = archivo.read()
                  # Cerrar el archivo
                  archivo.close()

Lectura de Archivos

Leer archivos en Python es una tarea común y se puede hacer de varias maneras dependiendo del tipo de archivo y del formato en el que esté almacenada la información. Más adelante se mostrará algunos métodos básicos para leer archivos de texto, CSV y JSON, por el momento se iniciará con archivos de texto.

Existen diferentes formas de leer los datos de un archivo:

read(): Lee todo el contenido del archivo.
readline(): Lee una línea del archivo.
readlines(): Lee todas las líneas del archivo y las devuelve como una lista.

Ejemplos:

Leer todo el archivo:

                    
                      # Leer todo el archivo
                      archivo=open("miArchivo.txt","r",encoding="utf-8")
                      contenido = archivo.read()
                      print (contenido)
                      archivo.close()

Leer una línea:

                    
                      # Leer una línea
                      archivo=open("miArchivo.txt","r")
                      linea = archivo.readline()
                      print (linea)
                      linea = archivo.readline()
                      print (linea)
                      archivo.close()

Leer todas las líneas:

                    
                      # Leer todas las líneas
                      archivo = open("miArchivo.txt", "r")
                      lineas = archivo.readlines()
                      archivo.close()

Leer línea por línea:

                    
                      # Leer línea por línea
                      archivo=open("miArchivo.txt","r")
                      for linea in archivo:
                        print (linea)
                      archivo.close()

Escritura en Archivos

Escribir en archivos en Python es una tarea común que se puede realizar utilizando diferentes modos de apertura, como el modo de escritura ('w'), el modo de anexar ('a'), , el modo de creación exclusiva ('x'), o el modo de lectura y escritura ('r+'). Para esto, se utiliza la función open() con dos parámetros principales.:

Nombre del archivo: El nombre o la ruta del archivo que se desea abrir.
Modo: Define cómo se abrirá el archivo.

Los modos comunes para escritura son:

'w': Escritura. Crea un archivo nuevo o sobrescribe el contenido existente.
'a': Escritura en modo adjunto. Agrega contenido al final del archivo sin borrar lo que ya existe.
'x': Creación exclusiva. Genera un archivo nuevo; lanza un error si ya existe.
'r+': Lectura y escritura. Abre el archivo para leer y escribir, pero no lo crea si no existe.

Sintaxis Básica:

Modo de Escritura ('w'): Este modo abre el archivo para escribir. Si el archivo no existe, se crea uno nuevo. Si el archivo ya existe, su contenido se sobrescribe.

                    
                      # Abrir el archivo en modo de escritura
                      with open('archivo.txt', 'w') as archivo:
                          archivo.write('Hola, mundo!\n')
                          archivo.write('Esta es una línea adicional.\n')

Modo de Anexar ('a'): Este modo abre el archivo para escribir. Si el archivo no existe, se crea uno nuevo. Si el archivo ya existe, el nuevo contenido se añade al final del archivo.

                    
                      # Abrir el archivo en modo de anexar
                      with open('archivo.txt', 'a') as archivo:
                          archivo.write('Esta línea se añade al final del archivo.\n')

Modo de Lectura y Escritura ('r+'): Este modo abre el archivo para leer y escribir. El puntero del archivo se coloca al principio del archivo.

                    
                      # Abrir el archivo en modo de lectura y escritura
                      with open('archivo.txt', 'r+') as archivo:
                          contenido = archivo.read()  # Leer el contenido actual
                          archivo.write('Esta línea se añade al principio del archivo.\n')  # Escribir al principio

Escritura de Múltiples Líneas: Para escribir múltiples líneas de manera eficiente:

                    
                      # Abrir el archivo en modo de escritura
                      lineas = ["Primera línea\n", "Segunda línea\n", "Tercera línea\n"]
                      with open("archivo.txt", "w") as archivo:
                          archivo.writelines(lineas)

Escribir Objetos Convertidos a Texto: Si se desea guardar datos como listas o diccionarios, estos deben convertirse en cadenas:

                    
                      datos = {"nombre": "Juan", "edad": 30}
                      with open("archivo.json", "w") as archivo:
                          archivo.write(str(datos))

Consideraciones Importantes:
- Cierre Automático: Aunque close() puede cerrar el archivo manualmente, se recomienda usar el bloque with para evitar errores:
- Codificación: Si el archivo contiene caracteres especiales, especifique la codificación:
```
                      
                        with open("archivo.txt", "w", encoding="utf-8") as archivo:
                        archivo.write("Texto con caracteres especiales: ñ, á, é.\n")
                      
                    
```
- Mover puntero: El método seek se utiliza para mover el puntero del archivo a una posición específica. archivo.seek(0) mueve el puntero al principio del archivo, y archivo.seek(0, 2) mueve el puntero al final del archivo.

Ejemplo Completo:

Aquí se tiene un ejemplo completo que muestra cómo usar estos modos:

                
                  # Escribir en el archivo (sobrescribir si existe)
                  with open('archivo.txt', 'w') as archivo:
                      archivo.write('Línea 1\n')
                      archivo.write('Línea 2\n')
                  # Anexar al archivo
                  with open('archivo.txt', 'a') as archivo:
                      archivo.write('Línea 3\n')
                  # Leer y escribir en el archivo
                  with open('archivo.txt', 'r+') as archivo:
                      contenido = archivo.read()
                      print('Contenido antes de escribir:')
                      print(contenido)
                      # Mover el puntero al principio del archivo
                      archivo.seek(0)
                      archivo.write('Nueva Línea 1\n')
                      # Mover el puntero al final del archivo
                      archivo.seek(0, 2)
                      archivo.write('Nueva Línea 2\n')

Cerrar archivos (close())

Después de haber terminado de trabajar con un archivo, es recomendable cerrarlo utilizando el método close(). Esto libera los recursos asociados al archivo, pero si se usa la sentencia with es innecesario.

                
                  file.close()

Manejo de Excepciones

El manejo de excepciones en Python es fundamental para trabajar con archivos, ya que permite gestionar errores comunes que pueden surgir, como archivos inexistentes, permisos insuficientes o problemas de lectura/escritura. A continuación, se describe cómo se implementa el manejo de excepciones en este contexto, incluyendo ejemplos prácticos.

Principales Excepciones Relacionadas con Archivos

FileNotFoundError: Ocurre cuando el archivo no existe.
PermissionError: Surge si no se tienen permisos para acceder al archivo.
IsADirectoryError: Se lanza cuando se intenta abrir un directorio como si fuera un archivo.
IOError: Generalmente ocurre con problemas generales de entrada/salida.
EOFError: Se lanza cuando se intenta leer más allá del final del archivo.

Estructura Básica con Manejo de Excepciones

El manejo de excepciones se realiza mediante bloques try, except, else, y finally:

                  
                    try:
                    # Código que puede causar una excepción
                    with open("archivo.txt", "r") as archivo:
                        contenido = archivo.read()
                        print(contenido)
                    except FileNotFoundError:
                        print("Error: El archivo no existe.")
                    except PermissionError:
                        print("Error: No tienes permisos para acceder al archivo.")
                    except Exception as e:  # Captura de cualquier otro error no especificado
                        print(f"Error inesperado: {e}")
                    else:
                        # Código que se ejecuta si no hubo excepciones
                        print("Archivo leído exitosamente.")
                    finally:
                        # Código que se ejecuta siempre, ocurra o no una excepción
                        print("Operación de archivo finalizada.")

Ejemplos Prácticos

Leer un archivo con manejo de errores:

                      
                        try:
                        with open("datos.txt", "r") as archivo:
                            for linea in archivo:
                                print(linea.strip())
                        except FileNotFoundError:
                            print("El archivo 'datos.txt' no se encuentra.")
                        except IOError:
                            print("Ocurrió un error al intentar leer el archivo.")

Escribir en un archivo con validación de permisos:

                    
                      try:
                      with open("salida.txt", "w") as archivo:
                          archivo.write("Esto es una prueba.\n")
                      except PermissionError:
                          print("No se tienen permisos para escribir en 'salida.txt'.")
                      except Exception as e:
                          print(f"Error inesperado: {e}")
                      else:
                          print("El archivo se escribió correctamente.")

Gestionar múltiples errores en lectura y escritura:

                      
                        try:
                        with open("entrada.txt", "r") as entrada, open("salida.txt", "w") as salida:
                            datos = entrada.read()
                            salida.write(datos)
                        except FileNotFoundError as e:
                            print(f"Archivo no encontrado: {e.filename}")
                        except PermissionError as e:
                            print(f"Problema de permisos: {e}")
                        except Exception as e:
                            print(f"Error inesperado: {e}")
                        finally:
                            print("Proceso completado, con o sin errores.")

Buenas Prácticas

Uso de with: Este manejador asegura que los archivos se cierren automáticamente, incluso si ocurre una excepción.
Captura específica antes de Exception: Siempre es mejor capturar excepciones específicas primero y usar Exception al final como un caso general.
Evitar manejo de excepciones genéricas si no es necesario: Esto ayuda a identificar problemas de manera más clara.

Errores Personalizados

Se pueden lanzar errores personalizados si se desea realizar validaciones adicionales:

                  
                    try:
                    archivo = "datos.txt"
                    if not archivo.endswith(".txt"):
                        raise ValueError("El archivo debe tener extensión .txt")
                    with open(archivo, "r") as f:
                        print(f.read())
                    except ValueError as e:
                        print(f"Error de validación: {e}")
                    except Exception as e:
                        print(f"Error inesperado: {e}")

Uso de la Declaración with

La declaración with en Python es una forma elegante y segura de trabajar con archivos. Se utiliza para manejar automáticamente la apertura y el cierre de un archivo, asegurando que el archivo se cierre correctamente incluso si ocurre un error durante su uso. Esto es especialmente útil para evitar fugas de recursos.

Sintaxis Básica de with

                  
                    with open('archivo.txt', 'modo') as variable:
                        # Operaciones con el archivo
                        contenido = variable.read()

Cómo funciona:

open abre el archivo en el modo especificado.
La declaración with crea un contexto donde el archivo está abierto y lo asigna a una variable.
Una vez que se completa el bloque de código indentado, el archivo se cierra automáticamente, incluso si ocurre una excepción.

Ventajas del Uso de with

El archivo se cierra automáticamente al salir del bloque with.
Hace que el código sea más legible y limpio.
Evita errores relacionados con olvidar cerrar archivos.

Ejemplos Prácticos de with

Leer un archivo:

                      
                        with open('archivo.txt', 'r') as archivo:
                            contenido = archivo.read()
                            print(contenido)
                        # El archivo se cierra automáticamente aquí

Escribir en un archivo:

                      
                        with open('archivo.txt', 'w') as archivo:
                            archivo.write('Hola, este es un archivo de prueba.')
                        # El archivo se cierra automáticamente aquí

Añadir contenido a un archivo:

                      
                        with open('archivo.txt', 'a') as archivo:
                            archivo.write('\nLínea adicional al archivo.')
                        # El archivo se cierra automáticamente aquí