Función print() y input()

La comunicación con el usuario es una parte fundamental de cualquier programa. En Python, las funciones print() e input() son las herramientas básicas que nos permiten mostrar información y recibir datos del usuario a través de la consola.

Función print()

La función print() es la forma más sencilla de mostrar información en la pantalla. Su sintaxis básica es:

print(valor1, valor2, ..., sep=' ', end='\n')

Donde:

• valor1, valor2, ...: Son los valores que queremos mostrar
• sep: Es el separador entre valores (por defecto un espacio)
• end: Es el carácter que se añade al final (por defecto un salto de línea)

Veamos algunos ejemplos prácticos:

# Imprimir un texto simple
print("Hola, mundo!")

# Imprimir múltiples valores
nombre = "Ana"
edad = 25
print("Nombre:", nombre, "Edad:", edad)

# Usando variables dentro de cadenas con f-strings (Python 3.6+)
print(f"Hola {nombre}, tienes {edad} años")

Personalización de la salida

Podemos personalizar cómo se muestran los valores modificando los parámetros sep y end:

# Cambiar el separador
print("Python", "es", "genial", sep="-")  # Resultado: Python-es-genial

# Cambiar el final (útil para imprimir en la misma línea)
print("Cargando", end="...")
print("Completado")  # Resultado: Cargando...Completado

Formateo de texto

Python ofrece varias formas de formatear texto:

# Usando f-strings (recomendado en Python moderno)
precio = 19.99
print(f"El precio es: {precio:.2f} euros")  # El precio es: 19.99 euros

# Especificando precisión para números flotantes
pi = 3.14159265359
print(f"Pi con 3 decimales: {pi:.3f}")  # Pi con 3 decimales: 3.142

# Alineación de texto
print(f"{'Izquierda':<10}|{'Centro':^10}|{'Derecha':>10}")
print(f"{'*':<10}|{'*':^10}|{'*':>10}")

Función input()

La función input() permite recibir datos del usuario a través del teclado. Su sintaxis es:

variable = input(mensaje)

Donde:

• mensaje: Es el texto que se muestra al usuario como prompt
• variable: Almacena lo que el usuario escriba (siempre como cadena de texto)

Ejemplos básicos:

# Solicitar el nombre al usuario
nombre = input("Introduce tu nombre: ")
print(f"Hola, {nombre}!")

# Solicitar la edad (recordar que input siempre devuelve texto)
edad_texto = input("Introduce tu edad: ")
# Convertir a entero
edad = int(edad_texto)
print(f"El próximo año tendrás {edad + 1} años")

Conversión de tipos

Es importante recordar que input() siempre devuelve una cadena de texto, incluso si el usuario introduce números. Por eso, debemos convertir explícitamente al tipo de dato que necesitamos:

# Conversión a entero
numero = int(input("Introduce un número entero: "))
print(f"El doble es: {numero * 2}")

# Conversión a flotante
precio = float(input("Introduce el precio: "))
print(f"Con IVA (21%): {precio * 1.21:.2f}")

# Conversión a booleano (cualquier cadena no vacía es True)
respuesta = input("¿Continuar? (s/n): ").lower() == 's'
if respuesta:
    print("Continuando...")
else:
    print("Operación cancelada")

Manejo de errores básico

Cuando convertimos la entrada del usuario, pueden ocurrir errores si el formato no es el esperado:

try:
    edad = int(input("Introduce tu edad: "))
    print(f"En 10 años tendrás {edad + 10} años")
except ValueError:
    print("Error: Debes introducir un número entero")

Ejemplos prácticos combinando print() e input()

Calculadora simple

print("CALCULADORA SIMPLE")
print("-----------------")

num1 = float(input("Introduce el primer número: "))
num2 = float(input("Introduce el segundo número: "))

print(f"\nResultados:")
print(f"Suma: {num1 + num2}")
print(f"Resta: {num1 - num2}")
print(f"Multiplicación: {num1 * num2}")
# Comprobamos que el divisor no sea cero
if num2 != 0:
    print(f"División: {num1 / num2:.2f}")
