Domina Archivos en Python: Lectura, Escritura y Buenas Prácticas

¡Aprende a trabajar con archivos en Python! En este tutorial completo te guiaré paso a paso para que aprendas las técnicas esenciales para leer, escribir y manipular archivos, desde operaciones básicas hasta manejo avanzado de datos persistentes.

Objetivo: Aprender a trabajar con archivos en Python, incluyendo operaciones de lectura/escritura, manejo de errores, formatos de datos y mejores prácticas.

Índice

• Paso 1: Introducción a los Archivos
• Paso 2: Operaciones Básicas de Archivos
• Paso 3: Modos de Apertura de Archivos
• Paso 4: Lectura de Archivos
• Paso 5: Escritura de Archivos
• Paso 6: Manejo de Errores en Archivos
• Paso 7: Trabajar con Diferentes Formatos
• Paso 8: Proyecto Práctico - Gestor de Contactos
• Paso 9: Próximos Pasos
• Conclusión
• 💡 Tip Importante

Paso 1: Introducción a los Archivos

En este primer paso, entenderemos qué son los archivos y por qué son fundamentales en la programación, ya que permiten almacenar datos de manera persistente entre ejecuciones de programas.

Los archivos son la forma principal de almacenar datos de manera persistente en la mayoría de las aplicaciones. Sin archivos, cada vez que cerramos un programa, perdemos toda la información.

¿Por qué son importantes los archivos?

• Persistencia de datos: Los datos sobreviven al cierre del programa
• Compartición de información: Entre diferentes programas y usuarios
• Almacenamiento eficiente: Para grandes cantidades de datos
• Backup y recuperación: Los datos se pueden recuperar después de un reinicio

Tipos de archivos comunes

• Archivos de texto: .txt, .csv, .json, .xml
• Archivos binarios: Imágenes, audio, video, ejecutables
• Archivos de configuración: .ini, .cfg, .yaml

# Tu primer programa con archivos
def crear_archivo_saludo():
    """Crea un archivo simple con un saludo"""
    with open('saludo.txt', 'w') as archivo:
        archivo.write("¡Hola, mundo!\n")
        archivo.write("Bienvenido al manejo de archivos en Python.\n")

    print("Archivo 'saludo.txt' creado exitosamente")

crear_archivo_saludo()

Paso 2: Operaciones Básicas de Archivos

En este paso, aprenderemos las operaciones fundamentales para trabajar con archivos en Python, incluyendo cómo abrirlos, cerrarlos y las mejores prácticas para evitar problemas.

La función open()

La función open() es la puerta de entrada para trabajar con archivos en Python, permitiendo especificar el archivo y el modo de apertura.

La función open() es la base del manejo de archivos en Python. Tiene dos parámetros principales:

# Sintaxis básica
archivo = open('nombre_archivo.ext', 'modo')

Cerrar archivos correctamente

Cerrar archivos correctamente es crucial para liberar recursos del sistema y evitar pérdida de datos o corrupción de archivos.

Es crucial cerrar los archivos después de usarlos para liberar recursos del sistema.

# ❌ Forma incorrecta (puede causar problemas)
archivo = open('datos.txt', 'r')
contenido = archivo.read()
# El archivo queda abierto...

# ✅ Forma correcta
archivo = open('datos.txt', 'r')
contenido = archivo.read()
archivo.close()  # Cerrar explícitamente

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

Paso 3: Modos de Apertura de Archivos

En este paso, exploraremos los diferentes modos de apertura de archivos disponibles en Python, cada uno diseñado para operaciones específicas de lectura y escritura.

Modos principales

Los modos principales determinan cómo interactuarás con el archivo: solo lectura, escritura, agregar contenido, etc.

Modos con archivos binarios

Los modos binarios son esenciales cuando trabajas con archivos que no contienen texto, como imágenes, audio o datos serializados.

# Ejemplos de diferentes modos
def demostrar_modos():
    # Modo escritura (crea o sobrescribe)
    with open('ejemplo_w.txt', 'w') as f:
        f.write("Este archivo se crea o sobrescribe\n")

    # Modo agregar (agrega al final)
    with open('ejemplo_a.txt', 'a') as f:
        f.write("Esta línea se agrega al final\n")

    # Modo exclusivo (error si existe)
    try:
        with open('ejemplo_x.txt', 'x') as f:
            f.write("Este archivo se crea solo si no existe\n")
    except FileExistsError:
        print("El archivo ya existe")

