Angel Armando Martínez Blanco
Nada mejor que aprovechar la cuarentena para aprender en modo "turbo" :D
freddy molleda
X2
Sergio Noriega
X3
¿Qué es la recursividad en programación?
La recursividad es una técnica esencial en el campo de las ciencias de la computación, utilizada tanto a nivel algorítmico como programático. Su enfoque se basa en el principio de "divide y vencerás", donde un problema complejo se descompone en versiones más pequeñas y manejables del mismo problema. A nivel programático, se implementa haciendo que una función se llame a sí misma, lo cual es una poderosa herramienta para resolver tareas que se reducen a formas más simples de sí mismas, como veremos con el cálculo de factoriales.
¿Cómo se implementa la recursividad usando factoriales?
Para comprender mejor la recursividad, usaremos el cálculo de factoriales, un ejemplo clásico. El factorial de un número (n!) se define como el producto de todos los números enteros positivos menores o iguales a (n). La definición recursiva del factorial sería:
Así, para calcular el factorial de un número, descomponemos el problema en multiplicaciones de números sucesivamente menores, lo cual resulta en una estructura de llamada recursiva de funciones dentro de nuestro código.
¿Cómo se programa un factorial recursivo en Python?
Ahora veamos cómo implementar esta lógica en Python. Imagina que quieres crear una función que calcule el factorial de un número entero dado.
def factorial(n): """Calcula el factorial de n. n debe ser un entero positivo mayor que cero. Retorna n!.""" if n == 1: return 1 else: return n * factorial(n - 1) # Solicitamos al usuario un número y mostramos su factorial numero = int(input("Escribe un entero: ")) print(f"El factorial de {numero} es {factorial(numero)}")
En este código:
factorial que usa recursividad.n \* factorial(n - 1).¿Qué ocurre al correr el script de factoriales?
Cuando ejecutas el script anterior, se muestra paso a paso cómo cada llamada recursiva se procesa hasta llegar al caso base. Aquí el seguimiento de print dentro del código proporciona una útil técnica de depuración para entender el flujo de la recursividad.
Por ejemplo, para calcular el factorial de 4 se sigue el siguiente desdoblamiento:
El resultado, al resolver cada paso, nos conduce finalmente a 24, que es el factorial de 4.
¿Qué más deberías saber sobre la recursividad?
Un aspecto crítico al trabajar con funciones recursivas es asegurar que siempre exista un caso base para evitar loopings infinitos. En lenguajes como Python, la pila de llamadas tiene un límite, así que sin un caso base, la recursividad puede llevar a un error de límite máximo de recursividad.
Si te interesa personalizar o entender más sobre los límites de la recursividad en Python, te animo a investigar cómo ajustarlos adecuadamente. Experimenta, aprende y no dudes en explorar cómo otros lenguajes implementan la recursividad. Esta práctica no solo ampliará tu comprensión sino que te convertirá en un programador más eficiente y versátil. ¡Continúa explorando y expandiendo tus horizontes!
Angel Armando Martínez Blanco
Nada mejor que aprovechar la cuarentena para aprender en modo "turbo" :D
freddy molleda
X2
Sergio Noriega
X3
David González Trujano
Los algoritmos recursivos deben obedecer tres leyes importantes:
Un algoritmo recursivo debe tener un caso base. Un algoritmo recursivo debe cambiar su estado y moverse hacia el caso base. Un algoritmo recursivo debe llamarse a sí mismo, recursivamente.
Fernando Jesús Núñez Valdez
Buen aporte!!
Lorenzo Enrique Piñango Cerezo
Excelente aporte
freddy molleda
Les comparto un video resumen que hice sobre recursividad, muy bueno para complementar . https://drive.google.com/file/d/1xgGFoATJRF9cxsQEueWSViB2FQ8_9sa-/view?usp=sharing . Véanlo y me comparten lo que piensan
Alonso Cangalaya
Excelente, me ayudo a comprender como funcionan los stacks dentro de la recursividad computacional
freddy molleda
@AlonsoCangalaya tambien te puede servir este link aqui esta en ingles pero es muy bueno que tengas ese tema claro si quieres ser un buen programador (es facil de comprender)
Alejandro Giraldo Londoño
Luis Fernando Pedroza Taborda
Alejandro, muchas gracias por el aporte
Fredy Mendoza Vargas
Gracias x el resumen
Dionisio Ernesto Lagunes Navarro
Se puede cambiar el limite de recursividad importando sys y llamando la función setrecursionlimit()
import sys sys.setrecursionlimit(2000)
Enrique Devars
¡Wow! :D Increíble aporte.
¡Nunca pares de aprender! 💚
Lorenzo Enrique Piñango Cerezo
Gracias
Edinson Requena
Esta es la forma en la que puedes modificar el limite de recursion en python para que la funcion pueda llamarse a si misma mas de 1.000 veces. (esto cambia dependiendo del lenguaje
# Importamos el modulo sys que nos permitira modificar la recursion import sys def factorial(n): """Calcula el factorial de n n int > 0 returns n! """ print(n) if n == 1: return 1 return n * factorial(n - 1) n = int(input('Escribe un entero: ')) # Imprimimos el limite de recursion que trae python por defecto con la funcion sys.getrecursionlimit() que trae el modulo sys. print(sys.getrecursionlimit()) # Modificamos el limite de recursion a 2000 con la funcion sys.setrecursionlimit() que trae el modulo sys sys.setrecursionlimit(2000) print(factorial(n))
Saúl Alejandro Tapia Loya
El límite del stack de llamadas a funciones en Python es de 999, al tener 1000 en el stack crashea, esto es debido a que Python tiene un límite establecido para evitar el famoso "Stack Overflow", y también evitar recursiones infinitas, aún así, podemos cambiarlo con:
sys.setrecursionlimit(limite_de_recursiones)
Cristhian Julian Astoquilca Romero
Les comparto algo interesante que encontre en un libro. Las funciones con llamadas recursivas utilizan memoria extra en las llamadas; existe un límite en las llamadas; existe un límite en las llamadas, que depende de la memoria de la computadora. En caso de superar este límite ocurre un error de desbordamiento (overflow). Complementa un poco lo que mencionó el profesor en el video.
Miguel Torres
Así es, en python el límite de recursividad es 1000.
En los siguientes cursos de esta ruta verás más sobre ello y verán cómo modificar ese límite con un módulo de python llamadoos y cuándo debería hacerse. ;)
Sara Yaneth Contreras Elías
++RECURSIVIDAD++
La recursividad es una técnica de programación que nos permite que un bloque de instrucciones se ejecute n veces. Reemplaza en ocasiones a estructuras repetitivas.
La recursividad es un concepto difícil de entender en principio, pero luego de analizar diferentes problemas aparecen puntos comunes.
En Python las funciones o métodos pueden llamarse a sí mismos. Si dentro de una función o método existe la llamada "a sí mismo" decimos que la función o método es recursivo.
Cuando una función o método se llama a sí mismo, se asigna espacio en la pila para las nuevas variables locales y parámetros.
++¿Qué importancia tiene la recursión en la programación?++
Quizás se quiera dividir un problema complejo en varios problemas pequeños (Dividir y conquistar). Si ya se está familiarizado con los ciclos e iteraciones, en algunos casos, la recursión puede ser una mejor solución.
Se obtendría el siguiente error:
Rubén David Pérez Cantillo
Excelente aporte, Sara. Me ayudó a captarlo mejor, estuve enredado un buen rato tratendo de entender el concepto como tal. jajajsja
Noldia Chavez Cavero
Una ligera pulida al codigo:
Samuel de las
Me gustó mucho este modo. Gracias por compartirlo.
Fernando Arellano
Hola que tal quiero compartir una pagina que me ayudo a comprender la recursividad en este programa , ya que nos muestra los frames que se van generando y el valor que regresan . Les dejo el link http://www.pythontutor.com/visualize.html#mode=display y una captura de la interfaz.
Carlos Andrés Vanegas Ruiz
Verlo de esta manera me ayudó a entenderlo! (obvio está mal escrito en python pero el punto acá fue visualizar lo que estaba pasando)
Edwin Sebastian Cabascango Salazar
Al fin logre entenderlo bien, muchas gracias
Royer Guerrero Pinilla
def fib(n): if n < 2: return n else: return fib(n-1) + fib(n -2) fibonacci = fib(8) print(fibonacci)
Victor Noguera
Serie Fibonacci Gracias.
Guillermo Sánchez Martinez
Para 996 ya no lo calcula
RecursionError: maximum recursion depth exceeded while calling a Python object
Jorge Alberto Delgadillo Alonso
Existe una forma de hacer nuestra recursividad mas eficiente, se llama "Tail Recursion" y es super interesante les dejo el link https://www.youtube.com/watch?v=_JtPhF8MshA
Jose Flores
Que buen video, aunque con la pura explicación no supo muy bien como implementarlo en Python, lo bueno es que existe internet y busque como hacerlo, ya me quedo muy claro, la diferencia en pocas palabras, es que mientras la recursividad normal se tiene que recordar una serie de funciones, la "Tail Recursión" solo recuerda la función anterior, algo similar pasa con los sistemas caóticos donde el siguiente resultado solo depende del anterior, me gusta imaginar que es un tipo de histéresis.
Enrique Emanuel Martínez Saénz
mi limite es 996. sys.setrecursionlimit() se utiliza para establecer la profundidad máxima de la pila de intérpretes de Python en el límite requerido. Este límite evita que cualquier programa entre en una recursión infinita, que conduciria al desbordamiento de la pila C y bloqueará el Python.
Thomas Antonio Contreras Lan
def factorial(i): if i == 1 or i == 0: return 1 elif type(i) == float or i < 0: return 'Error, debe ser un número entero positivo' elif i > 1: return i * factorial(i-1)
Agregúe que si el valor de entrada es 0, tambien deba ser 1 el resultado (por convención) y que si se tratada de un número negativo o decimal arroje dicho mismo mensaje.
Raul Armas
La recursión también puede ser indirecta: una primera función llama a una segunda, y está segunda llama a la primera, ejemplo:
def is_even(x): if x == 0: return True else: return is_odd(x-1) def is_odd(x): return not is_even(x) print(is_odd(17)) print(is_even(23))
RESUMEN: Recursividad
Algoritmica:
Una foma de usar el principio "divide and conquer", definirla así es una forma de crear soluciones a partir de versiones más pequeñas del mismo problema. Existen soluciones base que permiten iterarse para encontrar un solución.
Programática:
Una técnica mediante la cual una función se llama así misma. Una función adentro de otra función, existen varios ejemplos de esto. Los factoriales, la serie de fibonnaci, los fractales. Podemos definir la recursión como una iteración, cualquier función recursiva podemos representarla como un loop.
Python no es un lenguaje funcional y las recursiones de colas no son particularmente una técnica eficiente, reescribir el algotimo iterativamente, de ser posible es generalmente una mejor idea
Lo que está ocurriendo con la recursión es: Estamos poniendo stack encima cada ve que ejecutamos un factorial. Al tener caso base se regresan todos lo valores en una sola lína.
El factorial lo que hace es que me ejecuta la función n, n veces.
A continuación dejo el estudio comentariado y referenciado de recursividad y su límite.
def me(): """ ■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■ INICIO Este código teiene como propósito Encontrar el límite de recursión teórico de mi máquina y compararlo con el real. 1. Defino una funcion recursiva 2. Le paso dos argumentos n y resultado_suma haciendo referencia a un número n y mi suma. 3. Imprimo el resultado de suma iterado después de pasarlo por un ciclo for ■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■ FINAL El resultado que me va a devolver al final es: => [Previous line repeated 993 more times]==> Cuando mi límite de recursión teórico es de 1000 ... RecursionError: maximum recursion depth exceeded while calling a Python object ■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■ RECURSION LIMIT Para cambiar el límite de recursión en python se usa la función: sys.setrecursionlimit(limit) Esta función ajusta mi limite máximo de profundidad del stack del interprete de pyhton, este límite previene que la recursión " infinita" crashee el "C stack" de Pyhton ■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■ CONSIDERACIONES El límite es directamente proporcional a la máquina. Es plataforma dependiente y es mejor usarlo cuando el contexto lo amerite. Si el nuevo límite de profundidad en la recursión es muy bajo el error RecursionError aparece. https://docs.python.org/3/library/sys.html#sys.setrecursionlimit ■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■ ¿CUAL ES MI LÍMITE DE RECURSIÓN? => Para saber el límite de recursión se usa: sys.getrecursionlimit() Me devuelve el valor actual del limite de recursión para el stack de python. """ pass #Con este import traigo palabra reservada sys. del sistema import sys print(help(me)) print(f'Mi límite de recursión teórico es: {sys.getrecursionlimit()}') if __name__ == '__main__': def recursive_function (n , resultado_sum): if n < 1: print(f'Vuelve siempre cero para que se ejecute un true infinito {n}. Soy el resultado de una suma y tengo el valor de: {resultado_sum} ') return sum else: # Soy la suma inicialmente de la forma => n = n+1 # Y mi resultado lo voy a iterar, repetir como una suma => (n + 1) + resultado_suma recursive_function(n - 1, resultado_sum + n) #El valor de c me dará indicación de que empieza c = 0 # Le digo que me itere hasta 998. for i in range(998): c += 1 valor_iterado = recursive_function(c, 0)