Operaciones esenciales en colecciones

Si se les dificulta entender lo que hace una función recursiva les recomiendo el Run and Debug de VScode.
Pueden ir viendo que hace el código linea por linea, como cambian las variables, la llamada de la función en la que te encuentras e ir imprimiendo los valores. Es una herramienta muy útil que siempre uso cuando el código es muy confuso, se las recomiendo.

marco antonio

Asi es como funciona amigos

si alguien tiene una duda con el codigo del profe bueno espero que esto les de una idea de como funciona la recursividad

lo hice asta tres, es que hacer un gif es difícil además no debía pasarme de los 20s, ignoren lo que esta debajo del if __name__ : "__main__" piramide(1,4) no me di cuenta asta que termine de editarlo XD

Alejandro Giraldo Londoño

Resumen:
■■■■■■■

Operaciones Esenciales en Colecciones:

Algunas operaciones básicas responden necesidades puntuales como saber:

Tamaño: Las dimensiones
Pertenencia: Si un elemento pertenece o no.
Recorrido: Pasar por los elementos
String: Converir la colección a un string.
Igualdad: Comparar colecciones
Concatenación: Unir o sumar listas
Conversión de tipo: Convertir tipos de datos entre si
Insertar, Remover, Reemplazar, Acceder a n elementos en n posición.

Aquí se hace referencia a los métodos nativos de python para hacer ordenamientos, insertar, acceder y remover elementos. sort(), remove(), pop() Estos métodos son útiles para determinadas tareas. Para sacar todo el provecho de estas se usarán junto a funciones cómo esta:

'''
Crea espacios hacia la derecha si el número lower es menor que el número upper, cuando son diferentes, en cada llamada el número lower base aumenta en 1 y la margen en 4 espacios.

El propósito de este  snipet  de código es ejemplificar qué tipo de conceptos (funciones, condicionales, recursividad) veremos en las estructuras de datos como métodos de clase. Si no entiendes la función no te rindas :), repasa y regresa.

'''


def pyramid_sum(lower, upper, margin =0):
	blanks = " " * margin
	print(blanks, lower, upper)
	if lower > upper:
		print(blanks, 0)
		return 0
	else:
		# Llamada recursiva
		result = lower+ pyramid_sum(lower + 1, upper, margin +4)
		print(blanks, result)
		return result

  
 
pyramid_sum(1,10)

Nicolás Moreno

¿Qué sentido tiene dar un ejemplo con un código que no se entiende? ¿Qué tanto nivel de experiencia se necesita para tomar esta clase? La empecé hace un año y la volví a remotar ahora que estudié por medios diferentes a Platzi y ahora sí la entiendo.
¿Pero cuál es el punto del ejemplo como tal?
Si no aprovechamos las clases para explicar la abstracción necesaria para entender un código, pues no tiene sentido eso que estamos haciendo.
Un poco más de pedagogía y lógica por favor, Platzi Team.

Saúl Mendoza

Aquí el código:

def pyramid_sum(lower, upper, margin=0):
    blanks = " " * margin
    print(blanks, lower, upper)
    if lower > upper:
            print(blanks, 0)
            return 0
    else:
            result = lower + pyramid_sum(lower + 1, upper, margin +4)
            print(blanks, result)
            return result

Miguel Ángel Reyes Moreno

Les ayudará mucho hacer debugging con VS Code. Tengo un vídeo en YouTube donde explico cómo usarlo, aquí se los dejo
Nunca paren de aprender 😄

Alfonso Andres Zapata Guzman

Explicacion detallada de la funcion recursiva ya que nadie la ha explicado por completo, y con esto quiero decir que no, nadie explico que sucede en el area decreciente de la piramide.

def pyramid_sum(lower, upper, margin=0):
    blanks = ' ' * margin
    print(blanks, lower, upper)
    if lower > upper: # al final se ejecuta esta parte como comienzo del decrecimiento de la piramide, cuando esto sucede se retorna 0 para romper el ciclo y usar este 0 para sumarlo al numero que tenia lower en la iteracion anterior.
        print(blanks, 0)
        return 0 # Este cero al comenzar a decrecer la piramide se regresa y se le suma al numero que tenia lower en la iteracion anterior, en este caso 4 + 0 = 4 
                 # y se retorna ese mismo 4, y se le suma al numero que tenia lower en la iteracion anterior es decir 4 + 3 = 7 y se devuelve este resultado,
                 # y se le suma el numero que tenia lower en la iteracion anterior que era 2, 7 + 2 = 9 y se devuelve este resultado
                 # a la ultima salida, en esta se le suma a ese 9 el valor inicial de lower que era 1 y el resultado impreso seria 10
    else: # al inicio de la funcion se ejecuta esta parte cuando esta creciente la piramide, esto hasta que lower supera a upper en tamaño.
        result = lower + pyramid_sum(lower + 1, upper, margin + 4)
        print(blanks, result)
        return result

