Operaciones Fundamentales con Archivos en Python

Python proporciona mecanismos robustos para interactuar con el sistema de archivos, permitiendo leer, escribir y modificar el contenido de los archivos. La función principal para esto es open(), que devuelve un objeto de archivo o file handle, sobre el cual se pueden realizar diversas operaciones.

Modos de Apertura de Archivos

Al abrir un archivo, es crucial especificar el modo de operación para definir la intención (lectura, escritura, etc.) y el tipo de contenido (texto o binario). Los modos más comunes son:

• Modos Principales:
  • 'r' (read): Abre el archivo solo para lectura. El archivo debe existir, de lo contrario, se produce un error FileNotFoundError. Es el modo predeterminado.
  • 'w' (write): Abre el archivo solo para ecsritura. Si el archivo no existe, lo crea. Si existe, su contenido se trunca (borra) antes de escribir.
  • 'a' (append): Abre el archivo para escritura. Si no existe, lo crea. Si existe, la escritura comienza al final del archivo, conservando el contenido existente.
  • 'x' (exclusive creation): Abre el archivo para escritura exclusiva. Si el archivo ya existe, se produce un error FileExistsError.
• Modos Secundarios (Tipo de Contenido):
  • 't' (text): Modo texto (predeterminado). Se utiliza para archivos de texto y requiere especificar la codificación (ej., encoding='utf-8').
  • 'b' (binary): Modo binario. Se utiliza para archivos no textuales (imágenes, videos, etc.) y no requiere codificación.
• Modificador '+=' (Lectura y Escritura):
  • '+': Permite operaciones tanto de lectura como de escritura. Se combina con los modos principales (ej., 'r+', 'w+', 'a+').

Ejemplos de combinaciones: 'rt' (lectura de texto), 'rb' (lectura binaria), 'wt+' (escritura/lectura de texto, truncando si existe).

Métodos Esenciales de Archivo

• seek(offset, origin): Mueve la posición del cursor del archivo. Funciona mejor en modo binario, ya que offset se interpreta como un número de bytes.
  • offset: Cantidad de bytes a mover (positivo a la derecha, negativo a la izquierda).
  • origin: Punto de referencia para el offset: 0 (inicio del archivo), 1 (posición actual), 2 (final del archivo).
• flush(): Fuerza la escritura de cualquier dato almacenado en búfer en la memoria al disco.
• close(): Libera los recursos del archivo y asegura que los datos en búfer se escriban en el disco.

Gestión de Archivos con with open()

Se recomienda encarecidamente usar el gestor de contexto with open(...), ya que garantiza que el archivo se cierre automáticamente, incluso si ocurren errores.

try:
    with open('mi_documento.txt', 'r+', encoding='utf-8') as archivo_gestionado:
        print(f"¿Es legible? {archivo_gestionado.readable()}")
        print(f"¿Es escribible? {archivo_gestionado.writable()}")
        archivo_gestionado.write("Contenido de prueba.\n")
        archivo_gestionado.seek(0) # Mover cursor al inicio para leer
        contenido = archivo_gestionado.read()
        print(f"Contenido actual: \n{contenido}")
except FileNotFoundError:
    print("El archivo 'mi_documento.txt' no se encontró.")
except Exception as e:
    print(f"Ocurrió un error: {e}")

Interacción con Argumentos de Línea de Comandos

El módulo sys permite acceder a los argumentos pasados a un script de Python. sys.argv es una lista donde el primer elemento es el nombre del script y los siguientes son los argumentos proporcionados.

import sys

def procesar_operacion_archivo():
    print(f"Argumentos del script: {sys.argv}")

    if len(sys.argv) < 2:
        print("Uso: python script.py <comando> [nombre_archivo] [contenido]")
        print("Comandos disponibles: 'crear', 'escribir', 'leer'")
        return

    comando = sys.argv[1].lower()
    nombre_archivo = sys.argv[2] if len(sys.argv) > 2 else "archivo_por_defecto.txt"

    if comando == 'crear':
        try:
            with open(nombre_archivo, 'x', encoding='utf-8') as f:
                print(f"Archivo '{nombre_archivo}' creado exitosamente.")
        except FileExistsError:
            print(f"Error: El archivo '{nombre_archivo}' ya existe. No se puede crear con 'x'.")
    elif comando == 'escribir':
        if len(sys.argv) < 4:
            print("Error: Se necesita contenido para el comando 'escribir'.")
            return
        texto_a_escribir = sys.argv[3]
        with open(nombre_archivo, 'w', encoding='utf-8') as f:
            f.write(texto_a_escribir)
            print(f"Contenido escrito en '{nombre_archivo}'.")
    elif comando == 'leer':
        try:
            with open(nombre_archivo, 'r', encoding='utf-8') as f:
                contenido_leido = f.read()
                print(f"Contenido de '{nombre_archivo}':\n{contenido_leido}")
        except FileNotFoundError:
            print(f"Error: El archivo '{nombre_archivo}' no existe.")
    else:
        print(f"Comando desconocido: '{comando}'.")

