() translation by (you can also view the original English article)
La mayoría de las tareas complejas en Python se pueden dividir en subtareas más simples. La recursividad ayuda a lograr esto, por lo tanto, hace que el código sea limpio y ordenado. Este tutorial presentará la recursividad, los beneficios de la recursividad y cómo usarla en la programación en Python.
¿Qué es la recursividad?
La recursividad es un método para resolver un problema con las soluciones a instancias más pequeñas del mismo problema. Este enfoque se puede aplicar a muchos tipos de desafíos en la programación.
Los beneficios de usar la recursividad
Algunos de los beneficios de usar la recursividad son:
- La recursividad agrega simplicidad al escribir código, lo que facilita la depuración.
- La recursividad reduce la cantidad de tiempo que tarda un algoritmo en ejecutarse en función de la longitud de la entrada.
- La recursividad también se prefiere cuando se resuelven problemas muy complejos, especialmente problemas en estructuras basadas en árboles, porque funciona mejor.
Introducción a la función recursiva en Python
Aunque la recursividad parece un procedimiento complicado, no es tan complicado. En términos sencillos, supón que tienes dos rectángulos A y B. Si los juntamos, forman un rectángulo C. Este es en sí mismo un procedimiento recursivo. Hemos usado instancias más pequeñas de un rectángulo para definirse a sí mismo, y si tuviéramos que escribir una función en Python, sería como sigue:
1 |
def rectangle(a,b): |
2 |
return a+b |
3 |
Dado que una función recursiva se llama a sí misma, es necesario que haya una regla o un punto de interrupción en el que terminaría el proceso o bucle. Esta condición se conoce como caso base. Un caso base es un requisito en todo programa recursivo; de lo contrario, el procedimiento resultaría en un bucle infinito.
El segundo requisito es el caso recursivo cuando la función se llama a sí misma.
Veamos un ejemplo:
En este ejemplo, escribirás una función factorial que toma un número entero (positivo) como entrada. El factorial de un número se obtiene multiplicando el número por todos los enteros positivos inferiores. Por ejemplo, factorial(3) = 3 x 2 x 1, factorial(2) = 2 x 1 y factorial(0) = 1.
Lo primero que debemos hacer es definir nuestro caso base, que será factorial(0) = 1.
Como puedes ver arriba, existe una relación entre cada escenario de factorial consecutivo. Debes notar que factorial(4) = 4 x factorial(3). Del mismo modo, factorial(5) = 5 x factorial(4).
La segunda parte escribirá una función que se llame a sí misma.
Ahora que lo hemos simplificado, la función resultante será:
1 |
def factorial(n): |
2 |
if(n == 0): |
3 |
#Define our base case?
|
4 |
return 1 |
5 |
else: |
6 |
return n*factorial(n-1) |
7 |
|
8 |
print(factorial(5)) |
9 |
|
10 |
#result
|
11 |
|
12 |
# 120
|
La solución si n==0 es:
1 |
def factorial(n): |
2 |
if(n == 0): |
3 |
#Define our base case?
|
4 |
return 1 |
5 |
else: |
6 |
return n*factorial(n-1) |
7 |
|
8 |
print(factorial(0)) |
9 |
|
10 |
#result
|
11 |
|
12 |
# 0
|
Ahora que sabes cómo escribir funciones recursivas, veamos varios casos de estudio que solidificarán tu comprensión de la recursividad.
Caso de estudio 1: Fibonacci
En una secuencia de Fibonacci, cada número es la suma de los dos números anteriores, como: 1 + 1 = 2; 1 + 2 = 3; 2 + 3 = 5; 3 + 5 = 8. La secuencia de Fibonacci se ha aplicado en muchas áreas, y la más común es en la predicción del precio de una acción en el mercado de valores por parte de los operadores de forex.
La secuencia de Fibonacci comienza con 0 y 1. El primer número en una secuencia de Fibonacci es 0, el segundo número es 1 y el tercer término en la secuencia es 0 + 1 = 1. El cuarto es 1 + 1 = 2 y así sucesivamente .
Para crear una función recursiva, debes tener dos casos base, es decir, 0 y 1. Luego puedes traducir el patrón de adición al caso else.
La función resultante será:
1 |
def fibonacci(n): |
2 |
if(n == 1): |
3 |
#define Base case 1
|
4 |
return 0+1 |
5 |
elif(n == 2): |
6 |
#define Base case 1
|
7 |
return 1+2 |
8 |
else: |
9 |
return fibonacci(n) + fibonacci(n-1) |
10 |
|
11 |
print(fibonacci(5)) |
12 |
|
13 |
#result
|
14 |
|
15 |
#
|
Caso de estudio 2: Invertir un string
En este ejemplo, escribirás una función que toma un string como entrada y luego devuelve el reverso del string.
Lo primero que debemos hacer es definir nuestro caso base, que verificará si la longitud del string es igual a 0 y, de ser así, devolverá el string en sí.
El segundo paso es llamar de forma recursiva a la función reverse para cortar la parte del string que excluye el primer carácter y luego concatenar el primer carácter al final del string cortado.
La función resultante es la que se muestra a continuación:
1 |
def reverse(a): |
2 |
|
3 |
if len(a) == 0: |
4 |
return a |
5 |
else: |
6 |
return reverse(a[1:]) + a[0] |
7 |
|
8 |
print(reverse("Python is a very easy language to learn")) |
9 |
|
10 |
# result
|
11 |
|
12 |
#nrael ot egaugnal ysae yrev a si nohtyP
|
13 |
|
14 |
Caso de estudio 3: Suma de elementos
En este ejemplo, escribirás una función que toma un array como entrada y luego devuelve la suma de los elementos de la lista.
Lo primero que debemos hacer es definir nuestro caso base, que verificará si el tamaño de la lista es cero y devolverá 0 si es True.
El segundo paso devuelve el elemento y una llamada a la función sum() menos un elemento de la lista.
La solución es como se muestra a continuación:
1 |
def sum_of_numbers(l): |
2 |
if len(l) == 1: |
3 |
return 0 |
4 |
else: |
5 |
return l[0] + sum(l[1:]) |
6 |
|
7 |
a =[5,7,3,8,10] |
8 |
|
9 |
print(sum(a)) |
10 |
|
11 |
# result
|
12 |
# 33
|
La solución para una lista vacía es la que se muestra a continuación:
1 |
def sum_of_numbers(l): |
2 |
if len(l) == 1: |
3 |
return 0 |
4 |
else: |
5 |
return l[0] + sum(l[1:]) |
6 |
|
7 |
|
8 |
b =[] |
9 |
|
10 |
print(sum(b)) |
11 |
|
12 |
# result
|
13 |
|
14 |
# 0
|
Conclusión
Este tutorial ha cubierto lo que es necesario para usar la recursividad para resolver programas complejos en Python. También es importante tener en cuenta que la recursividad tiene sus propias limitaciones:
- La recursividad ocupa mucho espacio en la pila, por lo que el mantenimiento del programa es un poco lento.
- Las funciones recursivas requieren más espacio y tiempo para ejecutarse.
Recuerda, no dudes en ver lo que tenemos disponible para la venta y para estudiar en el Envato Market, y por favor haz cualquier pregunta y brinda tus valiosos comentarios en los comentarios de abajo.
