No es como tal necesario. Es más para indicar que las funcionalidades pueden ir antes o después. Por ejemplo, si quieres cronometrar lo que tarda la función, harías un time_start encima y luego calcularías la diferencia con ese time_start previo. U otro ejemplo, si quisieras hacer alguna validación o cambio a algún input que le vas a pasar a la función. Es decir, no todas las funcionalidades tienen por qué ir detrás de la función!

Espero habértelo aclarado mejor. De cualquier manera como tú dices, si no el viernes puedes preguntar a Rubén dudas para aclararlo mejor en directo.

Gracias por la explicacion

El ejemplo de intereses compuesto hace referencia a otro ejemplo, calculo de los  ingresos de un equipo

En este caso el decorador añadiría tanto el print de antes como el de después.

De envoltura no se puede prescindir si se quiere utilizar como decorador, es decir, poder hacer decorador(funcion) ya que es el espacio que mantiene “en memoria” esa “func”, para cada una de esas funciones por lo que comentábamos del scope.

El retorno es una función. Se puede definir como saludar, para que ahora al llamar a saludar se sobreescriba con esta nueva función o por ejemplo como nuevo_saludo y así saludar sería la función original y nuevo saludo la función con ambos prints.

En este ejemplo en concreto aún no se habría “decorado” la función. Para ello habría que poner encima del def saludar, el @mi_envoltura. Sin embargo, por debajo un decorador simplificadamente lo que hace es lo que vemos ahí de saludar = mi_decorador(saludar)

Entonces en este caso, la modificacion que se hace a la funcion es añadir el print “despues de ejecutar..”

¿ por que existe envoltura? ¿se podria prescindir de ella?

¿para que se asigna el retorno de mi_decorator a la variable saludar?

En la llamada a la funcion saludar() se esta llamando a la funcion ya decorada?

La clave con la recursión (igual que con los bucles y otras estructuras de control) es ir navegando mentalmente por el flujo planteándote la decisión a tomar en cada caso.

Yendo al ejemplo del cálculo del factorial, sabemos que el factorial de un número (denotado “n!”) representa el resultado de multiplicar todos los números enteros desde el 1 hasta n. Por ejemplo 4! es 1·2·3·4=24.

Esta operación puede programarse con un bucle for sencillo mediante el siguiente código:

def factorial(n):
result = 1
for i in range(1, n + 1):
result *= i
return result

Esta función lo que hace es inicializar nuestro resultado con un valor de 1, y posteriormente iterar desde que i=1 hasta que i=n (recordemos que usamos n+1 porque el número del final no está incluido en range) multiplicando el acumulado por “i”. De esta forma, en la primera iteración multiplicamos result (que vale 1) por 1. En la segunda, result vale 1 y lo multiplicamos por 2, en la tercera, vale 2 y lo multiplicamos por tres, y así sucesivamente.

Ahora bien, esta misma operación se puede realizar de forma recursiva como se plantea en el video:

def factorial(n):
if n == 0 or n == 1:
return 1
else:
return n * factorial(n – 1)

Vamos a ir paso a paso sobre el código.

En primer lugar cuando hablamos de recursividad, siempre hay dos escenarios. Hay un escenario lo suficientemente sencillo como para poder dar una respuesta inmediata que pone fin a la recursividad. Encontrar este escenario lo primero siempre es clave para plantear correctamente la relación recursiva. En este caso, el número más sencillo para el que podemos calcular el factorial es el 1, ya que 1!=1 por la propia definición del cálculo. Se ha añadido también el caso 0!=1, que es así por convención matemática, pero podemos obviarlo por simplicidad y quedarnos sólo con que 1!=1.

Ahora ya tenemos nuestro caso base para el que sabemos dar una respuesta inmediata. Si llamamos a nuestra función “factorial” y vemos que n=1, inmediatamente devolver un 1 como resultado, lo que explica la primera parte de la función.

Ahora bien, en toda función recursiva hay una segunda parte, que es la gestión de los casos más “complejos” que no podemos responder inmediatamente. El punto clave a entender aquí es que tenemos que descomponer esta relación en una operación que se acerque más a nuestro caso base que sí sabemos responder, es decir, simplificar la operación.

En el caso del factorial, ya sabemos que 1! = 1, porque ya tenemos el caso base definido, pero no sabemos por ejemplo cuánto es 2! porque no se corresponde con el caso base. Ahora bien, por la definición de factorial, podemos expresar 2! en función del caso base si decimos que 2!=2·1!. Con este simple cambio, ya podemos dar una respuesta final, ya que nuestra función sabe cómo multiplicar algo por 2 y también sabe que 1!=1. Sólo tenemos que multiplicar 2 por el caso base, con lo que el resultado sería 2.

Ahora bien, ¿cómo hago si me piden el valor de 3!? Puedo llevar la lógica más allá y deducir que 3! = 3·2!, pero tampoco sé cuánto es 2!, por lo que puedo avanzar un paso más y decir que 3!=3·(2·1!), ya que 2!=2·1!. De nuevo hemos llegado al caso base, por lo que ahora sólo tenemos que sustituir 1! por su valor (que sabemos que es 1) e ir multiplicando hacia atrás. Esto es precisamente lo que hace la línea “n * factorial(n – 1)”, descomponiendo el factorial de n como n·(n-1)! hasta que llegamos al caso base y luego simplemente tenemos que multiplicar hacia atrás.