pyramid_sum(1, 4)

# Explicacion de porque se imprime blank de estos tamaños al decrecer, formando el tamaño de piramide.
# Esto sucede ya que no regresamos la variable blanks y por lo tanto esta variable desaparece cada que retornamos solo  la variable result,
# Usandose el blank que se tenia cuando se invoco el el calculo de la variable result reespectivamente.
# Suena feo invocar, como a magia, pero decir que se llamo la funcion puede no resultar tan claro para alguien no familiarizado

'''
Si a alguien ayuda aun mas: 
1) Llamado de funcione pyramid 
2) llamado de primera funcion recursiva 
3) llamado de segunda funcion recursiva 
4) llamado de tercera funcion recursiva
5) llamado de cuarta funcion recursiva
6) retorno de 0
7) 0 + lowerfuncion recursiva4= 4
8) 4 + lowerfuncion recursiva3= 3
9) 7 + lowerfuncion recursiva2= 2
10) 9 + lowerfuncion recursiva1= 1
11) 10
'''

Omar Daniel Centeno

Que divertido el código, sencillo, pero pone a prueba el pensamiento lógico.

Joseph Humberto Cueva

En https://pythontutor.com pueden escirbir codigo y visualizar cada paso para entender mejor los problemas.

Marcos Mesias

Ya entendí un poco la recursividad, es ir al futuro y luego al pasado. Impresionante.

reality !

Un visualizador que personalmente me gusta mucho y pienso que es muy útil es: Python Tutor: Visualize code in Python. Se los recomiendo para entender mejor qué sucede en el código.

David Azael Rangel González

hace 19 días

Les comparto unas preguntas, respuestas y código que me ayudaron a entender, un poco más, esta función recursiva: ```python # Pregunta 1: ¿Por qué el margen disminuye en las llamadas recursivas en pyramid_sum? # Respuesta: El margen no disminuye realmente; aumenta con cada llamada recursiva. # Cuando las llamadas recursivas regresan (se "deshacen"), cada nivel tiene su propio valor de margen almacenado. # Esto da la impresión de que el margen "disminuye", pero en realidad, es que el control está regresando a las llamadas anteriores, # con sus valores respectivos de margen. # Pregunta 2: ¿Dónde o cómo se definió el proceso de "deshacer" la recursión? # Respuesta: El "deshacer" ocurre automáticamente cuando la recursión alcanza su caso base. # En ese momento, las llamadas previas empiezan a resolverse hacia atrás en orden inverso. # Es parte de la estructura inherente de las llamadas recursivas. Cuando se retorna un valor, # el control vuelve al punto donde fue hecha la llamada, continuando con el cálculo pendiente. # Pregunta 3: ¿Por qué, al regresar de las llamadas, result crece con 4, luego 3, y luego 1? # Respuesta: En cada paso de la recursión, el valor retornado se suma al valor actual. # Como el valor actual también incrementa (de 1 a 2 a 3 a 4), cada llamada acumula los resultados en esa cadena. # Pregunta 4: ¿Por qué no ocurre esto con la recursión de Fibonacci? # Respuesta: En Fibonacci, no hay una acumulación lineal de valores. En lugar de eso, cada llamada depende de dos subproblemas, # lo que hace que los resultados se combinen en lugar de acumularse de manera secuencial. # La estructura de Fibonacci es más como un árbol en lugar de una cadena lineal. # Pregunta 5: ¿Cómo o cuándo se define que el resultado de una llamada depende directamente del valor de la siguiente? # Respuesta: Esto se define en el código cuando el resultado de la llamada recursiva es utilizado # como parte del cálculo de la llamada actual. Por ejemplo, en el código pyramid_sum, `result` depende de `pyramid_sum(lower + 1, upper, margin + 4)`, # lo que establece la dependencia directa entre cada llamada recursiva. # Ejemplo de código de `pyramid_sum` con acumulación de resultados: def pyramid_sum(lower, upper, margin=0): blanks = " " * margin print(blanks, lower) if lower > upper: print(blanks, 0) return 0 else: # Llamada recursiva; se suma el valor actual al resultado de la siguiente llamada result = lower + pyramid_sum(lower + 1, upper, margin + 4) print(blanks, result) return result # Ejemplo de ejecución: pyramid_sum(1, 4) # Recursión de Fibonacci, que no acumula de manera lineal sino que combina resultados de múltiples subproblemas: def fibonacci(n): if n == 0: return 0 elif n == 1: return 1 else: # Aquí se combinan dos subproblemas return fibonacci(n - 1) + fibonacci(n - 2) # Ejemplo de ejecución: fibonacci(5) ```