demostrar_modos()

Paso 4: Lectura de Archivos

En este paso, aprenderemos diferentes técnicas para leer contenido de archivos, desde lecturas completas hasta procesamiento línea por línea para archivos grandes.

Métodos de lectura

Python ofrece múltiples métodos para leer archivos según tus necesidades: lectura completa, línea por línea o por bloques.

def demostrar_lectura():
    # Crear archivo de ejemplo
    with open('ejemplo_lectura.txt', 'w') as f:
        f.write("Línea 1: Hola mundo\n")
        f.write("Línea 2: Python es genial\n")
        f.write("Línea 3: Manejo de archivos\n")

    # 1. Leer todo el archivo
    print("=== Leer todo el archivo ===")
    with open('ejemplo_lectura.txt', 'r') as archivo:
        contenido_completo = archivo.read()
        print(contenido_completo)

    # 2. Leer línea por línea
    print("=== Leer línea por línea ===")
    with open('ejemplo_lectura.txt', 'r') as archivo:
        for linea in archivo:
            print(f"Línea: {linea.strip()}")

    # 3. Leer todas las líneas en una lista
    print("=== Leer todas las líneas en lista ===")
    with open('ejemplo_lectura.txt', 'r') as archivo:
        lineas = archivo.readlines()
        print(f"Número de líneas: {len(lineas)}")
        for i, linea in enumerate(lineas, 1):
            print(f"{i}: {linea.strip()}")

    # 4. Leer con límite de caracteres
    print("=== Leer con límite ===")
    with open('ejemplo_lectura.txt', 'r') as archivo:
        parte = archivo.read(20)  # Leer solo 20 caracteres
        print(f"Primeros 20 caracteres: '{parte}'")

demostrar_lectura()

Lectura eficiente de archivos grandes

Para archivos grandes, es importante usar técnicas de lectura eficiente que no carguen todo el contenido en memoria simultáneamente.

def procesar_archivo_grande(nombre_archivo):
    """Procesa un archivo grande línea por línea para ahorrar memoria"""
    contador_lineas = 0
    contador_palabras = 0

    with open(nombre_archivo, 'r') as archivo:
        for linea in archivo:
            contador_lineas += 1
            contador_palabras += len(linea.split())

    print(f"Archivo procesado: {contador_lineas} líneas, {contador_palabras} palabras")
    return contador_lineas, contador_palabras

Paso 5: Escritura de Archivos

En este paso, exploraremos cómo escribir datos en archivos, incluyendo diferentes métodos y técnicas para formatear la información de manera legible.

Métodos de escritura

Python proporciona varios métodos para escribir en archivos, desde escritura simple hasta escritura de múltiples líneas.

def demostrar_escritura():
    # 1. Escribir texto simple
    with open('escritura_ejemplo.txt', 'w') as archivo:
        archivo.write("Esta es la primera línea\n")
        archivo.write("Esta es la segunda línea\n")

    # 2. Escribir múltiples líneas con writelines
    lineas = [
        "Línea 1\n",
        "Línea 2\n",
        "Línea 3\n"
    ]

    with open('escritura_multiple.txt', 'w') as archivo:
        archivo.writelines(lineas)

    # 3. Agregar contenido a un archivo existente
    with open('escritura_ejemplo.txt', 'a') as archivo:
        archivo.write("Esta línea se agrega al final\n")

    print("Archivos creados exitosamente")

demostrar_escritura()

Escritura con formato

La escritura con formato permite crear archivos legibles y bien estructurados, facilitando la interpretación posterior de los datos.

def guardar_datos_formateados():
    """Guarda datos con formato legible"""
    datos = [
        {"nombre": "Ana", "edad": 25, "ciudad": "Madrid"},
        {"nombre": "Carlos", "edad": 30, "ciudad": "Barcelona"},
        {"nombre": "María", "edad": 28, "ciudad": "Valencia"}
    ]

    with open('personas.txt', 'w') as archivo:
        archivo.write("LISTA DE PERSONAS\n")
        archivo.write("=" * 30 + "\n")

        for persona in datos:
            archivo.write(f"Nombre: {persona['nombre']}\n")
            archivo.write(f"Edad: {persona['edad']} años\n")
            archivo.write(f"Ciudad: {persona['ciudad']}\n")
            archivo.write("-" * 20 + "\n")

    print("Datos guardados en 'personas.txt'")

