Programación funcional

Según la RAE, un paradigma es:

• Ejemplo o ejemplar.
• Teoría o conjunto de teorías cuyo núcleo central se acepta sin cuestionar y que suministra la base y modelo para resolver problemas y avanzar en el conocimiento (p. ej., el paradigma newtoniano). Es la acepción más próxima al software.
• Relación de elementos que comparten un mismo contexto fonológico, morfológico o sintáctico.
• Esquema formal en el que se organizan las palabras que admiten modificaciones flexivas o derivativas.

Ninguna habla de software, pero todas comparten la idea de un conjunto de entidades con una base común que sirve como modelo de clasificación.

El concepto surge en 1978 para clasificar los estilos de programación, ofreciendo conceptos y abstracciones (funciones, variables, objetos, flujos de datos…) que permiten abstraerse de la arquitectura básica del sistema.

• Un lenguaje no tiene por qué cumplir un solo paradigma: la mayoría de lenguajes modernos son multiparadigma.
• Todos los paradigmas buscan la modularidad para mejorar eficiencia y costes de mantenimiento. La modularización también limita el alcance del software en el equipo donde se ejecuta, lo que aporta seguridad.
• Hoy se dividen en dos grandes bloques: imperativo y declarativo.

El paradigma más antiguo. Viene de imperare (ordenar): consiste en dar órdenes concretas para que el equipo las procese y ejecute.

• Se define paso a paso cómo obtener el resultado con instrucciones bien definidas.
• Las sentencias cambian el estado del programa (modifican sus datos).
• Se ejecutan de forma secuencial, lo que da un claro determinismo en la salida.

Suelen ser lenguajes cercanos al sistema: obligan a gestionar memoria, datos a nivel de bit o incluso registros de CPU, lo que supone muchas líneas de código para tareas que en otros paradigmas son mucho más cortas.

• C/C++
• Java
• Pascal
• Cobol
• FORTRAN
• C#
• Python

Dentro del imperativo están la programación estructurada, la procedimental y la orientada a objetos.

Programación estructurada

Busca mejorar la claridad, la calidad y el tiempo de desarrollo usando únicamente subrutinas y funciones. Surge en 1966 con el teorema de la programación estructurada.

Antes era habitual la instrucción GoTo (similar a JUMP en ensamblador MIPS): se define una etiqueta o línea y el programa salta a ese punto. Parece útil para reutilizar código, pero es muy poco eficiente en mantenibilidad y legibilidad (el famoso spaghetti code).

Programación procedimental

Deriva directamente de la estructurada y se basa en la llamada a procedimientos. Un procedimiento (coloquialmente, «función») es una subrutina con una serie de pasos que puede llamarse en cualquier momento: más reutilización, menos tiempo de desarrollo y programas más cortos y legibles.

Es tan relevante que los procesadores añaden soporte hardware: registro de pila e instrucciones de llamada que guardan el punto de retorno casi sin penalización.

Programación orientada a objetos

Organiza el software en torno a datos u objetos en lugar de funciones y lógica. Un objeto es un campo de datos con atributos y comportamientos propios. Encaja con programas grandes, complejos y en mantenimiento activo, y favorece el trabajo en equipo gracias a su alta modularización.

Al contrario que la imperativa, describe qué solución se quiere (condiciones, proposiciones, afirmaciones o transformaciones) sin indicar los pasos para obtenerla, lo que ayuda a evitar efectos secundarios. Normalmente se considera declarativo todo lo que no es imperativo.

En el imperativo se define todo el procedimiento a más bajo nivel, pudiendo afectar a los datos. En el declarativo se describe el resultado y es el lenguaje, framework o librería quien lo produce.

Ejemplo ilustrativo (el material lo muestra en JavaScript con imágenes no disponibles; aquí en Python): obtener los cuadrados de los números pares.

numeros = [1, 2, 3, 4, 5, 6]
cuadrados_pares = []
for n in numeros:              # cómo: recorrer...
    if n % 2 == 0:             # ...comprobar...
        cuadrados_pares.append(n * n)   # ...y modificar el estado
