Concepto de aplicación parcial

La aplicación parcial es una técnica de programación funcional que permite crear nuevas funciones a partir de funciones existentes, fijando algunos de sus argumentos. Cuando aplicamos parcialmente una función, estamos "preestableciendo" algunos de sus parámetros, lo que resulta en una nueva función que acepta menos argumentos que la original.

Imagina que tienes una función que requiere varios parámetros, pero en cierto contexto, algunos de esos parámetros siempre tendrán el mismo valor. En lugar de repetir esos valores cada vez que llamas a la función, puedes crear una nueva función que ya tenga esos valores incorporados.

Para entender mejor este concepto, veamos un ejemplo sencillo:

def saludar(saludo, nombre):
    return f"{saludo}, {nombre}!"

# Uso normal de la función
mensaje = saludar("Hola", "Ana")
print(mensaje)  # Hola, Ana!

Si necesitamos saludar a muchas personas con "Hola", podríamos aplicar parcialmente la función:

def saludar_con_hola(nombre):
    return saludar("Hola", nombre)

# Uso de la función con aplicación parcial
mensaje = saludar_con_hola("Ana")
print(mensaje)  # Hola, Ana!

En este ejemplo, saludar_con_hola es una nueva función que tiene prefijado el primer argumento de saludar. Esto es una forma manual de aplicación parcial.

Ventajas de la aplicación parcial

La aplicación parcial ofrece varias ventajas importantes:

• Reutilización de código: Permite crear variantes especializadas de funciones sin duplicar código.
• Mayor legibilidad: Las funciones resultantes suelen tener un propósito más específico y claro.
• Composición de funciones: Facilita la creación de cadenas de transformaciones de datos.
• Reducción de errores: Al fijar ciertos parámetros, se elimina la posibilidad de pasarlos incorrectamente.

Aplicación parcial en funciones de orden superior

La aplicación parcial es especialmente útil cuando trabajamos con funciones de orden superior como map(), filter() o sorted():

numeros = [1, 2, 3, 4, 5]

# Sin aplicación parcial
resultado = list(map(lambda x: x * 2, numeros))

# Definimos una función multiplicadora con aplicación parcial
def multiplicar_por(factor):
    def multiplicador(x):
        return x * factor
    return multiplicador

duplicar = multiplicar_por(2)
triplicar = multiplicar_por(3)

# Con aplicación parcial
resultado1 = list(map(duplicar, numeros))  # [2, 4, 6, 8, 10]
resultado2 = list(map(triplicar, numeros))  # [3, 6, 9, 12, 15]

En este ejemplo, multiplicar_por es una función fábrica que genera funciones especializadas mediante aplicación parcial. Cada función generada tiene prefijado el factor de multiplicación.

Aplicación parcial vs. valores predeterminados

Es importante distinguir entre la aplicación parcial y los valores predeterminados de los parámetros:

# Función con valor predeterminado
def saludar_default(nombre, saludo="Hola"):
    return f"{saludo}, {nombre}!"

# Aplicación parcial manual
def hola_parcial(nombre):
    return saludar("Hola", nombre)

Aunque ambos enfoques pueden lograr resultados similares, la aplicación parcial es más flexible porque:

1. Permite fijar cualquier parámetro, no solo los últimos (como en Python con valores predeterminados).
2. Puede aplicarse a funciones existentes sin modificarlas.
3. Permite crear múltiples variantes de una misma función base.

Implementación manual de aplicación parcial

Podemos implementar la aplicación parcial manualmente usando funciones anidadas:

def aplicacion_parcial(func, *args_fijos, **kwargs_fijos):
    def nueva_funcion(*args, **kwargs):
        # Combinamos los argumentos fijos con los nuevos
        todos_args = args_fijos + args
        todos_kwargs = {**kwargs_fijos, **kwargs}
        return func(*todos_args, **todos_kwargs)
    return nueva_funcion

# Ejemplo de uso
def dividir(a, b):
    return a / b

# Creamos una función que divide cualquier número entre 2
dividir_entre_2 = aplicacion_parcial(dividir, b=2)
print(dividir_entre_2(10))  # 5.0

Esta implementación manual nos permite entender el concepto, pero Python proporciona herramientas más elegantes para la aplicación parcial, como functools.partial(), que veremos en la siguiente sección.

Aplicaciones prácticas

La aplicación parcial tiene numerosos usos prácticos en el desarrollo de software:

• Configuración de funciones: Crear variantes de funciones con diferentes configuraciones.
• Callbacks personalizados: Generar funciones callback con parámetros específicos.
• Adaptadores de API: Simplificar interfaces complejas creando funciones más específicas.
• Procesamiento de datos: Crear pipelines de transformación de datos reutilizables.

Por ejemplo, si estamos procesando archivos con diferentes codificaciones:

def leer_archivo(nombre_archivo, codificacion):
    with open(nombre_archivo, 'r', encoding=codificacion) as f:
        return f.read()

# Creamos funciones especializadas mediante aplicación parcial manual
def leer_utf8(nombre_archivo):
    return leer_archivo(nombre_archivo, 'utf-8')

def leer_latin1(nombre_archivo):
    return leer_archivo(nombre_archivo, 'latin-1')

# Uso
contenido = leer_utf8('datos.txt')

La aplicación parcial nos permite crear funciones más específicas y expresivas, mejorando la legibilidad y mantenibilidad del código. En la siguiente sección, veremos cómo Python facilita esta técnica con la función functools.partial().

functools.partial()

Python proporciona una implementación elegante y eficiente de la aplicación parcial a través del módulo functools con la función partial(). Esta herramienta nos permite crear nuevas funciones derivadas sin necesidad de escribir funciones auxiliares manualmente.

La función partial() toma una función existente y un conjunto de argumentos, y devuelve una nueva función que, cuando se llama, combina los argumentos originales con los nuevos argumentos proporcionados. Esto simplifica enormemente el proceso de aplicación parcial que vimos anteriormente.

Sintaxis básica

La sintaxis de functools.partial() es la siguiente:

from functools import partial

nueva_funcion = partial(funcion_original, arg1, arg2, ..., kwarg1=valor1, ...)

Donde:

• funcion_original es la función a la que queremos aplicar parcialmente argumentos
• arg1, arg2, ... son argumentos posicionales que queremos fijar
• kwarg1=valor1, ... son argumentos con nombre que queremos fijar

Ejemplos prácticos

Veamos algunos ejemplos para entender mejor cómo funciona partial():

Ejemplo 1: Función matemática simple

from functools import partial

def potencia(base, exponente):
    return base ** exponente

# Creamos una función que calcula el cuadrado
cuadrado = partial(potencia, exponente=2)
# Creamos una función que calcula el cubo
cubo = partial(potencia, exponente=3)

print(cuadrado(5))  # 25
print(cubo(5))      # 125

En este ejemplo, hemos creado dos nuevas funciones (cuadrado y cubo) a partir de la función potencia, fijando el parámetro exponente.

Ejemplo 2: Trabajando con funciones integradas

partial() es especialmente útil con funciones integradas de Python:

from functools import partial

# Convertir cadenas a enteros en diferentes bases
binario_a_int = partial(int, base=2)
octal_a_int = partial(int, base=8)
hex_a_int = partial(int, base=16)

print(binario_a_int('1010'))    # 10
print(octal_a_int('12'))        # 10
print(hex_a_int('A'))           # 10

Este ejemplo muestra cómo podemos crear funciones especializadas para convertir cadenas a enteros en diferentes sistemas numéricos.

Uso con argumentos posicionales

partial() también puede fijar argumentos posicionales:

from functools import partial

def dividir(a, b):
    return a / b

# Fijamos el primer argumento (dividendo)
dividir_10_entre = partial(dividir, 10)
print(dividir_10_entre(2))  # 5.0 (10/2)

# Fijamos el segundo argumento (divisor)
dividir_entre_2 = partial(dividir, b=2)
print(dividir_entre_2(10))  # 5.0 (10/2)

Es importante notar que cuando fijamos argumentos posicionales, estos ocupan las primeras posiciones de la función original. En el ejemplo, dividir_10_entre(2) equivale a dividir(10, 2).

Combinación con funciones de orden superior

Una de las aplicaciones más potentes de partial() es su uso con funciones de orden superior como map(), filter() y sorted():

from functools import partial

numeros = [1, 2, 3, 4, 5]
cadenas = ["10", "20", "30", "40", "50"]

# Multiplicar cada número por 3
triplicar = partial(map, lambda x: x * 3)
resultado = list(triplicar(numeros))
print(resultado)  # [3, 6, 9, 12, 15]

# Convertir cadenas a enteros
convertir = partial(map, int)
resultado = list(convertir(cadenas))
print(resultado)  # [10, 20, 30, 40, 50]

# Filtrar números pares
es_par = lambda x: x % 2 == 0
filtrar_pares = partial(filter, es_par)
resultado = list(filtrar_pares(numeros))
print(resultado)  # [2, 4]