else:
    print("División: No es posible dividir entre cero")

Conversor de temperatura

print("CONVERSOR DE TEMPERATURA")
print("-----------------------")

celsius = float(input("Introduce temperatura en grados Celsius: "))

# Fórmulas de conversión
fahrenheit = (celsius * 9/5) + 32
kelvin = celsius + 273.15

print(f"\n{celsius}°C equivale a:")
print(f"{fahrenheit:.2f}°F (Fahrenheit)")
print(f"{kelvin:.2f}K (Kelvin)")

Generador de saludos personalizados

print("GENERADOR DE SALUDOS")
print("-------------------")

nombre = input("¿Cómo te llamas? ")
hora = int(input("¿Qué hora es? (0-23): "))

# Determinar el saludo según la hora
if 5 <= hora < 12:
    saludo = "Buenos días"
elif 12 <= hora < 20:
    saludo = "Buenas tardes"
else:
    saludo = "Buenas noches"

print(f"\n{saludo}, {nombre}!")

La combinación de print() e input() constituye la base de la interacción con el usuario en programas de consola. Aunque son funciones simples, su dominio es esencial antes de avanzar hacia interfaces más complejas o aplicaciones con entrada/salida de archivos.

Apertura y cierre de archivos

Trabajar con archivos es una habilidad fundamental en programación que permite a nuestras aplicaciones almacenar y recuperar información de forma persistente. Python ofrece un sistema sencillo pero potente para manipular archivos.

La función open()

La función open() es la puerta de entrada para trabajar con archivos en Python. Su sintaxis básica es:

archivo = open(ruta, modo)

Donde:

• ruta: Es la ubicación del archivo (puede ser ruta relativa o absoluta)
• modo: Especifica cómo queremos abrir el archivo (lectura, escritura, etc.)

Un ejemplo simple sería:

# Abrir un archivo en modo lectura
archivo = open("notas.txt", "r")

# Hacer operaciones con el archivo...

# Cerrar el archivo cuando terminemos
archivo.close()

Importancia de cerrar archivos

Es crucial cerrar los archivos después de usarlos mediante el método close(). Cuando abrimos un archivo, estamos utilizando recursos del sistema operativo que deben ser liberados. No cerrar los archivos puede provocar:

• Pérdida de datos si los cambios no se guardan correctamente
• Bloqueo de archivos que impide que otros programas accedan a ellos
• Agotamiento de recursos del sistema si abrimos muchos archivos

El patrón with (contexto)

La forma recomendada de trabajar con archivos en Python moderno es usando el patrón with, que garantiza que los archivos se cierren automáticamente:

# Usando with para manejar archivos (recomendado)
with open("notas.txt", "r") as archivo:
    # Operaciones con el archivo...
    contenido = archivo.read()
    
# Al salir del bloque with, el archivo se cierra automáticamente

Este enfoque tiene varias ventajas:

• El archivo se cierra automáticamente al salir del bloque with
• Funciona incluso si ocurren excepciones dentro del bloque
• Código más limpio y menos propenso a errores

Rutas de archivos

Podemos especificar la ubicación de los archivos de diferentes maneras:

# Ruta relativa (desde la ubicación actual)
with open("datos.txt", "r") as f:
    pass

# Ruta relativa a una subcarpeta
with open("documentos/carta.txt", "r") as f:
    pass

# Ruta absoluta (completa desde la raíz)
with open("/home/usuario/documentos/informe.txt", "r") as f:
    pass

# Usando pathlib (más moderno y compatible entre sistemas)
from pathlib import Path
ruta = Path("documentos") / "informe.txt"
with open(ruta, "r") as f:
    pass

Manejo de errores al abrir archivos

Cuando trabajamos con archivos, es común encontrar errores como archivos inexistentes o permisos insuficientes. Es buena práctica manejar estas situaciones:

try:
    with open("config.txt", "r") as archivo:
        configuracion = archivo.read()
except FileNotFoundError:
    print("El archivo de configuración no existe. Se usará la configuración por defecto.")
    configuracion = "configuración_predeterminada"
except PermissionError:
    print("No tienes permisos para leer el archivo de configuración.")

Verificación de existencia de archivos

Antes de Python 3.4, era común verificar si un archivo existía antes de intentar abrirlo:

import os

if os.path.exists("datos.txt"):
    with open("datos.txt", "r") as archivo:
        # Procesar el archivo
else:
    print("El archivo no existe")

Sin embargo, en código moderno es preferible usar el enfoque EAFP (Easier to Ask Forgiveness than Permission) con bloques try-except como se mostró anteriormente.

Trabajando con rutas de forma moderna

La biblioteca pathlib introducida en Python 3.4 ofrece una forma orientada a objetos de trabajar con rutas de archivos:

from pathlib import Path

# Crear objeto Path
ruta = Path("documentos/informes/ventas.txt")

# Verificar si existe
if ruta.exists():
    # Abrir el archivo
    with open(ruta, "r") as archivo:
        contenido = archivo.read()
        
# Obtener información sobre la ruta
print(ruta.parent)  # Directorio padre
print(ruta.name)    # Nombre del archivo
print(ruta.suffix)  # Extensión

Ejemplos prácticos

Verificar si un archivo existe antes de abrirlo

from pathlib import Path

archivo = Path("configuracion.txt")

if archivo.exists():
    with open(archivo, "r") as f:
        print("Leyendo configuración existente...")
        configuracion = f.read()
else:
    print("Creando archivo de configuración por defecto...")
    with open(archivo, "w") as f:
        configuracion_predeterminada = "modo=normal\nidioma=es\ntema=claro"
        f.write(configuracion_predeterminada)

Manejo de archivos temporales

import tempfile

# Crear un archivo temporal
with tempfile.NamedTemporaryFile(mode="w+", delete=False) as temp:
    # Escribir datos en el archivo temporal
    temp.write("Datos temporales de procesamiento")
    nombre_archivo = temp.name
    
print(f"Archivo temporal creado en: {nombre_archivo}")

# Más tarde podemos abrir el archivo temporal
with open(nombre_archivo, "r") as f:
    datos = f.read()
    print(f"Contenido recuperado: {datos}")
    
# Y finalmente eliminarlo cuando ya no lo necesitemos
import os
os.unlink(nombre_archivo)

Crear una estructura de directorios y archivos

from pathlib import Path

# Crear estructura de directorios para un proyecto
proyecto = Path("mi_proyecto")
carpetas = ["src", "docs", "tests", "data"]

# Crear directorios si no existen
for carpeta in carpetas:
    directorio = proyecto / carpeta
    directorio.mkdir(parents=True, exist_ok=True)
    
# Crear un archivo README.md en la raíz del proyecto
readme = proyecto / "README.md"
with open(readme, "w") as f:
    f.write("# Mi Proyecto\n\nDescripción del proyecto...")

print(f"Estructura de proyecto creada en {proyecto.absolute()}")

El manejo adecuado de la apertura y cierre de archivos es fundamental para desarrollar aplicaciones robustas que interactúen con el sistema de archivos. Utilizando el patrón with y las técnicas modernas de Python, podemos trabajar con archivos de manera segura y eficiente.

Leer y escribir archivos de texto

Una vez que hemos aprendido a abrir y cerrar archivos correctamente, el siguiente paso es dominar las operaciones de lectura y escritura en archivos de texto. Estas operaciones son fundamentales para almacenar y recuperar información de forma persistente en nuestras aplicaciones Python.

Lectura de archivos de texto

Python ofrece varios métodos para leer el contenido de un archivo de texto, cada uno con diferentes propósitos y casos de uso.

Leer el archivo completo