David Azael Rangel González

hace 20 días

Para entender de una manera mas sencilla esta funcion la cambie ligeramente. Para poder entender como trabaja esta función se necesitan capas adicionales de conocimiento: a. Cómo trabajan las funciones recursivas. b. Hay variantes de llamadas recursivas dependiendo de como estén diseñadas. c. Existe un stack de ejecución cuando el resultado de una función recursiva depende de un llamado posterior A partir de este conocimiento se puede encontrar un patrón para identificar los distintos tipos de patrones de llamadas recursivas. Pero he dicho mucho y nada, después pondré la explicación a profundidad con ejemplos. Ah, la función: ```python def pyramid_sum(lower, upper, margin=0): blanks = " " * margin # Crea una cadena de espacios para la sangría visual print(blanks, lower) # Imprime el valor de 'lower' con la sangría actual if lower > upper: # Caso base: si 'lower' es mayor que 'upper' print(blanks, 0) # Imprime 0 con la sangría actual return 0 # Retorna 0 y termina esta rama de la recursión else: # Si 'lower' <= 'upper', sigue recursivamente result = lower + pyramid_sum(lower + 1, upper, margin + 4) print(blanks, result) # Imprime el resultado con la sangría actual return result # Retorna el resultado de la suma recursiva # misma funcion con explicacion diferente def pyramid_sum(lower, upper, margin=0): # margen visual para ilustrar las llamadas blanks = " " * margin print(blanks, lower) # Muestra el valor actual # Caso base: si el valor 'lower' excede a 'upper', detener recursión if lower > upper: print(blanks, 0) return 0 else: # Aquí ocurre la recursión: se llama a la función con un valor mayor de 'lower' result = lower + pyramid_sum(lower + 1, upper, margin + 4) print(blanks, result) # Muestra el resultado acumulado return result ```

Andrés Cardona

hace 8 meses

Explícación: 1. Cuando `lower` es mayor que `upper`, la función imprime el valor de `lower` y `upper`, luego imprime cero y devuelve cero como resultado. 2. En la llamada recursiva anterior a la actual, se había acumulado un valor `result` que corresponde a la suma de todos los números desde `lower` hasta `upper`. 3. Esta llamada recursiva devuelve el valor de `result` más `lower`, que es el valor de `lower` de la llamada anterior más uno. 4. Este valor se imprime y se devuelve a la llamada recursiva anterior. 5. En la llamada recursiva anterior, este valor se suma al valor de `lower` de esa llamada y se devuelve nuevamente. 6. Este proceso continúa hasta que se llega a la llamada original de la función, donde se tiene el resultado final.

Andrés Cardona

hace 8 meses

cv cbcb

Andrés Cardona

hace 8 meses

c cv

Santiago Ahumada Lozano

Me puse a profundizar un poco sobre como funciona la operacion piramide y deduje que es la suma de los números desde ```lower``` hasta ```upper```: \* Definamos la operacion aΔb como `Piramid_sum(a, b)` \* Entonces por ejemplo `Piramid_sum(1, 4)` lo podemos representar por 1Δ4 \* Calculemos 1Δ4: \* 1Δ4 = 1 + (2Δ4) = 1 + 2 + (3Δ4) = 1+2+3+4+(5Δ4) = 1+2+3+4+0 = 1+2+3+4 \* De forma parecida podemos concluir que `Piramid_sum(lower, upper)=lower+(1+lower)+..+upper`

Mario Alexander Vargas Celis

def pyramid_sum(lower , upper ,margin = 0):
    blanks = " " * margin
    print(blanks, lower, upper)
    if lower > upper:
        print(blanks, 0)
        return 0
    else:
        result = lower + pyramid_sum(lower + 1, upper, margin + 4)
        print(blanks, result)
        return result
    
pyramid_sum(1 , 5)

jhon freddy tavera blandon

‘’’

Iteración: Puedes iterar sobre los elementos de una colección usando bucles como for. Por