Acceso a los argumentos fijados

Los objetos creados con partial() tienen atributos especiales que nos permiten inspeccionar los argumentos fijados:

from functools import partial

def saludar(saludo, nombre, sufijo):
    return f"{saludo}, {nombre}{sufijo}"

hola_sr = partial(saludar, "Hola", sufijo=" Sr.")

# Accedemos a la función original
print(hola_sr.func)  # <function saludar at 0x...>

# Accedemos a los argumentos posicionales fijados
print(hola_sr.args)  # ('Hola',)

# Accedemos a los argumentos con nombre fijados
print(hola_sr.keywords)  # {'sufijo': ' Sr.'}

# Usamos la función
print(hola_sr("Juan"))  # Hola, Juan Sr.

Estos atributos son útiles para depuración y para entender cómo se ha configurado una función parcial.

Casos de uso prácticos

functools.partial() tiene numerosas aplicaciones en el desarrollo real:

1. Configuración de funciones de biblioteca

import json
from functools import partial

# Configurar un serializador JSON con formato específico
json_bonito = partial(json.dumps, indent=4, sort_keys=True)

datos = {"nombre": "Ana", "edad": 28, "ciudad": "Madrid"}
print(json_bonito(datos))
# {
#     "ciudad": "Madrid",
#     "edad": 28,
#     "nombre": "Ana"
# }

2. Simplificación de callbacks

from functools import partial
import tkinter as tk

def manejar_clic(mensaje, evento):
    print(f"Botón clickeado: {mensaje}")

ventana = tk.Tk()
boton1 = tk.Button(ventana, text="Botón 1")
boton2 = tk.Button(ventana, text="Botón 2")

# Configuramos callbacks con mensajes específicos
boton1.config(command=partial(manejar_clic, "Has pulsado el botón 1"))
boton2.config(command=partial(manejar_clic, "Has pulsado el botón 2"))

ventana.mainloop()

3. Procesamiento de datos en lote

from functools import partial

def procesar_archivo(formato, nombre_archivo):
    print(f"Procesando {nombre_archivo} como {formato}")
    # Lógica de procesamiento...
    return f"{nombre_archivo} procesado"

# Creamos procesadores específicos
procesar_csv = partial(procesar_archivo, "CSV")
procesar_json = partial(procesar_archivo, "JSON")

archivos_csv = ["datos1.csv", "datos2.csv", "datos3.csv"]
archivos_json = ["config1.json", "config2.json"]

# Procesamos cada tipo de archivo
resultados_csv = list(map(procesar_csv, archivos_csv))
resultados_json = list(map(procesar_json, archivos_json))

4. Configuración de conexiones a bases de datos

import sqlite3
from functools import partial

def conectar_db(nombre_db, timeout=30, check_same_thread=True):
    return sqlite3.connect(nombre_db, timeout=timeout, 
                          check_same_thread=check_same_thread)

# Conexión optimizada para entornos multithread
conectar_multithread = partial(conectar_db, check_same_thread=False, timeout=60)

# Uso
conexion = conectar_multithread("mi_aplicacion.db")

Consideraciones de rendimiento

Los objetos creados con partial() son ligeramente más eficientes que las funciones anidadas equivalentes, especialmente cuando se crean muchas instancias. Esto se debe a que partial() está implementado en C en la biblioteca estándar de Python.

from functools import partial
import timeit

# Usando partial
setup1 = "from functools import partial; def f(x, y): return x + y; g = partial(f, 1)"
tiempo1 = timeit.timeit("g(2)", setup=setup1, number=1000000)

# Usando función anidada
setup2 = "def f(x, y): return x + y; def g(y): return f(1, y)"
tiempo2 = timeit.timeit("g(2)", setup=setup2, number=1000000)

print(f"Tiempo con partial: {tiempo1:.6f} segundos")
print(f"Tiempo con función anidada: {tiempo2:.6f} segundos")

Limitaciones

Aunque partial() es una herramienta muy útil, tiene algunas limitaciones:

• No permite reordenar argumentos (solo fijar los primeros argumentos posicionales)
• No permite eliminar o hacer opcionales argumentos obligatorios
• No modifica la firma de la función (los IDEs y herramientas de documentación mostrarán la firma original)

Para casos más complejos donde estas limitaciones son importantes, puede ser necesario recurrir a técnicas más avanzadas como la currificación, que veremos en la siguiente sección.

Currificación en Python

