Leer y escribir archivos de texto
🧭 Navegación:
- Anterior: Manejo de Archivos
- Siguiente: Trabajar con CSV
Los archivos de texto son como los documentos básicos de nuestra oficina del almacén: reportes, notas, logs de actividad, instrucciones y toda la documentación que necesitamos leer y generar automáticamente.
📝 ¿Qué son los archivos de texto?
Los archivos de texto contienen información en formato legible por humanos, sin formato especial. Son como documentos escritos a máquina que pueden contener:
- Reportes de inventario con listas de productos
- Logs de actividad del sistema del almacén
- Instrucciones y manuales para empleados
- Notas y observaciones de operaciones diarias
- Configuraciones simples en formato texto
🏢 Analogía del almacén: La secretaria digital
Imagina que tienes una secretaria digital que puede:
- Leer cualquier documento escrito y entender su contenido
- Escribir reportes y documentos automáticamente
- Organizar información en archivos bien estructurados
- Procesar grandes volúmenes de documentos en segundos
🔓 Operaciones básicas con archivos
Apertura de archivos: Accediendo a los documentos
# Modos de apertura de archivos
"r" # Lectura: Leer un documento existente
"w" # Escritura: Crear nuevo documento (sobrescribe si existe)
"a" # Añadir: Agregar contenido al final del documento
"r+" # Lectura/Escritura: Leer y modificar documento existente
"x" # Creación exclusiva: Crear solo si NO existe
📄 Lectura de archivos: Consultando documentos
Método 1: Leer todo el archivo de una vez
# Leer reporte completo de inventario
with open("reporte_inventario.txt", "r", encoding="utf-8") as archivo:
contenido_completo = archivo.read()
print(contenido_completo)
# Ejemplo práctico: Analizar reporte de ventas
def analizar_reporte_ventas():
"""Lee y analiza el reporte diario de ventas"""
try:
with open("ventas_hoy.txt", "r", encoding="utf-8") as f:
reporte = f.read()
# Buscar información específica
if "Stock bajo" in reporte:
print("⚠️ Alerta: Hay productos con stock bajo")
# Contar líneas del reporte
lineas = reporte.count("\n")
print(f"El reporte tiene {lineas} líneas")
return reporte
except FileNotFoundError:
print("No se encontró el reporte de ventas de hoy")
return None
Método 2: Leer línea por línea
# Procesar un log de actividades línea por línea
def procesar_log_almacen():
"""Procesa el log de actividades del almacén"""
actividades_importantes = []
with open("log_almacen.txt", "r", encoding="utf-8") as archivo:
for numero_linea, linea in enumerate(archivo, 1):
linea = linea.strip() # Eliminar espacios al inicio/final
# Filtrar solo actividades importantes
if "ERROR" in linea or "ALERTA" in linea:
actividades_importantes.append({
"linea": numero_linea,
"contenido": linea
})
return actividades_importantes
# Ejemplo de uso
alerts = procesar_log_almacen()
for alerta in alerts:
print(f"Línea {alerta['linea']}: {alerta['contenido']}")
Método 3: Leer todas las líneas como lista
# Leer lista de productos para inventario
def cargar_lista_productos():
"""Carga la lista de productos desde archivo"""
with open("productos_almacen.txt", "r", encoding="utf-8") as archivo:
todas_las_lineas = archivo.readlines()
# Limpiar espacios en blanco de cada línea
productos = [linea.strip() for linea in todas_las_lineas if linea.strip()]
return productos
# Ejemplo de uso
productos = cargar_lista_productos()
print(f"Tenemos {len(productos)} productos en el catálogo:")
for i, producto in enumerate(productos[:5], 1): # Mostrar primeros 5
print(f"{i}. {producto}")
✍️ Escritura de archivos: Creando documentos
Crear nuevos documentos
# Generar reporte diario de inventario
def generar_reporte_inventario():
"""Genera el reporte diario de inventario"""
from datetime import datetime
fecha_hoy = datetime.now().strftime("%Y-%m-%d")
hora_actual = datetime.now().strftime("%H:%M:%S")
reporte = f"""
=== REPORTE DIARIO DE INVENTARIO ===
Fecha: {fecha_hoy}
Hora de generación: {hora_actual}
📦 RESUMEN DEL INVENTARIO:
- Total de productos: 1,250 unidades
- Valor total del inventario: $45,750.00
- Productos con stock bajo: 8 productos
📈 PRODUCTOS MÁS VENDIDOS HOY:
1. Laptop Gaming Pro - 15 unidades vendidas
2. Mouse Inalámbrico - 32 unidades vendidas
3. Teclado Mecánico RGB - 18 unidades vendidas
⚠️ ALERTAS:
- Laptop Gaming Pro: Stock bajo (5 unidades restantes)
- Auriculares Bluetooth: Stock crítico (2 unidades restantes)
📋 NOTAS:
- Pedido de reposición programado para mañana
- Revisar calidad de mouse inalámbrico (3 devoluciones)
--- Fin del reporte ---
"""
nombre_archivo = f"reporte_inventario_{fecha_hoy}.txt"
with open(nombre_archivo, "w", encoding="utf-8") as archivo:
archivo.write(reporte)
print(f"✅ Reporte generado: {nombre_archivo}")
return nombre_archivo
# Generar el reporte
archivo_creado = generar_reporte_inventario()
Añadir contenido a documentos existentes
# Sistema de log de actividades del almacén
def registrar_actividad(actividad, usuario="Sistema"):
"""Registra una actividad en el log del almacén"""
from datetime import datetime
timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
entrada_log = f"[{timestamp}] {usuario}: {actividad}\n"
# Añadir al archivo de log existente
with open("log_almacen.txt", "a", encoding="utf-8") as archivo:
archivo.write(entrada_log)
print(f"✅ Actividad registrada: {actividad}")
# Ejemplos de uso del sistema de log
registrar_actividad("Inicio de jornada laboral", "Ana García")
registrar_actividad("Recibidos 50 productos nuevos", "Carlos López")
registrar_actividad("Venta procesada: $1,299.99", "Sistema")
registrar_actividad("Alerta: Stock bajo en Laptop Gaming Pro", "Sistema")
📊 Casos prácticos del almacén
📁 Sistema de reportes automáticos
def generar_reporte_ventas_semanal():
"""Genera un reporte semanal de ventas automáticamente"""
from datetime import datetime, timedelta
# Datos simulados de ventas de la semana
ventas_semana = {
"Lunes": 2450.00,
"Martes": 3200.00,
"Miércoles": 2890.00,
"Jueves": 3450.00,
"Viernes": 4200.00,
"Sábado": 5100.00,
"Domingo": 1800.00
}
total_semanal = sum(ventas_semana.values())
promedio_diario = total_semanal / 7
mejor_dia = max(ventas_semana, key=ventas_semana.get)
fecha_reporte = datetime.now().strftime("%Y-%m-%d")
reporte = f"""
📈 ========================================
REPORTE SEMANAL DE VENTAS
Generado: {fecha_reporte}
========================================
💰 RESUMEN FINANCIERO:
Total semanal: ${total_semanal:,.2f}
Promedio diario: ${promedio_diario:,.2f}
Mejor día: {mejor_dia} (${ventas_semana[mejor_dia]:,.2f})
📅 VENTAS POR DÍA:
"""
for dia, venta in ventas_semana.items():
porcentaje = (venta / total_semanal) * 100
barra = "█" * int(porcentaje / 5) # Barra visual
reporte += f" {dia:10} ${venta:8.2f} {barra} ({porcentaje:.1f}%)\n"
reporte += f"""
📊 ANÁLISIS:
- El mejor día fue {mejor_dia} con ${ventas_semana[mejor_dia]:,.2f}
- Los fines de semana representan el {'alto' if ventas_semana['Sábado'] + ventas_semana['Domingo'] > total_semanal * 0.3 else 'bajo'} volumen de ventas
- Tendencia semanal: {'Positiva' if ventas_semana['Viernes'] > ventas_semana['Lunes'] else 'Variable'}
🎯 RECOMENDACIONES:
- Mantener inventario alto para {mejor_dia}s
- Revisar estrategia para días de menor venta
- Considerar promociones en días de baja actividad
--- Fin del reporte ---
"""
nombre_archivo = f"reporte_semanal_{fecha_reporte}.txt"
with open(nombre_archivo, "w", encoding="utf-8") as archivo:
archivo.write(reporte)
print(f"✅ Reporte semanal generado: {nombre_archivo}")
return nombre_archivo
# Generar reporte
generar_reporte_ventas_semanal()
📋 Procesador de listas de tareas
def procesar_lista_tareas_diarias():
"""Procesa y organiza las tareas diarias del almacén"""
# Crear lista de tareas si no existe
tareas_ejemplo = """
# TAREAS DEL ALMACÉN - PENDIENTES
## Urgentes:
- Revisar stock de laptops gaming (Stock: 3 unidades)
- Procesar devolución de mouse defectuoso
- Llamar a proveedor de teclados mecánicos
## Importantes:
- Actualizar precios de temporada
- Organizar sección de accesorios
- Revisar sistema de seguridad
## Rutinarias:
- Limpieza de área de almacenamiento
- Backup de datos del sistema
- Revisión de inventario semanal
## Completadas:
- [x] Recibir pedido de monitors 4K
- [x] Actualizar sistema de punto de venta
"""
# Crear archivo si no existe
try:
with open("tareas_diarias.txt", "r", encoding="utf-8") as f:
contenido = f.read()
except FileNotFoundError:
with open("tareas_diarias.txt", "w", encoding="utf-8") as f:
f.write(tareas_ejemplo)
contenido = tareas_ejemplo
# Procesar el contenido
lineas = contenido.split("\n")
tareas_urgentes = []
tareas_importantes = []
tareas_rutinarias = []
tareas_completadas = []
categoria_actual = None
for linea in lineas:
linea = linea.strip()
# Identificar categorías
if "Urgentes:" in linea:
categoria_actual = "urgentes"
elif "Importantes:" in linea:
categoria_actual = "importantes"
elif "Rutinarias:" in linea:
categoria_actual = "rutinarias"
elif "Completadas:" in linea:
categoria_actual = "completadas"
# Procesar tareas
elif linea.startswith("- ") or linea.startswith("- [x]"):
tarea = linea[2:] # Quitar "- "
if categoria_actual == "urgentes":
tareas_urgentes.append(tarea)
elif categoria_actual == "importantes":
tareas_importantes.append(tarea)
elif categoria_actual == "rutinarias":
tareas_rutinarias.append(tarea)
elif categoria_actual == "completadas":
tareas_completadas.append(tarea)
# Generar reporte de tareas
reporte_tareas = f"""
📋 ========================================
REPORTE DE TAREAS DEL ALMACÉN
Fecha: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}
========================================
🔴 TAREAS URGENTES ({len(tareas_urgentes)}):
"""
for i, tarea in enumerate(tareas_urgentes, 1):
reporte_tareas += f" {i}. {tarea}\n"
reporte_tareas += f"""
🟠 TAREAS IMPORTANTES ({len(tareas_importantes)}):
"""
for i, tarea in enumerate(tareas_importantes, 1):
reporte_tareas += f" {i}. {tarea}\n"
reporte_tareas += f"""
🗾 TAREAS RUTINARIAS ({len(tareas_rutinarias)}):
"""
for i, tarea in enumerate(tareas_rutinarias, 1):
reporte_tareas += f" {i}. {tarea}\n"
reporte_tareas += f"""
✅ TAREAS COMPLETADAS ({len(tareas_completadas)}):
"""
for i, tarea in enumerate(tareas_completadas, 1):
reporte_tareas += f" {i}. {tarea}\n"
total_pendientes = len(tareas_urgentes) + len(tareas_importantes) + len(tareas_rutinarias)
reporte_tareas += f"""
📊 RESUMEN:
- Total tareas pendientes: {total_pendientes}
- Tareas completadas: {len(tareas_completadas)}
- Prioridad: {'ALTA - Revisar urgentes inmediatamente' if tareas_urgentes else 'Normal - Continuar con importantes'}
"""
# Guardar reporte
with open("reporte_tareas.txt", "w", encoding="utf-8") as archivo:
archivo.write(reporte_tareas)
print("✅ Reporte de tareas generado: reporte_tareas.txt")
return total_pendientes, len(tareas_completadas)
# Procesar tareas
pendientes, completadas = procesar_lista_tareas_diarias()
print(f"Tienes {pendientes} tareas pendientes y {completadas} completadas")
🛡️ Mejores prácticas para archivos de texto
✅ Siempre usar context managers
# ✅ Correcto: El archivo se cierra automáticamente
with open("archivo.txt", "r", encoding="utf-8") as f:
contenido = f.read()
# Aquí el archivo ya está cerrado
# ❌ Incorrecto: Debes cerrar manualmente
f = open("archivo.txt", "r")
contenido = f.read()
f.close() # ¿Qué pasa si hay un error antes de esto?
✅ Especificar codificación (encoding)
# ✅ Correcto: Especifica UTF-8 para caracteres especiales
with open("reporte.txt", "w", encoding="utf-8") as f:
f.write("Menú del día: café, niños, cumpleaños 🎉")
# ❌ Problemas potenciales sin encoding
with open("reporte.txt", "w") as f: # Puede fallar con acentos
f.write("Menú del día")
✅ Manejar errores apropiadamente
def leer_archivo_seguro(nombre_archivo):
"""Lee un archivo de manera segura con manejo de errores"""
try:
with open(nombre_archivo, "r", encoding="utf-8") as archivo:
return archivo.read()
except FileNotFoundError:
print(f"⚠️ Archivo no encontrado: {nombre_archivo}")
return None
except PermissionError:
print(f"⚠️ Sin permisos para leer: {nombre_archivo}")
return None
except UnicodeDecodeError:
print(f"⚠️ Error de codificación en: {nombre_archivo}")
# Intentar con codificación diferente
try:
with open(nombre_archivo, "r", encoding="latin-1") as archivo:
return archivo.read()
except:
return None
except Exception as e:
print(f"⚠️ Error inesperado: {e}")
return None
# Uso seguro
contenido = leer_archivo_seguro("reporte_importante.txt")
if contenido:
print("Archivo leído exitosamente")
else:
print("No se pudo leer el archivo")
✅ Limpiar y validar datos
def procesar_archivo_productos():
"""Procesa archivo de productos limpiando datos"""
productos_limpios = []
with open("productos_raw.txt", "r", encoding="utf-8") as f:
for numero_linea, linea in enumerate(f, 1):
# Limpiar la línea
linea_limpia = linea.strip()
# Saltar líneas vacías
if not linea_limpia:
continue
# Saltar comentarios
if linea_limpia.startswith("#"):
continue
# Validar que la línea tenga contenido válido
if len(linea_limpia) < 3:
print(f"⚠️ Línea {numero_linea} muy corta: '{linea_limpia}'")
continue
productos_limpios.append(linea_limpia)
return productos_limpios
🚨 Comprueba tu comprensión
🎯 Ejercicio 1: Generador de reportes personalizado
Crea un sistema que genere reportes personalizados para el almacén:
def crear_reporte_personalizado(titulo, datos, observaciones):
"""
Crea un reporte personalizado con el formato del almacén.
Args:
titulo (str): Título del reporte
datos (list): Lista de datos para incluir
observaciones (list): Lista de observaciones
"""
# Tu implementación aquí...
pass
# Prueba tu función
datos_inventario = [
"Laptops en stock: 25 unidades",
"Valor total: $45,000",
"Productos vendidos hoy: 8"
]
observaciones_del_dia = [
"Alta demanda en laptops gaming",
"Considerar descuento en accesorios",
"Revisar proveedor de cables USB"
]
crear_reporte_personalizado(
"Reporte de Inventario Semanal",
datos_inventario,
observaciones_del_dia
)
🎯 Ejercicio 2: Analizador de logs
Crea un analizador que procese logs del almacén y genere estadísticas:
def analizar_logs_almacen(archivo_log):
"""
Analiza el archivo de logs y genera estadísticas.
Debe contar:
- Total de líneas procesadas
- Número de errores encontrados
- Número de ventas exitosas
- Actividades por usuario
"""
# Tu implementación aquí...
pass
# Crear un log de ejemplo para probar
log_ejemplo = """
[2024-01-15 09:00:00] Ana García: Inicio de jornada
[2024-01-15 09:15:00] Sistema: Venta procesada - $299.99
[2024-01-15 09:30:00] Carlos López: ERROR - Producto no encontrado
[2024-01-15 10:00:00] Sistema: Venta procesada - $1,299.99
[2024-01-15 10:15:00] Ana García: Producto agregado al inventario
[2024-01-15 10:30:00] Sistema: ERROR - Conexión perdida
"""
with open("log_ejemplo.txt", "w", encoding="utf-8") as f:
f.write(log_ejemplo)
# Probar tu analizador
analizar_logs_almacen("log_ejemplo.txt")
🎯 Ejercicio 3: Sistema de configuración
Crea un sistema que maneje la configuración del almacén mediante archivos de texto:
def cargar_configuracion(archivo_config):
"""
Carga configuración desde archivo de texto con formato:
clave = valor
Ejemplo:
nombre_almacen = TechStore Central
ubicacion = Ciudad de Mexico
impuesto = 0.16
stock_minimo = 5
"""
# Tu implementación aquí...
pass
def guardar_configuracion(config_dict, archivo_config):
"""Guarda configuración en archivo de texto"""
# Tu implementación aquí...
pass
# Probar el sistema
config_ejemplo = {
"nombre_almacen": "TechStore Central",
"ubicacion": "Ciudad de Mexico",
"impuesto": "0.16",
"stock_minimo": "5",
"email_admin": "admin@techstore.com"
}
guardar_configuracion(config_ejemplo, "config_almacen.txt")
config_cargada = cargar_configuracion("config_almacen.txt")
print(config_cargada)
📈 Lo que has logrado
¡Felicidades! Ahora dominas el manejo de archivos de texto en Python. Eres como un administrador de documentos experto que puede:
- 📄 Leer cualquier documento: Procesar reportes, logs y archivos de datos
- ✍️ Generar documentos automáticamente: Crear reportes personalizados y profesionales
- 📋 Organizar información: Estructurar datos de manera clara y legible
- 🛡️ Manejar errores: Trabajar de manera segura con archivos
- 🚀 Automatizar tareas: Procesar grandes volúmenes de información
Estas habilidades son fundamentales para cualquier proyecto de automatización y te permiten crear sistemas que pueden comunicarse con el mundo real a través de archivos.
🧭 Navegación:
- Anterior: Manejo de Archivos
- Siguiente: Trabajar con CSV
En este capítulo: