¿Cuáles son las operaciones esenciales en las colecciones de Python?
Cuando manejamos colecciones en Python, es vital comprender las operaciones básicas que se pueden realizar sobre ellas. Estas operaciones son fundamentales para manipular y gestionar datos de manera eficiente. Algunas de las operaciones más comunes incluyen:
Conocer el tamaño: Determina cuántos elementos hay dentro de una colección.
Verificar pertenencia: Permite comprobar si un elemento específico pertenece a la colección.
Recorrer la colección: Recorrido a través de cada uno de sus elementos o a través de un cierto límite.
Conversión a string: Representa en forma de cadena tanto la colección completa como uno de sus elementos.
Comparación de colecciones: Verifica si dos colecciones son iguales o diferentes.
Concatenación: Unión o suma de listas y diccionarios.
Conversión de tipo de colección: Posibilidad de cambiar de un tipo de colección o dato a otro.
Inserción y eliminación de elementos: Agregar o quitar elementos al inicio, al final o en una posición específica.
Acceso y modificación de elementos: Consultar o modificar el tipo de datos, el valor o cualquier otra información relevante de un elemento.
Ésos son solo algunos ejemplos de lo que es posible hacer con las colecciones en Python, lo cual otorga una gran flexibilidad para el manejo de datos.
¿Cuáles son los métodos principales al trabajar con listas en Python?
Las listas en Python son colecciones muy versátiles. A continuación, algunos de los métodos más importantes que se pueden utilizar para manejarlas:
Añadir y eliminar elementos
append(): Añade un elemento al final de la lista.
insert(index, elem): Inserta un elemento en una posición específica.
pop([index]): Elimina y retorna un elemento de una posición determinada o el último si no se especifica el índice.
remove(elem): Elimina la primera aparición del elemento especificado.
Ordenar y consultar la lista
sort(): Ordena los elementos alfabéticamente si son cadenas o numéricamente si son números.
index(elem): Devuelve el índice de la primera aparición del elemento especificado.
count(elem): Cuenta cuántas veces aparece un elemento en la lista.
Veamos un ejemplo con código para ilustrar cómo trabajar con listas:
# Creación de una lista vacíafruits =[]# Agregar elementos a la listafruits.append('kiwi')fruits.append('berry')fruits.append('melón')# Consultar la listaprint(fruits)# Salida: ['kiwi', 'berry', 'melón']# Ordenar la listafruits.sort()print(fruits)# Salida: ['berry', 'kiwi', 'melón']# Eliminar y retornar el último elementolast_item = fruits.pop()print(last_item)# Salida: 'melón'
¿Cómo funciona una función recursiva en Python?
La recursividad es un concepto poderoso en programación, donde una función se llama a sí misma para resolver un problema. Este enfoque puede ser ventajoso para problemas que se pueden descomponer en problemas más pequeños y similares.
A continuación, un ejemplo de una función recursiva que suma números y los muestra en forma de pirámide:
defpyramid_sum(lower, upper, margin=0): blanks =" "* margin
print(blanks +str(lower)+str(upper))if lower > upper:return0else: result = lower + pyramid_sum(lower +1, upper, margin +4)print(blanks +"Resultado: "+str(result))return result
# Llamada a la función pirámidepyramid_sum(1,4)
Recomendaciones para el aprendizaje de funciones recursivas
Analiza el flujo de la función: Comprender cómo y cuándo la función se llama a sí misma es crucial.
Identifica la condición base: Asegúrate de que la función tenga una condición que detenga la recursividad, evitando un bucle infinito.
Practica con ejemplos sencillos: Construir una comprensión sólida comenzando con problemas simples y luego avanzando a casos más complejos.
Recuerda que la recursividad, al igual que muchas técnicas en programación, se beneficia enormemente de la práctica y la repetición. No dudes en volver a cursos anteriores para reforzar tus conceptos.
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.
Uff me sirvió bastante esa herramienta 👍
de gran ayuda
!gif
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
Te quedo excelente y ahora entiendo mucho mejor el concepto. Gracias por hacerlo.
Gracias por tu aporte
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.
'''defpyramid_sum(lower, upper, margin =0): blanks =" "* margin
print(blanks, lower, upper)if lower > upper:print(blanks,0)return0else:# Llamada recursiva result = lower+ pyramid_sum(lower +1, upper, margin +4)print(blanks, result)return result
pyramid_sum(1,10)
Excelente Resumen!
Gracias por tu aporte
¿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.
ni el profe entiende, checa como esta subiendo la mirada a un monitor que debe de tener enfrente de el y sólo esta de capturista de datos y leyendo el código, así hasta yo me meto de maestro.
Muchas gracias por el muy buen tutorial, mil gracias
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)return0 # 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 10else: # 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 07)0+ lowerfuncion recursiva4=48)4+ lowerfuncion recursiva3=39)7+ lowerfuncion recursiva2=210)9+ lowerfuncion recursiva1=111)10'''
Realice una pequeña modificacion a la piramide para que sea mas interactiva y facil de entender, ya que la primera vez si me costo un poco mas entenderla.
Modificar:
print(blanks, result, lower -1)
Con eesto la piramide mostrara en ell area descendente dos valores, el primero es el que llevamos y el segundo el que se le va sumando en cada capa de la recursividad.
No tiene sentido que haga un código que la mayoría no entiende, muchas gracias Alfonso por tomarte el tiempo de explicarlo.
Que divertido el código, sencillo, pero pone a prueba el pensamiento lógico.
Totalmente de acuerdo!
En https://pythontutor.com pueden escirbir codigo y visualizar cada paso para entender mejor los problemas.
Super útil esa herramienta. Muchas gracias.
Ya entendí un poco la recursividad, es ir al futuro y luego al pasado. Impresionante.
Corriendo el debugger pude entenderlo, esta función recursiva me recuerda a la película Inception o el origen en español.
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.
Muchas gracias por la página, me ayudó a entender un poco más, pero sigo sin entender 100% que es lo que hace la función
Hola, ¿Cómo hago para hacer mi aporte de código en esta sección de comentarios y que se vea ordenado?
Hola @andy20!
Justo aquí donde escribes, tienes la barra de herramienta, en ella se encuentra la opción "++insertar código++".
También pudieras hacerlo de forma manual escribiendo tres back quotes (acento grave) ```, seguido del lenguaje que estás escribiendo, por ejemplo para css, quedaría de la siguiente forma:
Esto me dejaría como resultado, lo siguiente:
body{margin:0;}
Fijate que de acuerdo al lenguaje que se especifica al inicio, el editor usa un color para los elementos. :D
Espero haberte ayudado :D
Para agregar, puedes obtener los acentos graves dejando presionada la tecla Alt y enseguida teclear el número 96, una vez lo teclees sueltas la tecla Alt y lo verás en pantalla
Hola a todos, he intentado comprender como funciona la recursividad luego de que el valor en consola retornado es igual a 4,7,9 y 10, agradeceria si alguien sabe me pueda informar donde puedo encontrar información para entenderlo o mejor aun si me pueden regalar un ejemplo, ya que no comprendo el por que estos resultados. Muchas gracias.
Hola Andrés, tienes muy buen ojo para los detalles. Justo en esa parte, donde va disminuyendo los valores surge la duda ¿Dónde le está restando valores o cómo los disminuye?. Después de analizarlo y hacer una prueba de escritorio me di cuenta que no resta nada. El programa funciona de la siguiente manera:
Al iniciar el programa toma los valores que se le pasan a la función lower = 1 upper = 4 y margin = 0, calcula los espacios en blanco e imprime. Después va a el condicional y como lower no es mayor que upper se va por el else. Es en este else donde está todo el detalle. Si te fijas el result está igualado a la suma del lower más lo que regrese la función pyramid_sum pero entra a la función con nuevos parámetros, ahora tiene valores lower = 2, upper = 4 y margin = 4. Al entrar a la función vuelve a calcular los espacios en blanco e imprime y como aún lower no es mayor que upper se sigue por el camino del else y es así hasta que upper alcanza un valor de 5.
Si te das cuenta en todo ese proceso nunca se le contesto con un resultado de la suma de upper más la función pyramid_sum, al campo result, se le empieza a contestar hasta ese lower = 5 porque es cuando entra al if y este regresa 0, es entonces que se van contestando a todas las 'peticiones' anteriores que se hicieron para encontrar el resultado de la operación result, es decir, cuando lower tuvo un valor de 4, 3, 2 y 1, porque todos estos habían quedado pendientes!!!!!.
Imagina que el programa tiene memoria de los resultados que le quedaron a deber y los va cobrando.
Espero te ayude un poco, sino escríbeme por aquí y ya te explico.
Saludos.
Buen día, Bruno:
Muchas gracias por tomarte tu tiempo de leerme y ayudarme a entender el código, para complementar tu explicación, el proceso que se genera de regresión en la solución de las operaciones pendinentes result = lower + pyramid_sum, es que toma el valor del ultimo Lower y toma los valores del return result una vez se cumple el primer return 0, es por ello que los valores de pyramid_sum (0,4,3,2,1) incrementan el resultado pero respeta el valor de blanks.
brunohervi93 gracias y lo que necesites de mi parte a futuro con gusto.
Hola!
En el codigo de piramide puede interpretar como aumenta, pero la parte baja de la piramide donde vuelve a la posicion inicial no logro comprenderlo.
Alguien me podria ayudar?
Hola Adriel,
ahí es donde entra en juego la recursividad. El código va siguiendo el “Stack de ejecución”, que es el orden en el que se fue ejecutando la función recursivamente sin retornar un valor, así como el valor de las variables en cada momento del stack. Espero que la gráfica te ayude un poco a entender. Saludos.
Les comparto unas preguntas, respuestas y código que me ayudaron a entender, un poco más, esta función recursiva:
# 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:defpyramid_sum(lower, upper, margin=0): blanks =" "* margin
print(blanks, lower)if lower > upper:print(blanks,0)return0else:# 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:deffibonacci(n):if n ==0:return0elif n ==1:return1else:# Aquí se combinan dos subproblemasreturn fibonacci(n -1)+ fibonacci(n -2)# Ejemplo de ejecución:fibonacci(5)
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:
defpyramid_sum(lower, upper, margin=0): blanks =" "* margin # Crea una cadena de espacios para la sangría visualprint(blanks, lower)# Imprime el valor de 'lower' con la sangría actualif lower > upper:# Caso base: si 'lower' es mayor que 'upper'print(blanks,0)# Imprime 0 con la sangría actualreturn0# Retorna 0 y termina esta rama de la recursiónelse:# Si 'lower' <= 'upper', sigue recursivamente result = lower + pyramid_sum(lower +1, upper, margin +4)print(blanks, result)# Imprime el resultado con la sangría actualreturn result # Retorna el resultado de la suma recursiva# misma funcion con explicacion diferentedefpyramid_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ónif lower > upper:print(blanks,0)return0else:# 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 acumuladoreturn result
Explícación:
Cuando lower es mayor que upper, la función imprime el valor de lower y upper, luego imprime cero y devuelve cero como resultado.
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.
Esta llamada recursiva devuelve el valor de result más lower, que es el valor de lower de la llamada anterior más uno.
Este valor se imprime y se devuelve a la llamada recursiva anterior.
En la llamada recursiva anterior, este valor se suma al valor de lower de esa llamada y se devuelve nuevamente.
Este proceso continúa hasta que se llega a la llamada original de la función, donde se tiene el resultado final.