# Para ejecutar desde la terminal:
# python tu_script.py crear mi_nuevo_archivo.txt
# python tu_script.py escribir mi_nuevo_archivo.txt "Hola, este es un texto."
# python tu_script.py leer mi_nuevo_archivo.txt

Introducción a las Funciones en Python

Las funciones son bloques de código organizados y reutilizables que realizan una tarea específica. Son un pilar fundamental en la programación, permitiendo estructurar el código de manera modular y eficiente.

Beneficios de Utilizar Funciones

• Reutilización de Código: Evitan la duplicación, permitiendo llamar la misma lógica desde diferentes partes del programa.
• Claridad y Organización: Dividen problemas complejos en partes manejables, mejorando la legibilidad del código.
• Mantenibilidad: Facilitan la corrección de errores y la implementación de mejoras, ya que los cambios se realizan en un solo lugar.
• Abstracción: Permiten usar un bloque de código sin necesidad de conocer sus detalles internos.

Sintaxis y Componentes de una Función

Una función se define con la palabra clave def, seguida del nombre de la función, paréntesis (que pueden contener parámetros) y dos puntos. El cuerpo de la función se indenta.

def nombre_de_la_funcion(parametro1, parametro2):
    """Docstring: Descripción de lo que hace la función."""
    # Cuerpo de la función: código que realiza la tarea
    resultado = parametro1 + parametro2
    return resultado # Opcional: devuelve un valor

• Nombre de la Función: Identificador único para invocar la función.
• Parámetros: Valores que la función espera recibir para realizar su tarea. Son opcionales.
• Cuerpo de la Función: Conjunto de instrucciones que se ejecutan cuando la función es llamada.
• Valor de Retorno (return): La función puede devolver un valor (o varios en forma de tupla) como resultado de su ejecución. Si no se especifica return, la función devuelve implícitamente None.

Ejemplos Básicos de Funciones

# Función sin parámetros ni valor de retorno explícito
def saludar():
    print("¡Hola desde una función!")

# Función con un parámetro
def mostrar_mensaje(mensaje):
    print(f"Mensaje recibido: {mensaje}")

# Función con parámetros y valor de retorno
def sumar_numeros(num1, num2):
    return num1 + num2

# Llamada a las funciones
saludar() # Imprime "¡Hola desde una función!"
mostrar_mensaje("Aprendiendo funciones en Python") # Imprime "Mensaje recibido: Aprendiendo funciones en Python"

suma_total = sumar_numeros(5, 7)
print(f"La suma es: {suma_total}") # Imprime "La suma es: 12"

# Un return sin valor o la ausencia de return devuelve None
def funcion_vacia():
    pass # No hace nada

def funcion_con_return_sin_valor():
    print("Esta función termina.")
    return

print(f"Retorno de funcion_vacia: {funcion_vacia()}") # Imprime "Retorno de funcion_vacia: None"
print(f"Retorno de funcion_con_return_sin_valor: {funcion_con_return_sin_valor()}") # Imprime "Esta función termina." y "Retorno de funcion_con_return_sin_valor: None"

Funciones que Devuelven Múltiples Valores

Una función puede devolver múltiples valores, que Python empaqueta automáticamente en una tupla.

def operaciones_aritmeticas(a, b):
    suma = a + b
    resta = a - b
    multiplicacion = a * b
    division = a / b # Considerar manejo de ZeroDivisionError
    return suma, resta, multiplicacion, division

resultados = operaciones_aritmeticas(10, 2)
print(f"Todos los resultados (tupla): {resultados}") # (12, 8, 20, 5.0)

# Desempaquetado de la tupla en variables individuales
s, r, m, d = operaciones_aritmeticas(20, 5)
print(f"Suma: {s}, Resta: {r}, Multiplicación: {m}, División: {d}")

Anidamiento de Llamadas a Funciones

Una función puede llamar a otra función dentro de su cuerpo. Esto es fundamental para la modularidad y para construir lógica más compleja a partir de bloques simples.

def encontrar_maximo_dos(val_a, val_b):
    return val_a if val_a > val_b else val_b