guardar_datos_formateados()

Paso 6: Manejo de Errores en Archivos

En este paso, aprenderemos a manejar los errores más comunes que pueden ocurrir al trabajar con archivos, implementando código robusto y seguro.

Excepciones comunes en archivos

Los archivos pueden generar varios tipos de errores que debemos manejar apropiadamente para crear aplicaciones confiables.

def manejar_errores_archivos():
    """Demuestra el manejo de errores comunes en archivos"""

    # 1. Archivo no encontrado
    try:
        with open('archivo_inexistente.txt', 'r') as archivo:
            contenido = archivo.read()
    except FileNotFoundError:
        print("❌ Error: El archivo no existe")

    # 2. Permisos insuficientes
    try:
        with open('/root/archivo_sistema.txt', 'w') as archivo:
            archivo.write("Esto fallará")
    except PermissionError:
        print("❌ Error: No tienes permisos para escribir en esta ubicación")

    # 3. Error de codificación
    try:
        with open('archivo_binario.jpg', 'r', encoding='utf-8') as archivo:
            contenido = archivo.read()
    except UnicodeDecodeError:
        print("❌ Error: El archivo no es de texto o tiene codificación diferente")

    # 4. Disco lleno
    try:
        with open('archivo_grande.txt', 'w') as archivo:
            # Intentar escribir mucho contenido
            archivo.write("x" * (1024 * 1024 * 1024))  # 1GB
    except OSError as e:
        if e.errno == 28:  # No space left on device
            print("❌ Error: No hay espacio suficiente en el disco")
        else:
            print(f"❌ Error de sistema: {e}")

manejar_errores_archivos()

Patrón robusto para manejo de archivos

Implementar un patrón consistente para el manejo de archivos ayuda a crear código más mantenible y menos propenso a errores.

def leer_archivo_seguro(nombre_archivo, modo='r', encoding='utf-8'):
    """
    Función robusta para leer archivos con manejo completo de errores
    """
    try:
        with open(nombre_archivo, modo, encoding=encoding) as archivo:
            if 'b' in modo:  # Modo binario
                return archivo.read()
            else:  # Modo texto
                return archivo.read()
    except FileNotFoundError:
        print(f"❌ Error: El archivo '{nombre_archivo}' no existe")
        return None
    except PermissionError:
        print(f"❌ Error: No tienes permisos para acceder a '{nombre_archivo}'")
        return None
    except UnicodeDecodeError:
        print(f"❌ Error: Problema de codificación en '{nombre_archivo}'")
        return None
    except Exception as e:
        print(f"❌ Error inesperado: {e}")
        return None

def escribir_archivo_seguro(nombre_archivo, contenido, modo='w', encoding='utf-8'):
    """
    Función robusta para escribir archivos con manejo completo de errores
    """
    try:
        with open(nombre_archivo, modo, encoding=encoding) as archivo:
            archivo.write(contenido)
        print(f"✅ Archivo '{nombre_archivo}' guardado exitosamente")
        return True
    except PermissionError:
        print(f"❌ Error: No tienes permisos para escribir en '{nombre_archivo}'")
        return False
    except OSError as e:
        if e.errno == 28:  # No space left on device
            print("❌ Error: No hay espacio suficiente en el disco")
        else:
            print(f"❌ Error de sistema: {e}")
        return False
    except Exception as e:
        print(f"❌ Error inesperado: {e}")
        return False

Paso 7: Trabajar con Diferentes Formatos

En este paso, aprenderemos a trabajar con formatos de archivo comunes como CSV y JSON, que son ampliamente utilizados para el intercambio de datos.

Archivos CSV (Comma-Separated Values)

Los archivos CSV son ideales para datos tabulares y son compatibles con la mayoría de las aplicaciones de hojas de cálculo.

import csv