print(cuadrados_pares)         # [4, 16, 36]

numeros = [1, 2, 3, 4, 5, 6]
cuadrados_pares = [n * n for n in numeros if n % 2 == 0]   # qué quiero
print(cuadrados_pares)         # [4, 16, 36]

Características del modelo

• Alto nivel de abstracción: programas complejos expresados de forma compacta.
• Optimización sin tocar el algoritmo: basta con sustituir los procedimientos a los que se accede (p. ej., un método de ordenación más rápido).
• Desarrollo muy rápido: ideal para prototipado en metodologías ágiles.

Lenguajes únicamente declarativos:

• HTML/CSS
• SQL
• Haskell
• Prolog

Solo describen el resultado; una implementación ajena hace el trabajo. En una consulta SQL se indica qué obtener o insertar y el motor se encarga del proceso; en HTML se describen elementos y aspecto, no el pintado de píxeles.

SELECT nombre FROM alumnos WHERE nota >= 5;   -- qué datos quiero, no cómo buscarlos

Programación funcional

Deriva de la procedimental y trabaja directamente con funciones, tratándolas como cualquier otra entidad del lenguaje. Se desarrolla en el bloque 3.

Programación reactiva

Trabaja con flujos de datos asíncronos: los datos se propagan y los módulos «reaccionan» ejecutando eventos al recibirlos.

En un enfoque imperativo, la CPU comprueba continuamente si han llegado datos (polling):

while(!exit){
    if(checkDataReceive()){
        receiveData();
    }
}

La reactiva se basa en el patrón Observer: los nuevos datos se notifican directamente a los interesados en lugar de que estos pregunten, invirtiendo el diseño tradicional de entrada/salida. La CPU solo trabaja cuando un módulo recibe una notificación.

Los sistemas reactivos son:

La mayoría de lenguajes modernos implementan más de un paradigma, lo que permite elegir o combinar según el proyecto. La elección depende menos del lenguaje y más de las decisiones de diseño de la arquitectura.

Comparativa de paradigmas

Ejemplo: sistema de comercio electrónico

Tendencias futuras

Crecen los lenguajes y entornos multiparadigma, porque la complejidad actual exige soluciones flexibles:

• Más programación funcional en lenguajes imperativos (Java, Python, C#), impulsada por el paralelismo y la reactividad.
• Orientación a datos y flujos: arquitecturas reactivas y sistemas distribuidos favorecen lo declarativo y lo funcional.
• Herramientas inteligentes y generación de código: paradigmas que se adaptan al problema, combinando instrucciones imperativas con descripciones declarativas optimizadas por IA.
• Mantenibilidad y escalabilidad: la modularidad y la reducción de efectos secundarios serán cada vez más valoradas.

Python es multiparadigma e interpretado: no se compila a código máquina, sino que un programa instalado en el equipo (el intérprete) lee las instrucciones y las traduce en tiempo real.

Hay muchas versiones de Python y de sus librerías y cada proyecto arrastra muchas dependencias, así que hace falta compartimentar los paquetes: los entornos virtuales.

1. Instala el intérprete de Python desde su web o repositorio oficial. Vale cualquier versión ≥ 3.9. Durante la instalación, incluye las librerías tcl/tk.
2. Instala Visual Studio Code con las extensiones Python y Jupyter.
3. En Windows 10/11, permite la ejecución de scripts de PowerShell (vienen bloqueados si no están firmados). Abre PowerShell como administrador:

Set-ExecutionPolicy -ExecutionPolicy Unrestricted -Scope CurrentUser

Se asume Windows, pero puede usarse cualquier sistema operativo.

Tener muchos paquetes en el mismo intérprete genera conflictos de versiones.

Un entorno virtual es un entorno aislado por proyecto: sus dependencias no interfieren con las de otros. La herramienta habitual es venv; la mayoría de gestores (Anaconda, Miniforge) dependen de ella.

Creación

python -m venv nombre_del_entorno

Crea un directorio con ese nombre que contiene una copia aislada de la instalación de Python.

Activación

nombre_del_entorno\Scripts\activate

nombre_del_entorno\Scripts\Activate.ps1

source nombre_del_entorno/bin/activate

Ejemplo completo

Crear y activar un entorno llamado venv e instalar requests:

python -m venv venv
source venv/Scripts/Activate.ps1
pip install requests

El paquete se instala solo en el entorno virtual, no en la instalación global. Al ejecutar un script en VS Code, este te preguntará qué entorno usar.

Se basa en la evaluación de funciones puras y la inmutabilidad de los datos, inspirándose en la matemática funcional.

Ejemplo ilustrativo (no incluido en el material):

contador = 0

def impura(x):
    global contador
    contador += 1          # efecto secundario: modifica estado externo
    return x + contador    # el resultado depende de algo más que x

def pura(x):
    return x + 1           # mismo x → mismo resultado, siempre

Como todo consiste en evaluar funciones, hay mucha recursividad y llamadas anidadas, sin modificar datos como en el imperativo.

Ventajas

• Alto nivel: se describe el resultado, no los pasos. Sentencias simples con mucha carga computacional.
• Transparencia: una función pura solo depende de sus entradas; sin efectos secundarios, depurar y mantener es más fácil.
• Paralelización: sin efectos secundarios ni dependencias externas, las rutinas se ejecutan concurrentemente con facilidad.

Casi todos los lenguajes admiten algo de programación funcional; en otros prácticamente todo el código es funcional (Haskell, Clojure…).

Programación funcional en Python

Para soportar el paradigma, las funciones deben poder:

1. Recibir una función como argumento.
2. Devolver una función a quien la llamó.

En Python todo es un objeto, incluidas las funciones (un objeto con un atributo que indica que puede invocarse). Por eso se tratan como cualquier otra variable:

def func():
	print("I am function func()!")

func()
another_name = func      # alias: sin paréntesis, no se ejecuta
another_name()
print(another_name)

I am function func()!
I am function func()!
<function func at 0x0000019425632CA0>

print("cat", func, 42)     # se imprime como cualquier valor

objects = ["cat", func, 42]
myfunc = objects[1]        # se accede como a cualquier elemento
myfunc()
objects[1]()               # o se invoca directamente

d = {"cat": 1, func: 2, 42: 3}   # la función como clave
print(d[func])                   # 2

def inner():
	print("I am function inner()!")

def outer(function):
	function()

outer(inner)

Ejemplo: sorted y el argumento key

sorted devuelve una nueva lista ordenada:

animals = ["ferret", "vole", "dog", "gecko"]
print(sorted(animals))

['dog', 'ferret', 'gecko', 'vole']

Parece alfabético, pero compara los valores ASCII de los caracteres. Si una palabra empieza en mayúscula, su valor es menor que el de cualquier minúscula y el orden deja de ser el esperado.

El argumento key recibe una función (un callback) que se aplica a cada elemento; su resultado es el criterio de orden:

print(sorted(animals, key=len))
print(sorted(animals, key=len, reverse=True))   # descendente

['dog', 'vole', 'gecko', 'ferret']
['ferret', 'gecko', 'vole', 'dog']

animals = ["ferret", "vole", "dog", "gecko"]
sorted_animals = sorted(animals, key=...)  # completar
print(sorted_animals)

def reverse_len(s):
	return -len(s)

animals = ["ferret", "vole", "dog", "gecko"]
print(sorted(animals, key=reverse_len))

['ferret', 'gecko', 'vole', 'dog']

Devolver una función

def outer():
	def inner():
		print("I am function inner()!")
	# Function outer() returns function inner()
	return inner

function = outer()
function        # referencia a inner, no la ejecuta
function()
outer()()

• Se pueden definir funciones dentro de otras: inner solo existe en el contexto de outer.
• Al devolver inner y guardarla en function, sigue siendo accesible.
• outer()(): el primer () ejecuta outer, que devuelve inner; el segundo ejecuta inner.

Pasar una función vs. pasar su resultado

No es lo mismo. En C, printText(helloText()) no es programación funcional: primero se ejecuta helloText y lo que se pasa es su resultado.

void printText(char* text){
	printf("%s\n", text);
}
char* helloText(){
	return "Hello World!";
}
int main(){
	printText(helloText());
	return 0;
}

int main(){
	char* mText = helloText();   // se ejecuta primero...
	printText(mText);            // ...y se pasa el resultado
	return 0;
}

def perro(edad):
    return edad * 7

def gato(edad):
    return edad * 5

def pez(edad):
    return edad * 12

def edad_de_mi_mascota(edad, conversor):
    return conversor(edad)          # conversor es el callback

print(edad_de_mi_mascota(3, perro))
print(edad_de_mi_mascota(3, gato))
print(edad_de_mi_mascota(3, pez))

21
15
36

Ejercicio guiado: callbacks con requests y la API de OMDB

Objetivo: buscar películas con la API de OMDB (omdbapi.com), una API gratuita con datos de IMDB accesible por HTTP.

1. En la web, entra en la sección API Key.
2. Regístrate (puedes usar el correo de U-tad) indicando uso educativo.
3. Activa la clave desde el email recibido.

Llamada de prueba (el parámetro s indica búsqueda). Devuelve un JSON con todos los resultados:

http://www.omdbapi.com/?apikey=<API_KEY>&s=interstellar

Uso de requests, con el entorno virtual activado:

pip install requests

from requests import get

response = get("http://www.omdbapi.com/?apikey=API_KEY&s=interstellar")
print(response.text)

if response.status_code == 200:
    ...
else:
    ...

Para leer los datos como diccionario:

import json
data_dict = json.loads(response.content)
print(data_dict["Search"][0])

# o directamente con el método de la respuesta
print(response.json()["Search"][0])

def make_get_request(url, on_success, on_error):
    ...

pip install Pillow

from PIL import Image
from io import BytesIO

img = Image.open(BytesIO(image_bytes))

import json
from io import BytesIO
from urllib.parse import quote

from PIL import Image
from requests import get

API_KEY = "TU_API_KEY"


def make_get_request(url, on_success, on_error):
    """Hace la petición GET y delega el resultado en los callbacks."""
    response = get(url)
    if response.status_code == 200:
        on_success(response.content)
    else:
        on_error(response.status_code)


def show_error(status_code):
    print(f"Error en la petición (HTTP {status_code})")


def success_get_poster_func(data):
    img = Image.open(BytesIO(data))
    img.save("poster.png")
    print("Póster guardado en poster.png")


def success_get_movie_func(data):
    movies = json.loads(data)
    # OMDB responde 200 aunque no encuentre nada: lo indica en "Response"
    if movies.get("Response") != "True":
        print("Error:", movies.get("Error"))
        return
    for movie in movies["Search"]:
        print(f'{movie["Title"]} – {movie["Year"]}: {movie["Poster"]}')
    poster_url = movies["Search"][0]["Poster"]
    if poster_url != "N/A":
        make_get_request(poster_url, success_get_poster_func, show_error)


if __name__ == "__main__":
    title = input("Título: ")
    url = f"http://www.omdbapi.com/?apikey={API_KEY}&s={quote(title)}"
    make_get_request(url, success_get_movie_func, show_error)

El estilo funcional usa muchas funciones cortas que a veces se llaman una sola vez. Para eso existen las funciones lambda: anónimas y definidas sobre la marcha, sin def.

lambda <parameter_list>: <expression>

lambda s: s[::-1]                    # invierte una cadena

callable(lambda s: s[::-1])          # True: también es un objeto invocable

reverse = lambda s: s[::-1]          # con alias...
reverse("I am a string")

def reverse(s):                      # ...equivale a
	return s[::-1]

(lambda s: s[::-1])("I am a string") # o se usa directamente

'gnirts a ma I'

Pueden recibir varios parámetros:

(lambda x1, x2, x3: (x1 + x2 + x3) / 3)(9, 6, 6)        # 7.0
(lambda x1, x2, x3: (x1 + x2 + x3) / 3)(1.4, 1.1, 0.5)  # 1.0

Función integrada que aplica una función a cada elemento de un iterable y devuelve un iterador con los resultados. Sustituye a un bucle for o while explícito.

map(<f>, <iterable>)

def reverse(s):
	return s[::-1]

animals = ["cat", "dog", "hedgehog", "gecko"]
iterator = map(reverse, animals)
print(iterator)

<map object at 0x...>

map no devuelve una lista, sino un iterador. Para obtener los valores:

for i in map(reverse, animals):
    print(i)

print(list(map(reverse, animals)))
# ['tac', 'god', 'gohegdeh', 'okceg']

list(map(lambda s: s[::-1], ["cat", "dog", "hedgehog", "gecko"]))

Ejemplo práctico con str.join

str.join concatena una lista de cadenas intercalando el separador, pero falla con números:

print("+".join(["cat", "dog", "hedgehog", "gecko"]))   # cat+dog+hedgehog+gecko
print("+".join([1, 2, 3, 4, 5]))

Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: sequence item 0: expected str instance, int found

Solución: convertir cada elemento a texto con map:

print("+".join(map(str, [1, 2, 3, 4, 5])))   # 1+2+3+4+5

map con varios iterables

map(<f>, <iterable₁>, <iterable₂>, ..., <iterableₙ>)

La función se aplica «en columnas», tomando un elemento de cada iterable. Debe tener tantos parámetros como iterables.

def f(a, b, c):
	return a + b + c

print(list(map(f, [1, 2, 3], [10, 20, 30], [100, 200, 300])))   # [111, 222, 333]

# 1. Triplicar
print(list(map(lambda x: x * 3, [1, 2, 3, 4])))      # [3, 6, 9, 12]

# 2. Imprimir: map es perezoso, hay que consumirlo para que se ejecute print
list(map(print, ["cat", "dog"]))

# 3. Mayúsculas / minúsculas y sin duplicados
letras = ["a", "B", "c"]
print(list(map(str.upper, letras)))                  # ['A', 'B', 'C']
print(list(map(str.lower, letras)))                  # ['a', 'b', 'c']
# dict.fromkeys conserva el orden y descarta repetidos
print("".join(dict.fromkeys(map(str.lower, "Mississippi"))))   # misp

Como map, aplica una función a cada elemento, pero la usa para seleccionar: la función devuelve un booleano y filter conserva los elementos cuyo resultado es True.

filter(<f>, <iterable>)

def greater_than_100(x):
	return x > 100

list(filter(greater_than_100, [1, 111, 2, 222, 3, 333]))   # [111, 222, 333]
list(filter(lambda x: x > 100, [1, 111, 2, 222, 3, 333]))  # igual, con lambda

# 1. Pares
print(list(filter(lambda n: n % 2 == 0, range(10))))   # [0, 2, 4, 6, 8]

# 2. Palabras en mayúsculas: str.isupper ya es una función que devuelve bool
palabras = ["cat", "Cat", "CAT", "dog", "Dog", "DOG", "emu", "Emu", "EMU"]
print(list(filter(str.isupper, palabras)))             # ['CAT', 'DOG', 'EMU']

Aplica una función a los elementos por pares, combinándolos hasta obtener un único resultado. No está en el núcleo de Python: se importa de functools (instalada por defecto).

from functools import reduce
reduce(<f>, <iterable>)

from functools import reduce

def f(x, y):
	return x + y

reduce(f, [1, 2, 3, 4, 5])   # 15

reduce no impone tipos, así que no se limita a la aritmética:

reduce(f, ["cat", "dog", "hedgehog", "gecko"])
# 'catdoghedgehoggecko'

lista = ["cat", "dog", "hedgehog", "gecko"]
spaced_list = map(lambda s: s + " ", lista)   # combinando map y reduce
reduce(f, spaced_list)
# 'cat dog hedgehog gecko '

from functools import reduce

def maximo(lista):
    # en cada paso se queda con el mayor de los dos
    return reduce(lambda a, b: a if a > b else b, lista)

print(maximo([3, 17, 4, 9]))   # 17