def encontrar_maximo_tres(val_a, val_b, val_c):
    # Reutilizamos la función que compara dos valores
    max_temp = encontrar_maximo_dos(val_a, val_b)
    return encontrar_maximo_dos(max_temp, val_c)

def encontrar_maximo_cuatro(val_a, val_b, val_c, val_d):
    # Podemos anidar las llamadas de forma más profunda
    max_ab = encontrar_maximo_dos(val_a, val_b)
    max_cd = encontrar_maximo_dos(val_c, val_d)
    return encontrar_maximo_dos(max_ab, max_cd)

print(f"Máximo entre 10 y 5: {encontrar_maximo_dos(10, 5)}")
print(f"Máximo entre 10, 25 y 15: {encontrar_maximo_tres(10, 25, 15)}")
print(f"Máximo entre 8, 3, 12 y 7: {encontrar_maximo_cuatro(8, 3, 12, 7)}")

Estructura de un Sistema Sancillo con Funciones

Las funciones son ideales para organizar la lógica de un programa, como un sistema de autenticación.

import os

RUTA_DATOS_USUARIOS = 'credenciales.txt'

def cargar_credenciales():
    """Carga los usuarios y contraseñas del archivo."""
    usuarios = {}
    if os.path.exists(RUTA_DATOS_USUARIOS):
        with open(RUTA_DATOS_USUARIOS, 'r', encoding='utf-8') as f:
            for linea in f:
                if ':' in linea:
                    usuario, clave = linea.strip().split(':', 1)
                    usuarios[usuario] = clave
    return usuarios

def guardar_credencial(usuario, clave):
    """Guarda un nuevo usuario en el archivo."""
    with open(RUTA_DATOS_USUARIOS, 'a', encoding='utf-8') as f:
        f.write(f"{usuario}:{clave}\n")
    print("Usuario registrado con éxito.")

def autenticar_usuario(usuario_input, clave_input):
    """Verifica si las credenciales son válidas."""
    usuarios_registrados = cargar_credenciales()
    if usuario_input in usuarios_registrados and usuarios_registrados[usuario_input] == clave_input:
        print(f"¡Bienvenido, {usuario_input}!")
        return True
    else:
        print("Usuario o contraseña incorrectos.")
        return False

def menu_principal_app():
    """Bucle principal del menú de la aplicación."""
    print("\n--- ¡Bienvenido a la Aplicación! ---")
    while True:
        print("\nSeleccione una opción:")
        print("1. Iniciar Sesión")
        print("2. Registrar Nuevo Usuario")
        print("0. Salir")

        opcion = input("Su elección: ")

        if opcion == '1':
            usr = input("Ingrese su usuario: ")
            pwd = input("Ingrese su contraseña: ")
            autenticar_usuario(usr, pwd)
        elif opcion == '2':
            nuevo_usr = input("Defina un nombre de usuario: ")
            nueva_pwd = input("Defina una contraseña: ")
            guardar_credencial(nuevo_usr, nueva_pwd)
        elif opcion == '0':
            print("Saliendo de la aplicación. ¡Hasta pronto!")
            break
        else:
            print("Opción no válida. Intente de nuevo.")

# Para ejecutar el menú principal:
# menu_principal_app()

Función para Copiar Archivos

Las funciones también pueden encapsular operaciones de archivo más complejas, como copiar el contenido de un archivo a otro.

def copiar_archivo(origen_path, destino_path):
    """
    Copia el contenido de un archivo desde la ruta de origen a la ruta de destino.
    Funciona para cualquier tipo de archivo (texto o binario).
    """
    try:
        with open(origen_path, 'rb') as archivo_original, \
             open(destino_path, 'wb') as archivo_copia:
            while True:
                bloque = archivo_original.read(4096) # Leer en bloques de 4KB
                if not bloque:
                    break # Se alcanzó el final del archivo
                archivo_copia.write(bloque)
        print(f"Archivo copiado exitosamente de '{origen_path}' a '{destino_path}'.")
    except FileNotFoundError:
        print(f"Error: Uno de los archivos (origen '{origen_path}' o destino '{destino_path}') no fue encontrado.")
    except Exception as e:
        print(f"Ocurrió un error inesperado al copiar el archivo: {e}")

# Ejemplo de uso:
# Asegúrate de tener un 'documento_original.txt' o 'imagen.jpg' existente
# copiar_archivo('documento_original.txt', 'documento_copia.txt')
# copiar_archivo('imagen.jpg', 'copia_de_imagen.jpg')