La currificación es una técnica de programación funcional estrechamente relacionada con la aplicación parcial, pero con un enfoque diferente y más sistemático. Mientras que la aplicación parcial nos permite fijar algunos argumentos de una función, la currificación transforma una función que toma múltiples argumentos en una secuencia de funciones que toman un solo argumento cada una.

El nombre "currificación" proviene del matemático Haskell Curry, quien formalizó esta técnica, aunque fue originalmente desarrollada por Moses Schönfinkel. En esencia, una función currificada no espera todos sus argumentos de una vez, sino que devuelve una nueva función por cada argumento que recibe.

Entendiendo la currificación

Para comprender mejor este concepto, veamos un ejemplo sencillo:

# Función normal con múltiples argumentos
def suma_normal(a, b, c):
    return a + b + c

# Versión currificada
def suma_currificada(a):
    def suma_b(b):
        def suma_c(c):
            return a + b + c
        return suma_c
    return suma_b

# Uso de la función normal
resultado1 = suma_normal(1, 2, 3)  # 6

# Uso de la función currificada
resultado2 = suma_currificada(1)(2)(3)  # 6

Observa cómo la función currificada se llama con un solo argumento a la vez, creando una cadena de llamadas de función. Cada llamada devuelve una nueva función que "recuerda" los argumentos anteriores mediante clausuras.

Diferencias entre currificación y aplicación parcial

Aunque relacionadas, la currificación y la aplicación parcial tienen diferencias importantes:

• La currificación transforma una función de n argumentos en n funciones de un argumento.
• La aplicación parcial crea una nueva función fijando algunos argumentos de la original.
• Una función currificada siempre toma exactamente un argumento por llamada.
• La aplicación parcial puede fijar cualquier número de argumentos a la vez.

Esta tabla ilustra las diferencias:

Implementación de currificación en Python

Python no tiene soporte nativo para currificación como algunos lenguajes funcionales (Haskell, por ejemplo), pero podemos implementarla de varias formas:

1. Implementación manual básica

def multiplicar(a):
    def por_b(b):
        def por_c(c):
            return a * b * c
        return por_c
    return por_b

# Uso
doble = multiplicar(2)
doble_de_tres = doble(3)
resultado = doble_de_tres(4)  # 2 * 3 * 4 = 24

# O en una sola línea
resultado = multiplicar(2)(3)(4)  # 24

2. Implementación con un decorador genérico

Podemos crear un decorador que automatice la currificación de cualquier función:

def currificar(func):
    def curried(*args):
        if len(args) >= func.__code__.co_argcount:
            return func(*args)
        return lambda *more_args: curried(*(args + more_args))
    return curried

# Aplicamos el decorador a una función normal
@currificar
def sumar_tres(a, b, c):
    return a + b + c

# Ahora podemos usar la función de forma currificada
resultado1 = sumar_tres(1)(2)(3)  # 6
resultado2 = sumar_tres(1, 2)(3)  # 6
resultado3 = sumar_tres(1)(2, 3)  # 6
resultado4 = sumar_tres(1, 2, 3)  # 6

Este decorador es más flexible, ya que permite llamar a la función currificada con cualquier combinación de argumentos, siempre que al final se proporcionen todos los necesarios.

Aplicaciones prácticas de la currificación

La currificación resulta útil en varios escenarios:

1. Creación de funciones especializadas

@currificar
def formatear(plantilla, nombre, valor):
    return plantilla.format(nombre=nombre, valor=valor)

# Creamos una función para mensajes de error
formato_error = formatear("ERROR: {nombre} - {valor}")

# Usamos la función especializada
mensaje1 = formato_error("Conexión fallida")("404")
mensaje2 = formato_error("Archivo no encontrado")("missing.txt")

print(mensaje1)  # ERROR: Conexión fallida - 404
print(mensaje2)  # ERROR: Archivo no encontrado - missing.txt

2. Composición de funciones

La currificación facilita la composición de funciones, permitiendo crear pipelines de procesamiento:

@currificar
def aplicar_formato(formato, valor):
    return formato(valor)

@currificar
def filtrar(condicion, lista):
    return [x for x in lista if condicion(x)]

# Funciones de transformación
mayusculas = lambda s: s.upper()
es_largo = lambda s: len(s) > 5

# Componemos funciones currificadas
procesar = aplicar_formato(mayusculas)
filtrar_largos = filtrar(es_largo)

# Aplicamos el pipeline
nombres = ["Ana", "Roberto", "Juan", "Elisabeth"]
resultado = procesar(filtrar_largos(nombres))
print(resultado)  # ['ROBERTO', 'ELISABETH']

