Fundamentos de Programación y Python
¿Por qué aprender Python?
Introducción a Python
Conceptos Básicos de Programación
Práctica: Te doy la bienvenida a los ejercicios interactivos
Manipulación de Cadenas de Texto en Python
Enteros, Flotantes y Booleanos
Todo lo que Debes Saber sobre print en Python
Operaciones Matemáticas en Python
Operaciones de Entrada/Salida en Consola
Colección y Procesamiento de Datos en Python
Listas
Método slice
Listas de más dimensiones y Tuplas
Aplicación de Matrices
Diccionarios
Comprehension Lists en Python (CLASE NUEVA)
Control de Flujo en Python
Estructuras condicionales
Bucles y Control de Iteraciones
Generadores e Iteradores
Funciones y Manejo de Excepciones en Python
Uso de Funciones en Python
Funciones Lambda y Programación Funcional en Python
¿Cómo realizar una función recursiva en Python?
Manejo de Excepciones y Uso de Pass (CLASE NUEVA)
Programación Orientada a Objetos en Python
Fundamentos de Programación Orientada a Objetos en Python
Ejercicio Biblioteca con POO
Herencia en POO con Python
Objetos heredados
Los 4 pilares de la programacion orientada a objetos
Uso de super() en Python (CLASE NUEVA)
Superando los Fundamentos de Programación Orientada a Objetos en Python
Lectura y escritura de archivos
Manejo de Archivos .TXT (CLASE NUEVA)
Manejo de Archivos CSV (CLASE NUEVA)
Manejo de Archivos JSON (CLASE NUEVA)
Biblioteca estándar de Python
Biblioteca estándar en Python (CLASE NUEVA)
Librería Os, Math y Random (CLASE NUEVA)
Librería Statistics y Análisis Estadístico (CLASE NUEVA)
Proyecto final: Guerra naval
Conceptos avanzados de Python
Recapitulación de lo aprendido hasta ahora
Escribir código Pythonico y profesional
Comentarios y Docstrings en Python
Scope y closures: variables locales y globales
Anotaciones de tipo
Validación de tipos en métodos
Librería Collections y Enumeraciones
Decoradores
Decoradores en Python
Decoradores anidados y con parámetros
Uso de Decoradores en clases y métodos
Métodos y estructura de clases en Python
Métodos mágicos
Sobrecarga de operadores
Implementación de `if __name__ == "__main__":`
Metaprogramación en Python
Uso de *args y **kwargs
Métodos privados y protegidos
Gestión avanzada de propiedades
Métodos estáticos y de clase avanzados
Programación concurrente y asíncrona
Introducción a la concurrencia y paralelismo
Threading y multiprocessing en Python
Asincronismo con asyncio
Asincronismo y concurrencia
Creación de módulos y paquetes
Creación de módulos en Python
Gestión de paquetes
Publicación de paquetes en PyPI
Proyecto final
Implementación de un sistema completo
Implementación de un Sistema Completo
No tienes acceso a esta clase
¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera
Si ya tienes una cuenta,
Recursos
La recursividad es una técnica fundamental en programación donde una función se llama a sí misma para resolver problemas complejos de manera más sencilla y estructurada.
¿Cómo se aplica la recursividad en el cálculo del factorial?
La recursividad se entiende mejor con ejemplos prácticos. El factorial de un número se define como el producto de todos los números desde ese número hasta 1. Por ejemplo, el factorial de 5 (5!) es 5 * 4 * 3 * 2 * 1.
En código Python, la función factorial se puede definir recursivamente de la siguiente manera:
def factorial(n):
if n == 0:
return 1
else:
return n * factorial(n - 1)
Este código sigue dos casos clave en la recursividad:
- Caso base: cuando
nes 0, la función retorna 1. - Caso recursivo: cuando
nes mayor que 0, la función retornanmultiplicado por el factorial den-1.
¿Cómo funciona la recursividad en la serie de Fibonacci?
La serie de Fibonacci es otra aplicación clásica de la recursividad. En esta serie, cada número es la suma de los dos anteriores, comenzando con 0 y 1. La fórmula es:
[ F(n) = F(n-1) + F(n-2) ]
El código Python para calcular el número n-ésimo en la serie de Fibonacci usando recursividad es el siguiente:
def fibonacci(n):
if n == 0:
return 0
elif n == 1:
return 1
else:
return fibonacci(n-1) + fibonacci(n-2)
Aquí también se siguen dos casos:
- Caso base: cuando
nes 0 o 1, la función retornan. - Caso recursivo: para otros valores de
n, la función retorna la suma defibonacci(n-1)yfibonacci(n-2).
Aportes 213
Preguntas 4
Ordenar por:
### Me costo trabajo entender la función recursiva. Asi que aqui va una explicacion de chatGPT
Call Stack en Recursión
Cuando llamas a una función en Python (o en la mayoría de los lenguajes de programación), la llamada a la función se añade al call stack. El call stack lleva un registro de todas las llamadas a funciones que necesitan resolverse. Cuando una función devuelve un valor, se elimina del call stack.
### Ejemplo: factorial(5)
Veamos el call stack mientras se evalúa factorial(5):
1. **Llamada inicial**: Se llama a `factorial(5)` y se añade al call stack.
* Call stack: `[factorial(5)]`
2. **Segunda llamada**: `factorial(5)` llama a `factorial(4)`.
* Call stack: `[factorial(5), factorial(4)]`
3. **Tercera llamada**: `factorial(4)` llama a `factorial(3)`.
* Call stack: `[factorial(5), factorial(4), factorial(3)]`
4. **Cuarta llamada**: `factorial(3)` llama a `factorial(2)`.
* Call stack: `[factorial(5), factorial(4), factorial(3), factorial(2)]`
5. **Quinta llamada**: `factorial(2)` llama a `factorial(1)`.
* Call stack: `[factorial(5), factorial(4), factorial(3), factorial(2), factorial(1)]`
6. **Sexta llamada**: `factorial(1)` llama a `factorial(0)`.
* Call stack: `[factorial(5), factorial(4), factorial(3), factorial(2), factorial(1), factorial(0)]`
### Caso base alcanzado
Cuando se llama a `factorial(0)`, se alcanza el caso base y devuelve 1. Este valor de retorno comienza el proceso de desenrollar el call stack.
### Devolviendo valores y desenrollando el stack
Ahora, cada llamada devuelve su resultado y se elimina del call stack:
1. `factorial(0)` devuelve 1.
* Call stack: `[factorial(5), factorial(4), factorial(3), factorial(2), factorial(1)]`
2. `factorial(1)` devuelve `1 * 1 = 1`.
* Call stack: `[factorial(5), factorial(4), factorial(3), factorial(2)]`
3. `factorial(2)` devuelve `2 * 1 = 2`.
* Call stack: `[factorial(5), factorial(4), factorial(3)]`
4. `factorial(3)` devuelve `3 * 2 = 6`.
* Call stack: `[factorial(5), factorial(4)]`
5. `factorial(4)` devuelve `4 * 6 = 24`.
* Call stack: `[factorial(5)]`
6. `factorial(5)` devuelve `5 * 24 = 120`.
* Call stack: `[]`
### Resultado final
El resultado final de `factorial(5)` es 120, y el call stack está vacío una vez que todas las llamadas a funciones han devuelto sus valores.
### Resumen
* Cada llamada a `factorial(n)` se añade al call stack.
* El caso base `factorial(0)` detiene la recursión y comienza a devolver valores.
* El call stack se desenrolla, devolviendo valores paso a paso hasta que se resuelve la llamada inicial.
* El call stack asegura que el contexto de cada llamada (su propio valor de `n`) se preserve hasta que pueda resolverse.
Hay que tener cuidado en donde **SI** y en donde **NO** se debe usar la recursividad.
En el caso de resolver Fibonacci o la sumatoria de los números naturales de 1 a n
la recursividad no es el mejor método y explico porque.
Para Fibonacci:
Para no extenderme dejo una captura de mi código agregando una variable que va contando
las veces que se invoca la función y al final imprime cuantas veces fue invocada.
Si la comparamos con la versión de Fibonacci usando un generador en la que cada vez que se entra a calcular se imprime lo que se está calculando (equivalente a cada vez que se llama) se puede ver que es mucho más eficiente el método por generadores.
Para la sumatoria:
Doy por hecho que conocen la historia de Gauss y su forma de resolver la sumatoria de 1 a 100.
Programar esta sumatoria de forma recursiva (o incluso con un ciclo for o while) es como el castigo
que se les puso a los niños y programarlo usando una formula para hacer el cálculo es como lo
habría hecho Gauss, en resumen, mi función puede ser calculada "n" siendo "n" el número hasta donde quiero sumar pero si en lugar de hacerlo recursivo mejor solo uso n(n+1)/2 esta forma es mucho más rápida que incluso se puede hacer mentalmente.
Con esto no quiero decir que la recursividad no sirva porque en los casos de calcular un factorial o escribir los pasos de los movimientos de los discos para resolver las torres de Hanoi sería más complicado no usar recursividad.
```js
#reto
def sumatoria(n):
if n == 0:
return 0
else:
return n + sumatoria(n - 1)
# Probar la función con varios valores
for i in range(11):
print(f"Sumatoria de {i} es: {sumatoria(i)}")
```
### Recursividad
La recursividad es una técnica de programación en la que una función se llama a sí misma para resolver un problema. Un problema se divide en subproblemas más pequeños y la función se llama recursivamente hasta que se alcanza una condición base que finaliza las llamadas recursivas.
### Consideraciones sobre la Recursividad
1. **Condición Base**: Es crucial definir correctamente una condición base para evitar llamadas recursivas infinitas.
2. **Eficiencia**: Las implementaciones recursivas pueden ser ineficientes para problemas complejos debido a la sobrecarga de llamadas a funciones. En el caso de Fibonacci, una implementación recursiva simple tiene una complejidad exponencial `O(2^n)`. Esto puede mejorarse utilizando memoización o una implementación iterativa.
```js
def fibonacci_memo(n, memo={}):
if n in memo:
return memo[n]
if n == 0:
return 0
elif n == 1:
return 1
else:
memo[n] = fibonacci_memo(n - 1, memo) + fibonacci_memo(n - 2, memo)
return memo[n]
# Ejemplo de uso
print(fibonacci_memo(10)) # Salida: 55
```
Quise hacer algo un poco más amigable con el usuario
```js
def sumatoria(n):
if n == 0:
return 0
else:
return n + sumatoria(n-1)
n = int(input("Ingrese un número entero: "))
print(f"La suma de números naturales hasta {n} es: {sumatoria(n)}")
```
Os dejo una función recursiva para generar la serie de fibonacci hasta un número limite:
`def fibonacci(f1, f2, n):`
` print(f1)`
` if n > f2:`
` print(f2)`
` fibonacci ( f1 + f2, f1 + f2 + f2 , n)`
` else:`
` print ("fin")`
`fibonacci(0,1,int(input("Generar fibonacci con limite: ")))`
Después de repetir como 10 veces la clase, creo que ya mas o menos me quedo un poco más claro.
La recursividad se divide en dos, **CASO BASE y CASO GENERAL.**
Para entenderle a esta vaina hay que entenderla como si fuera un ciclo.
Hagan de cuenta que es algo así como un while, ahí se necesita una variable iteradora, en el caso de recursividad el **CASO BASE** es donde el programa va a decir que pare, y el **CASO GENERAL** es el codigo que va a ejecutar, o sea ahi es donde se va a llamar la funcion, y se ejecutará las veces que diga el **CASO BASE**, si no sería un ciclo infinito.
En el ejemplo de la clase:
def factorial(n):
if n == 0: }
}CASO BASE
return 1 }
Aqui es donde le va a decir al programa que pare cuando una condicion se cumpla, todas las recursivas hacen eso o si no serian infinitas.
\#############################
else: CASO GENERAL
return n \* factorial(n-1)
Aqui el numero (n) va a restarse en cada ciclo, hasta que sea 0, de modo que si es 4. Va a multiplicarse, 4 \* 3, porque factorial se llama con el numero 4 pero ahi se esta restando con 1, dando 4-1 =3.
Por lo que la formula queda algo como:
4 \* (4-1)
En la siguiente vuelta, será ahora 3 \* 2 y a la siguiente vuelta será 2\*1, luego 1\*0 y ahí para porque llegó a 0 y su caso base nos indica que nos detengamos (return 1).
Entonces n cada ciclo irá restandose 1, porque esa ultima linea le dice que se reste n-1 por ello es que almacena el valor en cada ciclo.
Espero haya ayudado a comprender más este tema que es re complejo para algunos.
1. **Cuándo Usar Recursión**:
* La recursión es útil cuando un problema se puede dividir en casos más pequeños y similares al problema original.
* Algunos ejemplos comunes de uso de recursión son:
* Cálculo de factoriales.
* Búsqueda en árboles o grafos.
* Resolución de problemas matemáticos o algorítmicos.
1. **Importante**:
* Siempre debes tener un **caso base** que marque el final de las llamadas recursivas. De lo contrario, podrías entrar en un ciclo infinito.
* Además, asegúrate de que cada llamada recursiva se acerque al caso base.
Este es otro curso de python en el cual toca este tema de recursividad. Espero les ayude.
<https://platzi.com/home/clases/1764-python-cs/25243-recursividad/>
```python
#Solución Reto Suma de Números Naturales
def suma_numeros(n):
if n == 0:
return 0
else:
return n + suma_numeros(n - 1)
def print_suma(count):
sequence = []
for i in range(1, count + 1):
sum_result = suma_numeros(i)
sequence.append(sum_result)
if i == count:
print(f"{i} = {sum_result}", end=" ")
else:
print(f"{i} +", end=" ")
# Ejecución.
count = 7
print_suma(count)
```
Reto sumatoria número naturales:
```js
def summationOfNaturalNumbers(n):
if n <= 1:
return n
else:
return n + summationOfNaturalNumbers(n - 1)
print(summationOfNaturalNumbers(5))
```
```python
# Reto sumatoria de numeros naturales
def sumatoria(N):
if N==0:
return 0
else:
return N+sumatoria(N-1)
num=3
print("La sumatoria de todos los numeros menores que ",num,"es:",sumatoria(num))
```
Quise que el usuario ponga el número del cual quiere el factorial así que le añadí el input:
def factorial(n):
if n == 0:
return 1
else:
return n * factorial (n-1)
x = int(input("Ingrese número: "))
factorial_n = print(factorial(x))
🙌
Quería obtener la lista completa con la cantidad de números indicado así que modifiqué el print. 🤗
def fibonacci(n):
if n == 0:
return 0
elif n == 1:
return 1
else:
return fibonacci(n-1) + fibonacci(n-2)
print([fibonacci(n) for n in range(5)])
Gente aquí les dejo una variante al **ejercicio de Fibonacci** que me pareció interesante**:**
```python
def fib_r(n):
if n < 2:
return n
else:
return fib_r(n-1) + fib_r(n-2)
n = int(input("Ingrese la cantidad de elementos para fibonacci: "))
for x in range(n):
print(fib_r(x))
```
```js
def numeros_naturales(numero):
if numero == 0:
return 0
else:
return numero + numeros_naturales(numero - 1)
numero_usuario = int(input("ingrese un número natural: "))
resultado = numeros_naturales(numero_usuario)
print(f"La suma de números naturales hasta {numero_usuario} es de : {resultado}")
```def numeros\_naturales(numero):
if numero == 0:
return 0
else:
return numero + numeros\_naturales(numero - 1)
numero\_usuario = int(input("ingrese un número natural: "))
resultado = numeros\_naturales(numero\_usuario)
print(f"La suma de números naturales hasta {numero\_usuario} es de : {resultado}")
```python
def fibonacci(n):
if n==0:
fiboncito=[0]
return fiboncito
if n==1:
fiboncito=[0,1]
return fiboncito
else:
fiboncito=fibonacci(n-1)
fiboncito.append(fiboncito[-1]+fiboncito[-2])
return fiboncito
n=7;
print("Los primeros %i terminos de la serie de Fibonacci son:"%(n),fibonacci(n-1))
```
```js
#reto calcula la sumatoria de números naturales a partir de n hacía atras
def sumatoria(n):
if n > 0:
print(n)
return n + sumatoria(n-1)
else:
return 0
print(sumatoria(8))
```
Os comparto una función recursiva para generar la serie de fibonacci con un límite.
![]()
```python
def R(n):
if n == 0:
return 0
else:
return n + R(n-1)
print(R(5))
```Dejo Mi aporte al reto
```js
def sumatoria(n):
if n ==0:
return 0
else:
return n+sumatoria(n-1)
total_= sumatoria(5)
print(total_)
```Aporte para el pendiente de la sumatoria, tomado del ejercicio que nos explico!! muy bueno!
Buenas acá dejo mi aporte para el desafío de la clase de hoy, sólo agregué un validador de datos de entrada para evitar ingresos de tipo erróneo y números que no sean naturales#Ejercicio Suma de numeros naturalesdef sum\_num\_nat (x): if x == 1: return 1 else: return x + sum\_num\_nat(x-1)
def validation (): invalid = True while invalid: x = input("Ingrese el numero natural que desea utilizar: ") if not x.isnumeric(): print("\*ERROR\*\nEl valor ingresado no es un numero, intente nuevamente.") else: x = int(x) if x <= 0: print("\*ERROR\*\nEl numero ingresado no es un numero natural, recuerde que el valor necesita ser un numero entero (sin coma flotante) mayor o igual a 1") else: return x
print("Bienvenido al sumador de numeros naturales")x = validation()print("El resultado de la suma de numeros naturales de",x,"es igual a",sum\_num\_nat(x))```js
#Ejercicio Suma de numeros naturales
def sum_num_nat (x):
if x == 1:
return 1
else:
return x + sum_num_nat(x-1)
def validation ():
invalid = True
while invalid:
x = input("Ingrese el numero natural que desea utilizar: ")
if not x.isnumeric():
print("*ERROR*\nEl valor ingresado no es un numero, intente nuevamente.")
else:
x = int(x)
if x <= 0:
print("*ERROR*\nEl numero ingresado no es un numero natural, recuerde que el valor necesita ser un numero entero (sin coma flotante) mayor o igual a 1")
else:
return x
print("Bienvenido al sumador de numeros naturales")
x = validation()
print("El resultado de la suma de numeros naturales de",x,"es igual a",sum_num_nat(x))
```
def sum(n): if n == 0: return 0 elif n == 1: return 1 else: return n + sum(n-1) number = 10print (sum(number))
Si tienes formación relacionada con matemáticas, las funciones recursivas son un tema que nace en las matemáticas, no en la programación. Es decir, es heredada de las matemáticas.
`def suma_naturales(n):`
` if n == 0: `
`return 0 `
`else: `
`return n + suma_naturales(n-1)`
`suma = print(suma_naturales(8))`
Comparto el Reto
Mi solución al ejercicio
```python
def sumarNaturales(n):
if n == 0:
return 0
else:
return n + sumarNaturales(n-1)
number = 10
print(sumarNaturales(number))
```
```python
def sumatoria(n):
if n == 0:
return 0
else:
return n + sumatoria(n-1)
def sumatoria_primeros_n_num():
while True:
print('Selecciona una opción...')
print('1.- Hola! Selecciona hasta qué número deseas realizar la sumatoria: ')
print('2.- Salir')
option = int(input('Ingresa una opción: '))
if option == 2:
print('Hasta pronto! Saliendo de la sumatoria...')
break
if option == 1:
n = (int(input('Hasta qué número deseas realizar la sumatoria: ')))
print('***********************************************************')
print(' ')
print(f'La sumatoria hasta el número {n} es igual a', sumatoria(n))
print(' ')
print('***********************************************************')
else:
print('Opción inválida...')
print('Solamente puedes elegir entre la opción 1 ó 2...')
sumatoria_primeros_n_num()
```Lo hice ocupando el ejemplo de la clase 19
Una buena herramienta que les podría ayudar sería esta: <https://pythontutor.com/visualize.html#mode=edit> en donde pueden ver el código de una forma más visual e interactiva.
Una solucicón al reto:
def summation(n):
if n==0:
return 0
else:
return n+summation(n-1)
sum=5
print("Summation of ",sum,": ",summation(sum))
\# Sumatoria números naturales
def addition (n):
if n == 0:
return 0
else:
return n + addition (n-1)
number = 4
print (addition(number))
10
```python
|lis_num=[0,1,2,3,4,5,6,7,8,9,10]
def suma_num(i):
if i == 0:
return 0
elif i==1:
return 1
else:
return((i*(i+1))/2)
a=suma_num(4)
print(a)
def suma_num(i):
cero =0
if i == 0:
return 0
elif i==1:
return 1
else:
return(suma_num(i-1)+i)
b=suma_num(4)
print(b)
```
```js
def sumatoria(n):
if n == 0:
return 0
else:
return n + sumatoria(n-1)
print(sumatoria(5))
```def sumatoria(n): if n == 0: return 0 else: return n + sumatoria(n-1) print(sumatoria(5))
La misma serie de Fibonnaci que ella entrego, pero imprimiendola segun el numero de valores que le indiquemos:def fibonacci(n):
```js
def fibonacci(n):
if n == 0:
return 0
elif n == 1:
return 1
else:
return fibonacci(n - 1) + fibonacci(n - 2)
number = 10
print(f"Serie de Fibonacci con {number}")
serie = [fibonacci(x) for x in range(1, number)]
print(f"Serie: {serie}")
```
Aqui mi ejercicio para la suma de naturales
**Recursividad** para calcular potencia:
`def exp(n, e):`
` if n == 0:`
` return 0`
` elif e == 0:`
` return 1`
` elif e == 1:`
` return n`
` elif e < 0:`
` return 1 / exp(n, (e * -1))`
` else:`
` return n * exp(n, e - 1)`
`print(exp(2, -1))`
aqui el codigo para el reto, suma de los numeros natrurales entre si, con ayuda de chat gpt,
\#suma de numeros naturales
\#suma de numeros naturalesdef sumNaturales(n): if n == 1: return 1 else: return n + sumNaturales(n-1)print("suma =", sumNaturales(3))print("suma =", sumNaturales(4))print("suma =", sumNaturales(5))
solución a la actividad, realice un paso para mostrar la recursividad de la función y así podía visualizar cómo se está desglosaba en cada llamada.
```js
# sumatoria de numeros naturales
def sumatoria(n):
if n == 0:
return 0
else:
return n + sumatoria(n-1)
print("Sumatoria de 10:", sumatoria(10))
# sumatoria de numeros naturales por el metodo de la formula
def sumatoria_formula(n):
return n * (n + 1) / 2
print("Sumatoria de 10:", sumatoria_formula(100))
```
def naturales (n): if n < 1: return 0 else: return n + naturales(n-1)
number = 8print(f"La sumatoria de los números naturales hasta {number} es: {naturales(number)}")
```js
def naturales (n):
if n < 1:
return 0
else:
return n + naturales(n-1)
number = 8
print(f"La sumatoria de los números naturales hasta {number} es: {naturales(number)}")
```
script del reto:
```python
def factorial(n):
if n > 1:
return n * factorial(n - 1)
else:
1
if __name__ == '__main__':
print(factorial(5))
```def factorial(n): return n \* factorial(n - 1) if n > 1 else 1
if \_\_name\_\_ == '\_\_main\_\_': print(factorial(5))
```js
def sumatoria(n):
if n == 0: # Caso base: cuando llega a 0, se detiene
return 0
else:
return n + sumatoria(n - 1) # Llamada recursiva
# Ejemplo: sumatoria de los primeros 5 números (1+2+3+4+5)
resultado = sumatoria(5)
print(resultado)
```
Yo realicé esta estructura para la serie fibonacci:def natural\_numbers(*n*): *if* *n* == 1: *return* *n* *else*: *return* natural\_numbers(*n*-1) + *n* number = *int*(input('Dime qué número quieres calcular: '))print(natural\_numbers(number))
```js
def fibonacci(n):
if n == 0 or n == 1:
return n
else:
return fibonacci(n-1) + fibonacci(n-2)
def printFibonacci():
limit = int(input('Dame el límite de números a imprimir: '))
n = 0
while limit > 0:
print(fibonacci(n))
limit -= 1
n += 1
printFibonacci()
```Y para el ejercicio de los números naturales:
```js
def natural_numbers(n):
if n == 1:
return n
else:
return natural_numbers(n-1) + n
number = int(input('Dime qué número quieres calcular: '))
print(natural_numbers(number))
```
Dato de color con la formula de la profe las pc solo puede calcular hasta 998! . Luego de eso da:
`RecursionError: maximum recursion depth exceeded`
se puede calculas mas grande con otras formulas o ciclos `for` pero con mas costo de memoria
Creo hablerlo entendido, pero sin ver reflejada la eficiencia o alguna eficiencia al usar funciones recursivas como en estos ejemplos.
Porque igual hacen las mismas cantidad de paso y hasta más pudiera ser que realizando otra semántica consumiendo hasta mas recursos.
```python
#Sumatoria de números
def sumatoria(m):
if m == 0:
return 0
elif m == 1:
return 1
else:
return m + sumatoria(m-1)
number1 = 5
print(sumatoria(number1))
```
"La secuencia de Fibonacci está escrita en el mismo lenguaje de la naturaleza." Fibonacci.
adjunto tarea :)
```js
#Clase 21 de 63 • Curso de Python
#¿Cómo realizar una función recursiva en Python?
#Una función recursiva es una función que se llama a sí misma.
#Ejericio 1
#Crear función recursiva que calcule el factorial de un número
print("Ejercicio 1: Crear función recursiva que calcule el factorial de un número");
def factorial(n):
if n == 0:
return 1;
else:
return n * factorial(n - 1);
numero = 5;
print(f"El factorial de {numero} es:",factorial(numero));
#Ejercicio 2
#Crear función recursiva que calcule la serie de Fibonacci
print("")
print("Ejercicio 2: Crear función recursiva que calcule la serie de Fibonacci");
def fibonacci(n):
if n == 0 or n == 1:
return n
else:
return fibonacci(n - 1) + fibonacci(n - 2)
numero = 10
print(f"El número en la serie de Fibonacci en la posición {numero} es:",fibonacci(numero))
#Ejercicio 3
#Crear función recursiva que calcule la sumatoria de numeros naturales
print("")
print("Ejercicio 3: Crear función recursiva que calcule la sumatoria de numeros naturales")
def sumatoria(n):
if n == 0:
return 0
else:
return sumatoria(n - 1) + n
numero = 5
print(f"La sumatoria de los números naturales hasta {numero} es:",sumatoria(numero));
```#Clase 21 de 63 • Curso de Python#¿Cómo realizar una función recursiva en Python?#Una función recursiva es una función que se llama a sí misma.
\#Ejericio 1#Crear función recursiva que calcule el factorial de un númeroprint("Ejercicio 1: Crear función recursiva que calcule el factorial de un número");
def factorial(n): if n == 0: return 1; else: return n \* factorial(n - 1);
numero = 5;print(f"El factorial de {numero} es:",factorial(numero));
\#Ejercicio 2#Crear función recursiva que calcule la serie de Fibonacciprint("")print("Ejercicio 2: Crear función recursiva que calcule la serie de Fibonacci");
def fibonacci(n): if n == 0 or n == 1: return n else: return fibonacci(n - 1) + fibonacci(n - 2)
numero = 10print(f"El número en la serie de Fibonacci en la posición {numero} es:",fibonacci(numero))
\#Ejercicio 3#Crear función recursiva que calcule la sumatoria de numeros naturalesprint("")print("Ejercicio 3: Crear función recursiva que calcule la sumatoria de numeros naturales")
def sumatoria(n): if n == 0: return 0 else: return sumatoria(n - 1) + n
numero = 5print(f"La sumatoria de los números naturales hasta {numero} es:",sumatoria(numero));
```python
def sumatoria(n):
if n < 1:
print("Este numero no es un numero natural valido!!")
return 0
return n * (n + 1) // 2 # Formula de la sumatoria
numero_N = int(input("Ingrese el numero que desea saber la sumatoria: "))
print("La sumatoria de este numero es:", sumatoria(numero_N))
```Yo lo hice de esta manera:
Para los números naturales aplicamos una muy parecida al factorial, pero en lugar de multiplicar sumamos y 0 debe tener de return 0 para que se detenga antes de llegar a los números negativos
`def naturales(n):`
`if n == 0: `
`return 0 `
`else:`
`return n + naturales(n-1)`
`print(naturales(6))`
Hola, les dejo mi reto ->
```js
def sumatoriaReversa(n):
if n == 0:
return 0
else:
return n + sumatoriaReversa(n-1)
print(sumatoriaReversa(10))
```
`def naturalia(n):`
` if n == 0:`
` return 0`
` else:`
` return n + naturalia(n-1)`
`print(naturalia(10))`
```js
def sumatoria(n):
if n == 1:
return 1
else:
return n + sumatoria(n-1)
sumatoria_n = sumatoria(10000)
print (sumatoria_n)
```Buen Dia.
Dejo el codigo para el reto.
Haciendo pruebas pude observar que con numeros grande no funciona.def sumatoria(n): if n == 1: return 1 else: return n + sumatoria(n-1)sumatoria\_n = sumatoria(10000)print (sumatoria\_n)
quise que el número se ingresara desde la consola asi que lo hice de esta forma
```python
# Ejemplo 2: Suma de los primeros n números naturales
sigma = lambda n : int((n*(n+1)/2))
```Ejemplo de la suma de los primeros n naturales usando la fórmula de Gauss
Mi aporte por el reto sugerido:
def sumatoria(n):
if n == 0:
return 0
elif n == 1:
return 1
else:
return n + sumatoria(n - 1)
print(sumatoria(5))
De hecho el factorial de 0 es igual a 1... y se puede demostrar matemáticamente usando recursividad
Mi codigo del reto.
def natural\_numbers(n):
if n == 0:
return 0
else:
return n + natural\_numbers(n - 1)
print(natural\_numbers(3)) # 6
Este es mi aporte:
```python
#Sumatoria de números naturales
def sumNumNat(n):
if n == 0:
return 0
else:
return n + sumNumNat(n-1)
numeroNatural = int(input("Ingrese un número natural, el cual desee conocer su sumatoria de todos los enteros existentes hasta él: "))
print(sumNumNat(numeroNatural))
```
```js
#Factorization challenge solution
def factorization(n):
if n == 0:
return 0
else:
return n + factorization(n-1)
print(factorization(5))
```def factorization(n): if n == 0: return 0 else: return n + factorization(n-1)
print(factorization(5))
n = int(input("Ingrese número: "))
def sumatoria\_op2(n):
if n == 1:
return n
else:
return n + sumatoria\_op2(n-1)
print(sumatoria\_op2(n))
El reto del dia ef sumatoria(n): if n == 0: return 0 elif n == 1: return 1 else: return n + sumatoria(n-1)sumatoria = print(sumatoria(4))```js
ef sumatoria(n):
if n == 0:
return 0
elif n == 1:
return 1
else:
return n + sumatoria(n-1)
sumatoria = print(sumatoria(4))
```
Creo que hay un error en la recursividad de fibonacci, lo que hace la funcion es sumar los ultims digitos del número que le mandamos.
Creo es necesario la ultilizacion de un parametro como limite al momento de crear la recursividad.
Entonces, la funcion deberia recibir el limite, iterar el limite en 1 cada vez que se ejecute, comenzar con 2 valores prederterminados para a y b, de 0 y 1 correspondientemente, hacer que a tome el valor de b en cada interacion y b tome el valor de a+b.
Te tengo, en el reto: def factorial(n):
if n == 0:
return 1
else:
return n + factorial(n-1)
factorial\_5 = factorial(5)
print(factorial\_5)
se muestra que solamente hay que añadir el operador + :)
```python
#Como realizar una funcion recurciva en python
def factorial(n):
if n == 0:
return 1
else:
return n * factorial(n-1)
factorial_5 = print(factorial(8) )
```#Como realizar una funcion recurciva en python def factorial(n): if n == 0: return 1 else: return n \* factorial(n-1) factorial\_5 = print(factorial(8) )
ya ente di ejemplo el numero factorial de 8 es 40,320 ósea multiplicar desde el primer numero positivo hasta el numero factorial mencionado en mi caso el 8 ,(8 x 7 x 6 x 5 x 4 x 3 x 2 x 1 jajaa gracias cali eres la mama de esa vaina 👌💕
Diiiiiioooossss la función recursiva jajaja me dio arritmia
por si alguien quiere practicar la recursividad
<https://sites.google.com/site/programacioniiuno/material/ejercicios-y-tps/ejercicios-recursividad>
¿Cómo realizar una función recursiva en Python?:
La recursividad es cuando un programa se llama a sí mismo para solucionar un problema
Los ejercicios de recursividad se usan para evaluarte para darte trabajo lol
Yo lo hice de esta forma no estaba muy difícil; lo quería hacer con una serie de varios consecutivos pero ya lo habían hecho en otro comentario jejeje
Hay un detalle que puede que pasemos o no por alto.
y es que en recursividad donde en este caso tenemos un numero dinámico que esperamos llegue a 0 para dejar de funcionar sea así:
***return*** **recursividad(n *-* 1) *+* n** y no así: ***return*** **recursividad(n ) *+* n - 1** ya que de esta manera n nunca llegaria al limite que definamos en nuestra función y seria infinita.
*def* *naturalNumbers*(n): *if* n *==* 0: *return* 0 *elif* n *==* 1: *return* 1 *else*: *return* naturalNumbers(n *-* 1) *+* n numb *=* 2print(naturalNumbers(numb))```python
def naturalNumbers(n):
if n == 0:
return 0
elif n == 1:
return 1
else:
return naturalNumbers(n - 1) + n
numb = 2
print(naturalNumbers(numb))
```
Para mi concepto, no es necesario ocupar el else y dejar el return del else al mismo nivel del if, solo hay que invertir la condición y queda perfecta, por ejemplo:
```python
# Ejecicio sumatoria de serie de número
def factorial(num):
if num > 0:
return num + factorial(num - 1)
return 1
# Un plus... mi solución al fibonacci
# en una línea de texto sin usar loops
def fibo(step):
if step > 0:
res = [fibo(step - 1), fibo(step - 2)]
tmp = res[0][0] + res[1][0]
return [tmp, f"{res[0][1]} {tmp}"]
return [0 if step == 0 else 1, "0"]
num = int(input("Ingrese un número: "))
fibonacci = fibo(num)
# Cadena fibonacci en una línea
print(fibonacci[1])
# Número fibonacci en la posición definida en num
print(fibonacci[0])
```
la sumatoria esta muy aburrida, que tal si le hacemos a esto Exercise: Prime Number Analyzer
Create a Python program that performs the following tasks:
1\.
Generate Prime Numbers: Use a generator function to produce an infinite sequence of prime numbers.
2\.
Iterator for N Primes: Create an iterator that allows you to iterate over the first N prime numbers.
3\.
Recursive Sum of Primes: Implement a recursive function that calculates the sum of the first N prime numbers.
4\.
Filter and Map: Use filter and map functions to filter out primes that are less than a given threshold and then create a list of their squares.
5\.
Lambda Functions: Integrate lambda functions within map and filter operations.
Respuesta del reto
def suma (numero):
if numero == 0:
return 0
else:
return numero + suma(numero-1)
variab = print(suma(10))
Para calcular la serie de Fibonacci usando recursividad, se define una función que toma un número `n` como parámetro. El código básico sería:
```python
def fibonacci(n):
if n == 0:
return 0 # Caso base
elif n == 1:
return 1 # Caso base
else:
return fibonacci(n - 1) + fibonacci(n - 2) # Caso recursivo
```
Si llamamos a `fibonacci(5)`, el flujo sería:
1. `fibonacci(5)` llama a `fibonacci(4)` y `fibonacci(3)`.
2. `fibonacci(4)` llama a `fibonacci(3)` y `fibonacci(2)`.
3. `fibonacci(3)` llama a `fibonacci(2)` y `fibonacci(1)`.
4. `fibonacci(2)` llama a `fibonacci(1)` y `fibonacci(0)`.
Los casos base devolverán 1 y 0, respectivamente, y luego se sumarán:
- `fibonacci(0)` = 0
- `fibonacci(1)` = 1
- `fibonacci(2)` = `1 + 0` = 1
- `fibonacci(3)` = `1 + 1` = 2
- `fibonacci(4)` = `2 + 1` = 3
- `fibonacci(5)` = `3 + 2` = 5
Así, el resultado final de `fibonacci(5)` es 5.
*def* exp(n, e): *if* n == 0: *return* 0 *elif* e == 0: *return* 1 *elif* e == 1: *return* n *elif* e < 0: *return* 1 / exp(n, (e \* -1)) *else*: *return* n \* exp(n, e - 1)
print(exp(2, -1))
MI DESAFIO 😁👍😶🌫️☠️
```python
# LA RECURSIVIDAD
# 1 2 3 4 5 6 7 8 9 10
n = int(input("INGRESE UN LIMITE : "))
def suma_numeros (n):
if n == 0:
return 0
else:
return n + suma_numeros(n-1) # <--LA RECURSIVIDAD
for i in range(n):
print(f"SUMANDO DE {i} ES: {suma_numeros(i)}")
```
Ejercicio de Tarea.
def suma(n):
if n == 0:
return 0
else:
return n + suma(n - 1)
numero = 6 print (suma (numero))
ese fue el codigo que realice entendi el concepto pero no como se usa en el entorno laboral
De esta manera resolví el reto:
Bueno, ps asi lo resolvi a la primera jeje, ya me quedo un poco mas claro aunque me tomo bastante tiempo y con ayuda de Chatgpt que me lo explico mas detalladamente.
Gracias por este tema que así como a Juan Pablo es de cuidado, y muy interesante para aplicarlo.
\#Reto sumatoria numeros naturales
No es mucho pero es trabajo honesto, no se hasta que punto este bien el "<=":
```js
def summation(n):
if n <= 0:
return 0
else:
return n + summation(n-1)
number = 7
print(summation(number))
```def summation(n): if n <= 0: return 0 else: return n + summation(n-1)
number = 7print(summation(number))
aquí mi forma de resolver el ejercicio:
Solución al reto
```js
def naturals(n):
if n == 0:
return 0
else:
result = n + naturals(n - 1)
print(f"La suma del número natural {n} es igual a: {result}")
return result
nat = int(input("Ingrese el valor del número natural a calcular: "))
print(naturals(nat))
```
### ¿Qué hace `return`?
1. **Finaliza la Ejecución de la Función**:
* Cuando Python encuentra una declaración `return` dentro de una función, detiene la ejecución de esa función inmediatamente y vuelve al punto donde la función fue llamada.
2. **Devuelve un Valor**:
* `return` puede devolver un valor (o varios valores) al lugar donde se llamó la función. Este valor puede ser de cualquier tipo de dato: números, cadenas, listas, objetos, etc.
* Si no se especifica un valor después de `return`, la función devuelve `None` por defecto.
### Ejemplos de Uso
#### Ejemplo Básico
`def suma(a, b`):
` return` a + b
`resultado = suma(3, 4`)
`print(resultado) # Imprime: 7`
En este ejemplo, `return a + b` devuelve la suma de `a` y `b` a la variable `resultado`.
#### Uso en Condicionales
`def es_par(numero`):
` if numero % 2 == 0`:
` return True`
` else`:
` return False`
`print(es_par(4)) # Imprime: True`
`print(es_par(5)) # Imprime: False`
Aquí, `return` se usa para devolver `True` o `False` dependiendo de si el número es par o no.
#### Uso en Recursión
Como vimos en tu función de factorial, `return` es crucial para devolver el resultado de cada llamada recursiva:
`def factorial(n`):
` if n == 0`:
` return 1`
` else`:
` return n * factorial(n - 1`)
### ¿Por Qué es Importante?
* **Control del Flujo**: `return` permite controlar cuándo y qué valor se devuelve desde una función, lo que es esencial para la lógica del programa.
* **Modularidad**: Permite que las funciones sean modulares y reutilizables, ya que pueden devolver resultados que otras partes del programa pueden usar.
* **Claridad**: Hace que el código sea más claro y fácil de entender, ya que especifica explícitamente qué valor se espera que devuelva una función.
¿Quieres ver más aportes, preguntas y respuestas de la comunidad?