ejemplo:'''
mi_lista = [1, 2, 3]
for elemento in mi_lista:
   print(elemento)  # Imprimir cada elemento de la lista

mi_diccionario = {'clave': 'valor'}
for clave, valor in mi_diccionario.items():
   print(clave, valor)  # Imprimir cada clave y valor del diccionario

Nicolas Alpargatero

Pythonistas les comparto algo que aprendí por si alguien también se preguntaba. Desde el IDE con python el debugger tiene una opción que dice Step Into esta es para cuando llega a 0 la presionamos y nos seguirá mostrando por dentro el print step by step.
.
y en Jupyter solo era darle line by line desde el inicio para que nos muestra el step by step y como va alimentando las variables.

Nicolas Alpargatero

Me demore un buen rato en entender por qué de 0 pasaba a 4 y así empezar a disminuir, ya que mi debugger saltaba de una de 0 -4-7-9-10 pero sin mostrar el cambio del valor de la variable, me costó comprender, gracias a IA jaja

Sara María Mejia Sánchez

def pyramid_sum(lower, upper, margin = 0): blanks = " " * margin print(blanks, lower, upper) if lower > upper: print(blanks, 0) return 0 else: result = lower + pyramid_sum(lower + 1, upper, margin + 4) print(blanks, result) return result pyramid_sum(1, 4)

Sara María Mejia Sánchez

[] ["Isabel"] ["Isabel", "Mulan"] ["Isabel", "Mulan", 255] ["Isabel", ["Mulan", 255]] fruits = [] fruits.append("Kiwi") fruits.append("Berry") fruits.append("Melon") fruits.sort() fruits.pop() fruits.insert(0, "Apple") fruits.insert(1, "Strawberry") fruits.pop(1) fruits.remove("Apple") # fruits.remove("Dragon fruit")

Sebastian Patricio Menares Arriaza

me fue útil imprimir esto para entender el algoritmo…

x = pyramid_sum(1, 4)
print("-------")
print(x)
print("-------")
print(pyramid_sum(1, 4))


"""
en consola...

 1 4
     2 4
         3 4
             4 4
                 5 4
                 0
             4
         7
     9
 10
-------
10
-------
 1 4
     2 4
         3 4
             4 4
                 5 4
                 0
             4
         7
     9
 10
10

"""

Christian Andrés Espinosa Villagómez

Este video en especifico no me gusto , porque el curso es de estructuras de datos y en este video empezo a hablar acerca de lista y termina haciendo un ejemplo en código en donde en ninguna lado uso una estructura de datos. No tiene que ver lo uno con lo otro. Acaso se emociono.

Ferney Builes

https://youtu.be/ddcY66Hp74g

Jonathan Osorio

Si para algunos aún se les dificulta entender como trabaja una función recursiva, esta es una explicación que me ayudo mucho a entenderlo:
Cuando se llama a una función con esta característica, se da la particularidad de que dentro del código esta nuevamente el llamado a si misma, lo que hace que la función que se llamo la primera vez entre en “pausa” mientras se ejecuta nuevamente la función con los argumentos que nosotros hayamos establecido dentro del código de la función, durante dicha ejecución al encontrarse nuevamente con el llamado a si misma, la anterior (es decir la segunda que se ejecuto) también estará en “pausa” hasta que la siguiente función se ejecute, se llame nuevamente y así sucesivamente.
Entonces para obtener el resultado esperado y también para evitar un loop infinito de llamado de funciones es importante establecer unas condiciones durante cada llamado a la función (donde una de estás sea que retorne algo que detenga la ejecución de funciones) y ajustar los argumentos para que cuando llegue al último llamado de la función, esta comience a retornar los datos que su función predecesora necesita para también retornar su resultado a su respectiva función predecesora y así sucesivamente hasta llegar al primer llamado de la función y retornar el resultado.

Este código también lo pude aclarar:

num = int(input('Number:  '))

def conNum(a):
    if a == 0:
        return 0
    print(a)
    return a + conNum(a-1)

print(conNum(num))

## si el número es 4 (solo seguir flechas ↓)
# conNum(4) 
#    ↓↓↓                ↑↑↑ devuelve 10 ↑↑↑(RESULTADO)
#     4 no es igual a 0
#     imprime 4 
#     return 4 + conNum(3)
#       sig ejec ↓↓↓               ↑↑↑ devuelve 6 ↑↑↑
#                 3 no es igual a 0
#                 imprime 3 
#                 return 3 + conNum(2)
#                   sig ejec ↓↓↓               ↑↑↑ devuelve 3 ↑↑↑
#                             2 no es igual a 0
#                             imprime 2
#                             return 2 + conNum(1) 
#                               sig ejec ↓↓↓               ↑↑↑ devuelve 1 ↑↑↑
#                                         1 no es igual a 0
#                                         imprime 1
#                                         return 1 + conNum(0) 
#                                           sig ejec ↓↓↓            ↑↑↑ devuelve 0 ↑↑↑
# (es la condición inicial, solo seguir flechas ↑)    0 es igual a 0
#                                                     return 0

Espero esto les ayude en algo.

edwen

Michelle Duque De La Rosa