3. Configuración progresiva

La currificación permite configurar funciones en etapas, lo que resulta útil en entornos donde la información está disponible en diferentes momentos:

@currificar
def conectar_db(driver, host, usuario, contraseña, base_datos):
    # Simulamos una conexión a base de datos
    conexion = f"Conectado a {base_datos} en {host} usando {driver}"
    return conexion

# Configuración por etapas
config_mysql = conectar_db("mysql")
config_servidor = config_mysql("localhost")
config_credenciales = config_servidor("admin")("secreto")

# Más tarde, cuando sabemos qué base de datos usar
conexion_usuarios = config_credenciales("usuarios")
conexion_productos = config_credenciales("productos")

print(conexion_usuarios)  # Conectado a usuarios en localhost usando mysql

Currificación vs. functools.partial

Aunque functools.partial y la currificación pueden lograr resultados similares, tienen enfoques diferentes:

from functools import partial

# Con partial (aplicación parcial)
def sumar(a, b, c):
    return a + b + c

sumar_con_1 = partial(sumar, 1)
sumar_con_1_y_2 = partial(sumar_con_1, 2)
resultado_partial = sumar_con_1_y_2(3)  # 6

# Con currificación
@currificar
def sumar_curry(a, b, c):
    return a + b + c

resultado_curry = sumar_curry(1)(2)(3)  # 6

La elección entre currificación y aplicación parcial depende del contexto:

• Usa aplicación parcial (partial) cuando necesites fijar algunos argumentos específicos y mantener una interfaz similar a la original.
• Usa currificación cuando quieras descomponer una función en pasos secuenciales o crear pipelines de procesamiento.

Implementación avanzada con inspección

Una implementación más robusta de currificación puede utilizar la inspección para manejar argumentos con nombre:

import inspect

def curry_avanzado(func):
    sig = inspect.signature(func)
    num_params = len(sig.parameters)
    
    def curried(*args, **kwargs):
        if len(args) + len(kwargs) >= num_params:
            return func(*args, **kwargs)
        
        def inner(*more_args, **more_kwargs):
            combined_args = args + more_args
            combined_kwargs = {**kwargs, **more_kwargs}
            return curried(*combined_args, **combined_kwargs)
        
        return inner
    
    return curried

@curry_avanzado
def configurar(host, puerto, usuario, timeout=30):
    return f"Conexión a {host}:{puerto} como {usuario} (timeout: {timeout}s)"

# Podemos usar argumentos posicionales o con nombre en cualquier orden
config1 = configurar("localhost")(8080)("admin")
config2 = configurar("localhost", puerto=8080)(usuario="admin")
config3 = configurar(timeout=60)("localhost", 8080, "admin")

print(config1)  # Conexión a localhost:8080 como admin (timeout: 30s)
print(config3)  # Conexión a localhost:8080 como admin (timeout: 60s)

Consideraciones prácticas

Al trabajar con currificación en Python, ten en cuenta estas recomendaciones:

• Legibilidad: La currificación puede hacer que el código sea más difícil de leer para desarrolladores no familiarizados con programación funcional.
• Documentación: Documenta claramente las funciones currificadas para facilitar su uso.
• Rendimiento: Las implementaciones manuales de currificación pueden tener un pequeño impacto en el rendimiento debido a las múltiples llamadas a funciones.
• Compatibilidad: Las funciones currificadas pueden ser menos compatibles con APIs que esperan funciones tradicionales.

Ejemplo práctico: Procesamiento de datos

Un caso de uso común para la currificación es el procesamiento de datos en etapas:

@currificar
def transformar_datos(transformacion, filtro, datos):
    return [transformacion(x) for x in datos if filtro(x)]

# Definimos transformaciones y filtros
a_fahrenheit = lambda c: c * 9/5 + 32
es_positivo = lambda x: x > 0
es_par = lambda x: x % 2 == 0

# Creamos funciones especializadas
convertir_positivos = transformar_datos(a_fahrenheit)(es_positivo)
convertir_pares = transformar_datos(a_fahrenheit)(es_par)

# Aplicamos a diferentes conjuntos de datos
temperaturas = [-5, 0, 10, 20, 15, 25]
print(convertir_positivos(temperaturas))  # [50.0, 68.0, 59.0, 77.0]
print(convertir_pares(temperaturas))      # [32.0, 50.0, 68.0]

La currificación nos permite crear pipelines de procesamiento flexibles y reutilizables, facilitando la composición de operaciones complejas a partir de funciones simples.