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

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.

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 😄

Marcos Miguel Mesias Ortiz

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

Joseph Humberto Cueva Mendieta

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

Santiago Ahumada Lozano

hace 8 días

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`

reality !

hace 8 meses

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.

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 Maria Mejia Sanchez

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 Maria Mejia Sanchez

[] ["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