Espero que con esta explicación quede mucho más claro el concepto de recursión. El resto de aplicaciones son ejemplos de esta misma lógica con ligeras modificaciones. Si tienes cualquier duda adicional, quedamos a tu disposición.

Por otro lado, no quería que el otro mensaje se hiciera muy largo, así que te explico aquí el uso de *args.

*args utiliza el asterisco *, que en Python sirve para “desempaquetar” o “expandir” una tupla o lista en sus elementos individuales cuando se recibe como input. Por ejemplo, si escribes:

a, *b = (1, 2, 3)

Entonces a valdrá 1 y b valdrá [2, 3] (Sí, se devuelve como una lista. Esto es porque se trata como un nuevo objeto y se prefiere que sea mutable.)

Este mismo concepto se puede aplicar a:

• variables que devuelve una función
• o como hemos visto, en *args, para desempaquetar varios elementos posicionales.

Diferencia entre *args y **kwargs:

• *args recoge los argumentos posicionales que no hemos definido explícitamente. Son los “posicionales extra”.
• **kwargs recoge los argumentos con nombre (clave=valor) que no se han definido previamente. Son los “nombrados extra”.

El ejemplo:

def calcular_prestamo(*capitales, tasa=0.05, tiempo=1):
“””Calcula el interés simple para múltiples capitales.”””
intereses = [capital * tasa * tiempo for capital in capitales]
return sum(intereses)

total_interes = calcular_prestamo(1000, 2000, 3000, 4000, tasa=0.04, tiempo=2)
print(f”El interés total es: ${total_interes:.2f}”)

• Los valores 1000, 2000, 3000, 4000 se recogen dentro de capitales, que es *args (posicionales). Esto funciona igual que el ejemplo anterior con *b.
  En este caso, capitales es una tupla siempre, porque así lo define Python internamente para agrupar los argumentos posicionales extra.
• tasa=0.04 y tiempo=2 se recogen directamente como argumentos con nombre (es decir, usando clave=valor), ya que están definidos como parámetros con valor por defecto.

Este tema también es algo denso, haces muy bien en preguntar!

Efectivamente, el tema de los decoradores en Python es algo más avanzado. Lo importante por ahora es que entiendas el concepto general, más que saber implementarlos desde cero. En la práctica, lo más común es usar decoradores ya existentes, no crearlos.

Un decorador es simplemente una función que añade funcionalidad a otra función, “por encima”. Esto es posible gracias al sistema de scopes de Python (visto en la clase sobre Scope, Shadowing, Args y Kwargs).

Para resumir: en Python las variables existen en “capas” o niveles de funciones. Por ejemplo, si ejecutamos una función desde el código principal, tenemos dos capas: la global (fuera de la función) y la local (dentro). Python permite usar variables de una capa externa dentro de una función interna, lo que hace posible cosas como los decoradores.

Volviendo a los decoradores: en este caso hablamos de tres scopes:

1. El global (fuera de todo)
2. El del decorador (función intermedia)
3. El local (la función interna que se ejecuta).

El decorador aprovecha que puede usar variables definidas en el scope intermedio dentro de la función interna, en este caso la función que se le pasa de input.

Además, los decoradores se caracterizan por:

• Recibir una función como parámetro (input), que se utiliza dentro de la función interna
• Devolver una nueva función (la interna) que hace algo extra antes, después (o ambos) de ejecutar la original.

Ejemplo:

def mi_decorator(func):
def envoltura(*args, **kwargs):
print(“Antes de ejecutar la función”)
resultado = func(*args, **kwargs)
print(“Después de ejecutar la función”)
return resultado
return envoltura

# Aplicación manual del decorator
def saludar():
print(“Hola, mundo!”)

saludar = mi_decorator(saludar)

saludar()

Esto imprime:

Antes de ejecutar la función
Hola, mundo!
Después de ejecutar la función

Aquí:

1. El decorador guarda la función original saludar c0n
2. Luego la reemplaza por otra función (al poner saludar = mi_decorador) que, al ejecutarse, hace más cosas (imprime antes y después lo que hemos visto arriba).

Como extra, en este ejemplo usamos *args y **kwargs. Esto es para que el decorador funcione con cualquier tipo de argumentos, sin importar qué parámetros tiene la función original.

Por ejemplo, si saludar necesitara un argumento:

def saludar(nombre):
print(f”Hola, {nombre}!”)

Entonces es necesario que el decorador acepte *args y/o **kwargs (o el nombre en específico, pero solo valdría para esa función), si no, fallaría al llamar a la función.

Te animo a hacer pruebas por tu cuenta, cambiando funciones y decoradores para ver cómo reaccionan que siempre se entiende mejor!

Es un tema denso y complejo, pero espero habértelo aclarado un poco más.