El método más simple es read(), que lee todo el contenido del archivo como una única cadena de texto:

with open("notas.txt", "r") as archivo:
    contenido = archivo.read()
    print(contenido)

Este método es ideal para archivos pequeños, pero puede consumir mucha memoria si el archivo es grande.

Leer línea por línea

Para archivos más grandes o cuando necesitamos procesar el contenido línea por línea, podemos usar varias técnicas:

# Método 1: Usando readline()
with open("registro.txt", "r") as archivo:
    linea = archivo.readline()  # Lee la primera línea
    while linea:
        print(linea, end="")  # end="" evita doble salto de línea
        linea = archivo.readline()  # Lee la siguiente línea

# Método 2: Iterando directamente sobre el archivo (recomendado)
with open("registro.txt", "r") as archivo:
    for linea in archivo:
        print(linea, end="")

La segunda forma es más pythónica y eficiente, ya que el objeto archivo es iterable y devuelve las líneas automáticamente.

Leer todas las líneas en una lista

Si necesitamos manipular las líneas como una colección, podemos usar readlines():

with open("tareas.txt", "r") as archivo:
    lineas = archivo.readlines()  # Devuelve una lista con todas las líneas

# Ahora podemos procesar la lista
for i, linea in enumerate(lineas, 1):
    print(f"Línea {i}: {linea.strip()}")

El método strip() elimina los espacios en blanco y saltos de línea al inicio y final de cada línea.

Escritura en archivos de texto

La escritura en archivos nos permite guardar información generada por nuestro programa para su uso posterior.

Escribir texto

El método básico para escribir en un archivo es write():

with open("salida.txt", "w") as archivo:
    archivo.write("Hola, mundo!\n")
    archivo.write("Esta es la segunda línea.\n")

Es importante notar que write() no añade automáticamente saltos de línea, por lo que debemos incluirlos explícitamente con \n.

Escribir múltiples líneas

Para escribir varias líneas a la vez, podemos usar writelines():

lineas = [
    "Primera línea\n", 
    "Segunda línea\n", 
    "Tercera línea\n"
]

with open("listado.txt", "w") as archivo:
    archivo.writelines(lineas)

Observa que writelines() tampoco añade saltos de línea automáticamente, por lo que cada elemento de la lista debe incluirlos si los necesitamos.

Añadir contenido a un archivo existente

Si queremos añadir contenido al final de un archivo sin sobrescribir lo que ya existe, usamos el modo "a" (append):

with open("registro_diario.txt", "a") as archivo:
    archivo.write(f"Entrada registrada: {datetime.now()}\n")

Modos de lectura y escritura combinados

A veces necesitamos leer y escribir en el mismo archivo. Para esto, podemos usar el modo "r+":

with open("datos.txt", "r+") as archivo:
    # Leer contenido actual
    contenido = archivo.read()
    
    # Volver al inicio del archivo
    archivo.seek(0)
    
    # Escribir contenido modificado
    archivo.write("NUEVA LÍNEA\n" + contenido)

El método seek() es crucial aquí, ya que después de leer, el cursor está al final del archivo y necesitamos volver al principio para escribir.

Codificación de caracteres

Cuando trabajamos con texto que contiene caracteres especiales (como acentos, eñes o símbolos), es importante especificar la codificación correcta:

# Lectura con codificación específica
with open("mensaje.txt", "r", encoding="utf-8") as archivo:
    texto = archivo.read()

# Escritura con codificación específica
with open("salida.txt", "w", encoding="utf-8") as archivo:
    archivo.write("¡Hola, España! 🇪🇸\n")

UTF-8 es la codificación más recomendada para compatibilidad internacional.

Ejemplos prácticos

Contador de palabras

def contar_palabras(nombre_archivo):
    try:
        with open(nombre_archivo, "r", encoding="utf-8") as archivo:
            texto = archivo.read()
            palabras = texto.split()
            return len(palabras)
    except FileNotFoundError:
        return "El archivo no existe"