def trabajar_con_csv():
    """Demuestra cómo trabajar con archivos CSV"""

    # Crear archivo CSV
    datos = [
        ["Nombre", "Edad", "Ciudad"],
        ["Ana", 25, "Madrid"],
        ["Carlos", 30, "Barcelona"],
        ["María", 28, "Valencia"]
    ]

    with open('personas.csv', 'w', newline='') as archivo:
        escritor = csv.writer(archivo)
        for fila in datos:
            escritor.writerow(fila)

    print("✅ Archivo CSV creado")

    # Leer archivo CSV
    print("\n=== Contenido del CSV ===")
    with open('personas.csv', 'r') as archivo:
        lector = csv.reader(archivo)
        for fila in lector:
            print(fila)

trabajar_con_csv()

Archivos JSON (JavaScript Object Notation)

JSON es un formato ligero y legible por humanos, perfecto para estructuras de datos complejas y APIs web.

import json

def trabajar_con_json():
    """Demuestra cómo trabajar con archivos JSON"""

    # Datos a guardar
    datos = {
        "usuarios": [
            {
                "id": 1,
                "nombre": "Ana García",
                "email": "[email protected]",
                "activo": True
            },
            {
                "id": 2,
                "nombre": "Carlos López",
                "email": "[email protected]",
                "activo": False
            }
        ],
        "configuracion": {
            "tema": "oscuro",
            "idioma": "es",
            "notificaciones": True
        }
    }

    # Guardar como JSON
    with open('datos.json', 'w', encoding='utf-8') as archivo:
        json.dump(datos, archivo, indent=2, ensure_ascii=False)

    print("✅ Archivo JSON creado")

    # Leer archivo JSON
    print("\n=== Contenido del JSON ===")
    with open('datos.json', 'r', encoding='utf-8') as archivo:
        datos_leidos = json.load(archivo)

    print(f"Número de usuarios: {len(datos_leidos['usuarios'])}")
    print(f"Tema configurado: {datos_leidos['configuracion']['tema']}")

    for usuario in datos_leidos['usuarios']:
        estado = "activo" if usuario['activo'] else "inactivo"
        print(f"- {usuario['nombre']} ({usuario['email']}) - {estado}")

trabajar_con_json()

Paso 8: Proyecto Práctico - Gestor de Contactos

En este paso, aplicaremos todos los conceptos aprendidos creando un sistema completo de gestión de contactos que demuestra persistencia de datos y manejo robusto de archivos.

Vamos a crear un sistema completo de gestión de contactos que integre todas las técnicas de manejo de archivos que hemos aprendido.

import json
import os
from datetime import datetime

