Crea una cuenta o inicia sesi贸n

隆Contin煤a aprendiendo sin ning煤n costo! 脷nete y comienza a potenciar tu carrera

Operaciones esenciales en colecciones

4/23
Recursos

Aportes 29

Preguntas 3

Ordenar por:

驴Quieres ver m谩s aportes, preguntas y respuestas de la comunidad?

o inicia sesi贸n.

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.

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

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)

驴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.

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

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
'''

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

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 馃槃

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

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

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`

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.

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)

鈥樷欌

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

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.

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

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)

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

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

"""

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.

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 鈥減ausa鈥 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 鈥減ausa鈥 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.

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


lower = int(input("Lower: "))
upper = int(input("Upper: "))

pyramid_sum(lower, upper)

Aqu铆 el profesor dice que la fruta es muy deliciosa

Corriendo el debugger pude entenderlo, esta funci贸n recursiva me recuerda a la pel铆cula Inception o el origen en espa帽ol.

Operaciones esenciales en colecciones

El m茅todo append() funciona para a帽adir elementos a la listas ****

El m茅todo pop() funciona para eliminar el 煤ltimo elemento de una lista por defecto pero tambi茅n recibe el par谩metro de posici贸n

El m茅todo sort() funciona para ordenar la lista de forma alfab茅tica

El m茅todo insert() funciona para insertar elementos y esta recibe dos par谩metros; el primero la posici贸n y como segundo el valor

El m茅todo remove() funciona para remover o eliminar elementos de la lista