# Uso
num_palabras = contar_palabras("articulo.txt")
print(f"El archivo contiene {num_palabras} palabras")

Registro de temperatura

def registrar_temperatura(temperatura):
    from datetime import datetime
    
    timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
    registro = f"{timestamp}: {temperatura}°C\n"
    
    with open("temperaturas.log", "a") as archivo:
        archivo.write(registro)
    
    print(f"Temperatura {temperatura}°C registrada correctamente")

# Simulación de uso
registrar_temperatura(22.5)
registrar_temperatura(23.1)

Convertir archivo a mayúsculas

def convertir_a_mayusculas(archivo_entrada, archivo_salida):
    try:
        # Leer contenido del archivo original
        with open(archivo_entrada, "r", encoding="utf-8") as entrada:
            contenido = entrada.read()
        
        # Escribir contenido en mayúsculas al archivo de salida
        with open(archivo_salida, "w", encoding="utf-8") as salida:
            salida.write(contenido.upper())
            
        return True
    except Exception as e:
        print(f"Error: {e}")
        return False

# Uso
if convertir_a_mayusculas("original.txt", "mayusculas.txt"):
    print("Conversión completada con éxito")

Filtrar líneas de un archivo

def filtrar_lineas(archivo_entrada, archivo_salida, texto_filtro):
    with open(archivo_entrada, "r") as entrada:
        with open(archivo_salida, "w") as salida:
            for linea in entrada:
                if texto_filtro in linea:
                    salida.write(linea)
    
    print(f"Filtrado completado. Líneas con '{texto_filtro}' guardadas en {archivo_salida}")

# Ejemplo: filtrar líneas que contengan la palabra "ERROR" de un archivo de log
filtrar_lineas("aplicacion.log", "errores.log", "ERROR")

Crear un archivo CSV simple

def crear_csv_estudiantes(nombre_archivo, datos):
    with open(nombre_archivo, "w", newline="") as archivo:
        # Escribir encabezado
        archivo.write("Nombre,Edad,Calificación\n")
        
        # Escribir datos
        for estudiante in datos:
            linea = f"{estudiante['nombre']},{estudiante['edad']},{estudiante['calificacion']}\n"
            archivo.write(linea)
    
    print(f"Archivo CSV creado en {nombre_archivo}")

# Datos de ejemplo
estudiantes = [
    {"nombre": "Ana García", "edad": 20, "calificacion": 8.5},
    {"nombre": "Carlos López", "edad": 22, "calificacion": 7.8},
    {"nombre": "Elena Martín", "edad": 19, "calificacion": 9.2}
]

crear_csv_estudiantes("estudiantes.csv", estudiantes)

La lectura y escritura de archivos de texto es una habilidad fundamental que te permitirá crear aplicaciones más útiles y versátiles. Desde guardar configuraciones hasta procesar grandes volúmenes de datos, estas operaciones son esenciales en el desarrollo de software con Python.

Modos de apertura de archivos

Cuando trabajamos con archivos en Python, el modo en que los abrimos determina qué operaciones podemos realizar con ellos. El modo se especifica como segundo parámetro en la función open() y define si podemos leer, escribir, o ambas cosas, así como si trabajamos con texto o datos binarios.

Los modos de apertura son cadenas de texto que indican al sistema operativo cómo queremos interactuar con el archivo. Elegir el modo correcto es crucial para evitar errores y comportamientos inesperados en nuestras aplicaciones.

Modos básicos

Python ofrece varios modos fundamentales para abrir archivos:

• 'r': Modo de lectura (valor predeterminado). Abre el archivo para leer; genera error si el archivo no existe.

with open("config.txt", "r") as archivo:
    contenido = archivo.read()

• 'w': Modo de escritura. Crea un archivo nuevo para escribir; si ya existe, lo sobrescribe completamente.

with open("salida.txt", "w") as archivo:
    archivo.write("Nuevo contenido")  # Sobrescribe cualquier contenido previo