class GestorContactos:
    """Sistema de gestión de contactos con persistencia en archivos"""

    def __init__(self, archivo_datos='contactos.json'):
        self.archivo_datos = archivo_datos
        self.contactos = self.cargar_contactos()

    def cargar_contactos(self):
        """Carga los contactos desde el archivo JSON"""
        if os.path.exists(self.archivo_datos):
            try:
                with open(self.archivo_datos, 'r', encoding='utf-8') as archivo:
                    return json.load(archivo)
            except (json.JSONDecodeError, FileNotFoundError):
                print("⚠️  Archivo de datos corrupto, iniciando con lista vacía")
                return []
        return []

    def guardar_contactos(self):
        """Guarda los contactos en el archivo JSON"""
        try:
            with open(self.archivo_datos, 'w', encoding='utf-8') as archivo:
                json.dump(self.contactos, archivo, indent=2, ensure_ascii=False)
            print("✅ Contactos guardados exitosamente")
        except Exception as e:
            print(f"❌ Error al guardar contactos: {e}")

    def agregar_contacto(self, nombre, telefono, email='', notas=''):
        """Agrega un nuevo contacto"""
        if not nombre or not telefono:
            print("❌ Error: Nombre y teléfono son obligatorios")
            return False

        # Verificar si el contacto ya existe
        for contacto in self.contactos:
            if contacto['telefono'] == telefono:
                print("❌ Error: Ya existe un contacto con este teléfono")
                return False

        nuevo_contacto = {
            'id': len(self.contactos) + 1,
            'nombre': nombre,
            'telefono': telefono,
            'email': email,
            'notas': notas,
            'fecha_creacion': datetime.now().isoformat()
        }

        self.contactos.append(nuevo_contacto)
        self.guardar_contactos()
        print(f"✅ Contacto '{nombre}' agregado exitosamente")
        return True

    def buscar_contactos(self, termino):
        """Busca contactos por nombre o teléfono"""
        resultados = []
        termino = termino.lower()

        for contacto in self.contactos:
            if (termino in contacto['nombre'].lower() or
                termino in contacto['telefono']):
                resultados.append(contacto)

        return resultados

    def eliminar_contacto(self, id_contacto):
        """Elimina un contacto por ID"""
        for i, contacto in enumerate(self.contactos):
            if contacto['id'] == id_contacto:
                contacto_eliminado = self.contactos.pop(i)
                self.guardar_contactos()
                print(f"✅ Contacto '{contacto_eliminado['nombre']}' eliminado")
                return True

        print("❌ Error: Contacto no encontrado")
        return False

    def listar_contactos(self):
        """Muestra todos los contactos"""
        if not self.contactos:
            print("📝 No hay contactos registrados")
            return

        print(f"\n📋 LISTA DE CONTACTOS ({len(self.contactos)})")
        print("=" * 50)

        for contacto in self.contactos:
            print(f"ID: {contacto['id']}")
            print(f"Nombre: {contacto['nombre']}")
            print(f"Teléfono: {contacto['telefono']}")
            if contacto['email']:
                print(f"Email: {contacto['email']}")
            if contacto['notas']:
                print(f"Notas: {contacto['notas']}")
            print("-" * 30)

    def exportar_a_txt(self, nombre_archivo='contactos.txt'):
        """Exporta los contactos a un archivo de texto"""
        try:
            with open(nombre_archivo, 'w', encoding='utf-8') as archivo:
                archivo.write("LISTA DE CONTACTOS\n")
                archivo.write("=" * 50 + "\n")
                archivo.write(f"Total de contactos: {len(self.contactos)}\n")
                archivo.write(f"Fecha de exportación: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n")
                archivo.write("=" * 50 + "\n\n")

                for contacto in self.contactos:
                    archivo.write(f"ID: {contacto['id']}\n")
                    archivo.write(f"Nombre: {contacto['nombre']}\n")
                    archivo.write(f"Teléfono: {contacto['telefono']}\n")
                    if contacto['email']:
                        archivo.write(f"Email: {contacto['email']}\n")
                    if contacto['notas']:
                        archivo.write(f"Notas: {contacto['notas']}\n")
                    archivo.write("-" * 30 + "\n")

            print(f"✅ Contactos exportados a '{nombre_archivo}'")
            return True
        except Exception as e:
            print(f"❌ Error al exportar: {e}")
            return False

def menu_principal():
    """Menú principal del gestor de contactos"""
    gestor = GestorContactos()

    while True:
        print("\n" + "="*40)
        print("📱 GESTOR DE CONTACTOS")
        print("="*40)
        print("1. Agregar contacto")
        print("2. Buscar contactos")
        print("3. Listar todos los contactos")
        print("4. Eliminar contacto")
        print("5. Exportar a archivo TXT")
        print("6. Salir")
        print("="*40)

        opcion = input("Selecciona una opción (1-6): ").strip()

        if opcion == '1':
            nombre = input("Nombre: ").strip()
            telefono = input("Teléfono: ").strip()
            email = input("Email (opcional): ").strip()
            notas = input("Notas (opcional): ").strip()

            gestor.agregar_contacto(nombre, telefono, email, notas)

        elif opcion == '2':
            termino = input("Buscar por nombre o teléfono: ").strip()
            resultados = gestor.buscar_contactos(termino)

            if resultados:
                print(f"\n🔍 Resultados de búsqueda para '{termino}':")
                for contacto in resultados:
                    print(f"- {contacto['nombre']} ({contacto['telefono']})")
            else:
                print("❌ No se encontraron contactos")

        elif opcion == '3':
            gestor.listar_contactos()

        elif opcion == '4':
            try:
                id_contacto = int(input("ID del contacto a eliminar: "))
                gestor.eliminar_contacto(id_contacto)
            except ValueError:
                print("❌ Error: ID debe ser un número")

        elif opcion == '5':
            nombre_archivo = input("Nombre del archivo (default: contactos.txt): ").strip()
            if not nombre_archivo:
                nombre_archivo = 'contactos.txt'
            gestor.exportar_a_txt(nombre_archivo)

        elif opcion == '6':
            print("¡Gracias por usar el Gestor de Contactos!")
            break

        else:
            print("❌ Opción no válida")

        input("\nPresiona Enter para continuar...")