• 'a': Modo de añadir (append). Abre el archivo para escribir al final; crea el archivo si no existe.

with open("registro.log", "a") as archivo:
    archivo.write("Nueva entrada de registro\n")  # Añade al final sin borrar

• 'x': Modo de creación exclusiva. Crea un archivo nuevo y lo abre para escritura; genera error si ya existe.

try:
    with open("archivo_unico.txt", "x") as archivo:
        archivo.write("Este archivo no existía antes")
except FileExistsError:
    print("El archivo ya existe, no se puede sobrescribir")

Modos combinados

Estos modos básicos pueden combinarse para obtener comportamientos más específicos:

• 'r+': Modo de lectura y escritura. Abre el archivo para ambas operaciones; el archivo debe existir.

with open("datos.txt", "r+") as archivo:
    datos = archivo.read()
    archivo.seek(0)  # Volver al inicio del archivo
    archivo.write("Línea nueva\n" + datos)

• 'w+': Modo de escritura y lectura. Crea un archivo nuevo o sobrescribe uno existente, permitiendo también leerlo.

with open("nuevo_archivo.txt", "w+") as archivo:
    archivo.write("Primera línea\nSegunda línea\n")
    archivo.seek(0)  # Volver al inicio para leer
    contenido = archivo.read()
    print(f"Contenido escrito: {contenido}")

• 'a+': Modo de añadir y leer. Abre o crea un archivo para añadir contenido y permite leerlo.

with open("historial.txt", "a+") as archivo:
    # Añadir nueva entrada
    archivo.write("Nueva entrada: " + str(datetime.now()) + "\n")
    
    # Leer todo el historial
    archivo.seek(0)
    historial_completo = archivo.read()
    print("Historial actualizado:", historial_completo)

Modos binarios

Para trabajar con archivos que contienen datos no textuales (imágenes, audio, etc.), debemos usar los modos binarios añadiendo 'b' al modo básico:

• 'rb': Lectura binaria
• 'wb': Escritura binaria
• 'ab': Añadir en modo binario
• 'xb': Creación exclusiva binaria

# Leer una imagen en modo binario
with open("imagen.jpg", "rb") as archivo:
    datos_imagen = archivo.read()
    print(f"Tamaño de la imagen: {len(datos_imagen)} bytes")

# Crear una copia de un archivo binario
with open("imagen.jpg", "rb") as original:
    with open("copia_imagen.jpg", "wb") as copia:
        copia.write(original.read())

Modos de texto con codificación

Para archivos de texto, podemos especificar la codificación de caracteres:

# Leer un archivo con codificación específica
with open("mensaje.txt", "r", encoding="utf-8") as archivo:
    texto = archivo.read()
    
# Escribir con codificación específica
with open("caracteres_especiales.txt", "w", encoding="utf-8") as archivo:
    archivo.write("Texto con caracteres especiales: áéíóúñ€")

Parámetros adicionales de open()

Además del modo, la función open() acepta otros parámetros útiles:

• encoding: Especifica la codificación de caracteres (por defecto depende del sistema).
• buffering: Controla el buffer de E/S (0 para desactivarlo, 1 para línea a línea, >1 para tamaño en bytes).
• errors: Define cómo manejar errores de codificación ('strict', 'ignore', 'replace', etc.).
• newline: Controla cómo se manejan los saltos de línea.

# Ejemplo con varios parámetros
with open("datos.csv", 
          mode="r", 
          encoding="latin-1",
          errors="replace",
          newline="") as archivo:
    contenido = archivo.read()

Casos de uso prácticos

Registro de eventos con timestamp

def registrar_evento(mensaje):
    from datetime import datetime
    timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
    
    with open("eventos.log", "a") as log:
        log.write(f"[{timestamp}] {mensaje}\n")

# Uso del registro
registrar_evento("Aplicación iniciada")
registrar_evento("Usuario autenticado")

Actualizar archivo de configuración