if __name__ == "__main__":
    menu_principal()

Funcionalidades del Gestor de Contactos

1. Agregar contactos con validación de datos
2. Buscar contactos por nombre o teléfono
3. Listar todos los contactos con formato legible
4. Eliminar contactos por ID
5. Exportar a archivo TXT con formato profesional
6. Persistencia automática en archivo JSON
7. Manejo robusto de errores en todas las operaciones

Paso 9: Próximos Pasos

En este paso final, exploraremos temas avanzados en el manejo de archivos y rutas de aprendizaje para continuar desarrollando tus habilidades.

¡Felicidades! Has dominado los fundamentos del manejo de archivos en Python. Ahora puedes crear aplicaciones que persistan datos entre ejecuciones.

Temas Avanzados de Archivos

Estos temas avanzados te permitirán trabajar con archivos de manera más sofisticada y eficiente en aplicaciones del mundo real.

Manejo de Archivos Binarios

• Imágenes, audio, video
• Serialización de objetos
• Archivos comprimidos

Bases de Datos

• SQLite para aplicaciones locales
• Conexión a bases de datos remotas
• ORM (Object-Relational Mapping)

Procesamiento de Archivos Grandes

• Lectura por chunks
• Procesamiento en paralelo
• Optimización de memoria

Seguridad en Archivos

• Encriptación de datos sensibles
• Validación de integridad
• Control de acceso

Proyecto Avanzado Sugerido

Este proyecto avanzado combina múltiples conceptos de manejo de archivos con otras áreas de la programación para crear una aplicación completa.

Crea un Sistema de Notas Personal que incluya:

• Crear, editar y eliminar notas
• Categorización por etiquetas
• Búsqueda full-text
• Exportación a múltiples formatos
• Backup automático
• Interfaz web con Flask/Django

Mejores Prácticas para Producción

Aplicar estas mejores prácticas asegura que tus aplicaciones de manejo de archivos sean seguras, eficientes y mantenibles en entornos de producción.

1. Validación de entrada: Siempre valida los datos antes de procesarlos
2. Manejo de errores: Implementa try-except en todas las operaciones de archivos
3. Rutas seguras: Evita rutas relativas que puedan ser manipuladas
4. Backup: Implementa sistemas de backup automático
5. Logging: Registra todas las operaciones importantes
6. Testing: Crea tests para todas las funciones de manejo de archivos

Conclusión

¡Has aprendido a trabajar con archivos en Python! Ahora puedes crear aplicaciones que persistan datos, procesen información de archivos existentes y generen reportes útiles.

El manejo de archivos es una habilidad fundamental en el desarrollo de software. Combínalo con los conceptos que aprendiste en el tutorial anterior sobre fundamentos de programación y podrás crear aplicaciones completas y funcionales.

Para más tutoriales sobre Python y desarrollo de software, visita nuestra sección de tutoriales.

¡Sigue programando y creando aplicaciones útiles!

💡 Tip Importante

📝 Mejores Prácticas para Manejo de Archivos

• Siempre usa with: Garantiza que los archivos se cierren correctamente
• Especifica la codificación: Usa encoding='utf-8' para archivos de texto
• Valida antes de operar: Verifica que los archivos existan y tengas permisos
• Maneja errores: Usa try-except para todas las operaciones de archivos
• Nombres descriptivos: Usa extensiones apropiadas (.txt, .json, .csv)
• Rutas absolutas: Cuando sea necesario, usa rutas completas
• Backup regular: Implementa copias de seguridad para datos importantes
• Documenta tus funciones: Incluye docstrings con información sobre archivos

📚 Recursos Recomendados:

• Documentación oficial de Python - File Objects
• Real Python - Working with Files
• Automate the Boring Stuff - Files

¡El manejo de archivos es una de las habilidades más útiles que aprenderás como programador!