def actualizar_configuracion(clave, valor):
    # Leer configuración actual
    config = {}
    try:
        with open("config.ini", "r") as archivo:
            for linea in archivo:
                if "=" in linea:
                    k, v = linea.strip().split("=", 1)
                    config[k] = v
    except FileNotFoundError:
        # El archivo no existe, se creará uno nuevo
        pass
    
    # Actualizar valor
    config[clave] = valor
    
    # Guardar configuración actualizada
    with open("config.ini", "w") as archivo:
        for k, v in config.items():
            archivo.write(f"{k}={v}\n")
    
    print(f"Configuración actualizada: {clave}={valor}")

# Ejemplo de uso
actualizar_configuracion("tema", "oscuro")
actualizar_configuracion("idioma", "es")

Copiar y transformar archivos

def copiar_y_transformar(archivo_origen, archivo_destino, transformacion):
    """
    Copia un archivo aplicando una función de transformación a cada línea.
    """
    try:
        with open(archivo_origen, "r") as origen:
            with open(archivo_destino, "w") as destino:
                for linea in origen:
                    linea_transformada = transformacion(linea)
                    destino.write(linea_transformada)
        return True
    except Exception as e:
        print(f"Error: {e}")
        return False

# Ejemplo: convertir a mayúsculas
resultado = copiar_y_transformar(
    "entrada.txt", 
    "salida.txt", 
    lambda x: x.upper()
)

if resultado:
    print("Transformación completada con éxito")

Guardar y cargar datos de usuario

def guardar_preferencias(usuario, preferencias):
    """Guarda las preferencias de un usuario en un archivo específico."""
    nombre_archivo = f"prefs_{usuario}.txt"
    
    with open(nombre_archivo, "w") as archivo:
        for clave, valor in preferencias.items():
            archivo.write(f"{clave}={valor}\n")
    
    print(f"Preferencias guardadas para {usuario}")

def cargar_preferencias(usuario):
    """Carga las preferencias de un usuario desde su archivo."""
    nombre_archivo = f"prefs_{usuario}.txt"
    preferencias = {}
    
    try:
        with open(nombre_archivo, "r") as archivo:
            for linea in archivo:
                if "=" in linea:
                    clave, valor = linea.strip().split("=", 1)
                    preferencias[clave] = valor
        return preferencias
    except FileNotFoundError:
        print(f"No hay preferencias guardadas para {usuario}")
        return {}

# Ejemplo de uso
prefs_usuario = {
    "tema": "claro",
    "notificaciones": "activadas",
    "tamaño_fuente": "mediano"
}

guardar_preferencias("carlos", prefs_usuario)
preferencias_cargadas = cargar_preferencias("carlos")
print("Preferencias cargadas:", preferencias_cargadas)

Trabajar con archivos temporales

def procesar_datos_temporales(datos):
    import tempfile
    import os
    
    # Crear archivo temporal
    with tempfile.NamedTemporaryFile(mode="w+", delete=False) as temp:
        # Escribir datos para procesamiento
        for linea in datos:
            temp.write(f"{linea}\n")
        
        nombre_temp = temp.name
    
    # El archivo se cierra automáticamente al salir del bloque with
    
    # Procesar el archivo (en este caso, contar líneas)
    with open(nombre_temp, "r") as archivo:
        num_lineas = sum(1 for _ in archivo)
    
    # Eliminar el archivo temporal cuando ya no lo necesitamos
    os.unlink(nombre_temp)
    
    return num_lineas

# Ejemplo
datos_muestra = ["dato1", "dato2", "dato3", "dato4"]
resultado = procesar_datos_temporales(datos_muestra)
print(f"Se procesaron {resultado} líneas de datos")

La elección del modo de apertura correcto es fundamental para trabajar eficientemente con archivos en Python. Entender las diferencias entre los distintos modos te permitirá implementar operaciones de entrada/salida de forma segura y efectiva en tus aplicaciones.