Listas y mutabilidad
Curso de Introducción al Pensamiento Computacional con Python
Contenido del curso
Miguel Torres
Jose Colmenares
Miguel Torres
Bernardo Aranguren Jaimes
Carlos Andres Perez Zapata
Sebastian Cifuentes
Karl Behrens Gil
Willington Ortiz
Jaime Jesús González Muñoz
Wilmer Ropero C
Rafael Ortiz
Lorenzo Enrique Piñango Cerezo
Carli Code
Profesor
Carlos Rodríguez
Marcos Monteverde
José Ocando
Carmen Sánchez Salgado
Marcos ismael Caballero reyes
Santiago Rios Olaya
Felipe Andrés González Quintero
Harrinson Quintero
Manuel Alejandro Hermoso
Francisco Javier Mendoza Flores
Lorenzo Enrique Piñango Cerezo
Victor Inojosa
Sara Yaneth Contreras Elías
Carlos Andres Ocampo Pabon
Cristian Risueño Celedonio
Sebastián Andrade
Cristian Blandon
Sebastian CA
Sebastian Cifuentes
Juan Pisco
Sebastian Cifuentes
Marco Antonio González Arellano
Andrés Álvarez
Cesar Eduardo Montoya Santiago
Gean Carlo Reyes Alayo
Ricardo Morales
David Ruiz
edwin mateus
Alejandro Giraldo Londoño
Francisco Javier Aguilar Lara
Marcos Monteverde
:D Acá investigue los métodos de listas: https://docs.python.org/3/tutorial/datastructures.html#more-on-lists
Los nuevos que encontré además de los de la clase:
Grande Miguel!
Gracias @jlrcolcor :D
Crear una lista: mylist = ['one', 20, 5.5, [10, 15], 'five'] listas mutables: mylist = ['one', 'two', 'three', 'four', 'five'] mylist[2] = "New item" Si el índice es negativo, cuenta desde el último elemento. elem = mylist[-1] Recorrer una lista: for elem in mylist: print(elem) Actualizar elementos: mylist = [1, 2, 3, 4, 5] for i in range(len(mylist)): mylist[i]+=5 print(mylist) mylist = ['one', 20, 5.5, [10, 15], 'five'] print(len(mylist)) Cortar una lista: mylist = ['one', 'two', 'three', 'four', 'five'] mylist[1:3] = ['Hello', 'Seven'] print(mylist) Insertar en una lista: mylist = [1, 2, 3, 4, 5] mylist.insert(1, 'Hello') print(mylist) Agregar a una lista al final: mylist = ['one', 'two', 'three', 'four', 'five'] mylist.append("new one") mylist = ['one', 'two', 'three', 'four', 'five'] list2 = ["Hello", "new one"] mylist.extend(list2) print(mylist) Ordenar una Lista: mylist = ['cde', 'fgh', 'abc', 'klm', 'opq'] list = [3, 5, 2, 4, 1] mylist.sort() list.sort() print(mylist) print(list) Invertir una lista: mylist = [1, 2, 3, 4, 5] mylist.reverse() print(mylist) Indice de un elemento: mylist = ['one', 'two', 'three', 'four', 'five'] print(mylist.index('two')) Eliminar un elemento: mylist = ['one', 'two', 'three', 'four', 'five'] removed = mylist.pop(2) print(mylist) print(removed) mylist.remove('two') del mylist[2] mylist = ['one', 'two', 'three', 'four', 'five'] del mylist[1:3] print(mylist) Funciones agregadas: mylist = [5, 3, 2, 4, 1] print(len(mylist)) print(min(mylist)) print(max(mylist)) print(sum(mylist)) Comparar listas: mylist = ['one', 'two', 'three', 'four', 'five'] list2 = ['four', 'one', 'two', 'five', 'three'] if (mylist == list2): print("match") else: print("No match") Operaciones matematicas en las listas: list1 = [1, 2, 3] list2 = [4, 5, 6] print(list1 + list2) print(list1 * 2) Listas y cadenas: mystr = "LikeGeeks" mylist = list(mystr) print(mylist) mystr = "LikeGeeks" mystr = "Welcome to likegeeks website" mylist = mystr.split() print(mylist) Unir una lista: mylist = ['Welcome', 'to', 'likegeeks', 'website'] delimiter = ' ' output = delimiter.join(mylist) print(output) Aliasing: mylist = ['Welcome', 'to', 'likegeeks', 'website'] list2 = mylist list2[3] = "page" print(mylist)
increible aporte, gracias!
Interesante, gracias!
Listas y mutabilidad
Las listas son secuencias de objetos, pero a diferencia de las tuplas y rangos, sí son mutables. Es posible iterar con ellas, y cuando modificas una lista, pueden existir efectos secundarios (side effects).
Para modificar una lista podemos:
"""Vamos a generar nuestra primera lista""" my_list = [1, 2, 3] """Para acceder al primer índice lo haremos de la siguiente forma""" my_list[0] 1 ######################################################## """Si queremos utilizar la notación de slices (dividir) definimos los índices en los que dividiremos nuestra lista.""" """Aquí llamaremos desde el 2do indice hasta el final.""" my_list[1:] [2, 3] ######################################################## """Para agregar un item a nuestra lista lo haremos con la funcion append my_list.append(4)""" """Ahora la lista tendra 4 objetos.""" print(my_list) [1, 2, 3, 4] ######################################################## """Para modificar un elemento podemos hacerlo referenciando su índice""" my_list[0] = 'a' print(my_list) ['a', 2, 3, 5] ######################################################## """El método pop eliminara el último elemento de nuestra lista""" my_list.pop() 4 print(my_list) ['a', 2, 3] ######################################################## """Cuando una variable hace referencía a una lista significa que apunta al mismo espacio en memoria, esto significa que si cambia la lista se vera reflejado en todas sus referencias, esto es un side effect""" """Creamos la lista a""" a = [1, 2, 3] """Creamos la lista b que hara referencía a la lista a""" b = a """Si imprimimos las listas seran iguales""" a [1, 2, 3] b [1, 2, 3] """Si agrego un objeto a la lista a también se vera reflejado en b""" a.append(4) a [1, 2, 3, 4] b [1, 2, 3, 4] """Por esto debes tener mucho ojo al modificar las listas."""
Clonación
Casi siempre es mejor clonar una lista en vez de mutarla, esto nos ayuda a disminuir el riesgo de pérdida de la información. Para clonar una lista podemos utilizar rebanadas (slices) o la función list.
"""Crearemos una lista a""" a = [1, 2, 3] """Con la variable b clonaremos la lista a""" b = list(a) """Si removemos el último elemento de a no se vera reflejado en b""" a.pop() 3 """Veamos los elementos de a""" a [1,2] """Y los elementos de b""" b [1, 2, 3]
List comprehension
Es una forma concisa de aplicar operaciones a los valores de una secuencia. También se pueden aplicar condiciones para filtrar.
"""Vamos a crear una lista con una operacion de range""" my_list = list(range(10)) """Si revisamos que contiene veremos que tiene todos los numeros desde el 0 al 9""" my_list [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] ########################################################### """Ahora aplicaremos un list comprehension en donde vamos a multiplicar * 2 cada uno de los elementos""" double = [i * 2 for i in my_list] """Y si revisamos los elementos de la lista veremos""" double [0, 2, 4, 6, 8, 10, 12, 14, 16, 18] ########################################################### """Otro ejemplo de list compregension puede ser solo tomar los numeros pares de nuestra lista""" pares = [i for i in my_list if i % 2 == 0] """Y si revisamos los elementos de la lista veremos""" pares [0, 2, 4, 6, 8]
Gran aporte, sobre todo lo de list comprehension
Gracias por el resumen, es muy práctico tenerlo
Gracias
Gracias!
Les comparto el link de la** documentación oficial** de python para listas :) : https://docs.python.org/3/tutorial/datastructures.html
Grandioso tu aporte.
es muy valioso esto!
Siempre la documentación es el mejor recurso = )
gracias por el dato
#metodo append >>>my_list=[1,2,3] >>>my_list.append(4) [1,2,3,4] #metodo insert >>>my_list=[1,2,3] >>>my_list.insert(0,-1) #lista.insert(#indice,#valor) [-1,1,2,3] #metodo extend >>>my_list=[1,2,3] >>>my_list2=[4,5,6] >>>my_list.extend(my_list2) [1,2,3,4,5,6] #metodo index #Devuelve la posicion de un elemento en la lista #sino esta en la lista, arroja error >>>my_list=[1,2,3] >>>my_list.index(1) 0 #indice del valor 1 >>>my_list.index(4) error #metodo remove >>>my_list=[1,2,3] >>>my_list.remove(3) [1,2] >>my_list.remove(3) error #3 ya no esta en la lista #metodo sort >>>my_list=[3,1,2] >>>my_list.sort() #forma ascendente [1,2,3] >>>my_list.sort(reverse=True) #forma descendente [3,2,1] #metodo reverse >>>my_list=[5,2,1,3] >>>my_list.reverse() [3,1,2,5] #invierte la lista #metodo pop >>>my_list=[1,2,3,4] >>>my_list.pop(0) #my_list.pop(#indice) 1 [2,3,4] #my_list[3] no existe >>>my_list.pop(3) error #no existe ese indice
Super util este resumen
Gracias por el aporte me fue de mucha utilidad.
**Métodos de una lista: **
list.append(element)
Añade un elemento al final de la lista. Equivalente a my_list[len(my_list):] = [x]
list.extend(iterable)
Extiende una lista añadiendo todos los elementos de un iterable. Equivalente a my_list[len(my_list):] = iterable.
list.insert(index, element)
Inserta un elemento x en la posición i. Por ejemplo: my_lista.insert(0,x) inserta un elemento al comienzo de la lista. También si hacemos my_list.insert(len(my_list), x) es equivalente a my_list.append(x).
list.remove(element)
Elimina el primer elemento de la lista cuyo valor sea igual a x. Lanza una excepción “ValueError” si no encuentra ningún valor igual.
list.pop([index])
Elimina el elemento en la posición i, y lo devuelve. Si no se especifica el indice list.pop() elimina el ultimo elemento en la lista y lo devuelve. (Los corchetes alrededor de la i en la firma del método denotan que el parámetro es opcional, no que se debe escribir corchetes en esa posición. Se verá esta notación con frecuencia en la Referencia de la biblioteca de Python).
list.clear()
Elimina todos los elementos de la lista. Equivalente a del my_list[:].
List.index(element, start, end)
Devuelve el primer indice de un elemento con un valor igual al elemento especificado como parámetro. start(opcional) establece un indice donde comenzar la búsqueda, end(opcional) establece el indice donde finalizará la búsqueda. Devuelve la excepción “ValueError” si no encuentra ninguna ocurrencia.
List.count(element)
Devuelve el numero de veces que un elemento aparece en la lista.
list.sort(key=None, reverse=False)
Organiza una lista, no devuelve ningun valor pero modifica la lista. key(opcional) pasa un método por parámetro para personalizar la forma en la que se organiza la lista. reverse(False por defecto) si lo ponemos True obtendremos una lista organizara al revés.
list.reverse()
Invierte el orden de la lista.
list.copy()
Nueva función de Python 3 que devuelve una copia de la lista tal como lo hace list() y/o [::]
Y hay mas! documentación oficial aquí
¡Excelente aporte!
Buen aporte :)
Una tercera forma para clonar una lista es usando el método copy()
a = [1,2,3] b = a.copy()
++¿Cuáles son todos los métodos que Python incluye en las listas?++
append() Añade un ítem al final de la lista:
Primera posición (0):
pop() Extrae un ítem de la lista y lo borra:
remove() Borra el primer ítem de la lista cuyo valor concuerde con el que indicamos:
reverse() Le da la vuelta a la lista actual:
Gracias por el aporte <3
Una lista sería un array?
Asi es, lo que en Python llamamos listas en lenguajes como C++ les llaman arrays
Una lista es una estructura de datos... En Python no hay "arrays" como tal.
Los "arrays" en Java o en C son inmutables y estáticos (con un tamaño previamente definido)... Las listas en Python son dinámicas y mutables.
Python has a set of built-in methods that you can use on lists/arrays.
Method Description append() Adds an element at the end of the list clear() Removes all the elements from the list copy() Returns a copy of the list count() Returns the number of elements with the specified value extend() Add the elements of a list (or any iterable), to the end of the current list index() Returns the index of the first element with the specified value insert() Adds an element at the specified position pop() Removes the element at the specified position remove() Removes the first item with the specified value reverse() Reverses the order of the list sort() Sorts the list
¿Listas == array?
Estas en lo correcto compañero, las listas son lo mismo que los arreglos, recuerda que para definir que tu objeto sea una lista, debes usar [] luego de ponerle el nombre a tu array :D
Un saludo.
Oh genial, gracias.
También podemos voltear (ordenar al revés) una lista. (También aplica para cadenas de texto)
Listas
Adicional podemos hacer unpacking, slicing, etc...
En la documentacion dice , que no se pueden usar Array , pero se puede usaren su lugar Listas, con los siguientes metodos Method Description append() Adds an element at the end of the list clear() Removes all the elements from the list copy() Returns a copy of the list count() Returns the number of elements with the specified value extend() Add the elements of a list (or any iterable), to the end of the current list index() Returns the index of the first element with the specified value insert() Adds an element at the specified position pop() Removes the element at the specified position remove() Removes the first item with the specified value reverse() Reverses the order of the list sort() Sorts the list
append() Añade un ítem al final de la lista: Código lista = [1,2,3,4,5] lista.append(6) lista Resultado clear() Vacía todos los ítems de una lista: Código lista.clear() lista Resultado extend() Une una lista a otra: Código l1 = [1,2,3] l2 = [4,5,6] l1.extend(l2) l1 Resultado count() Cuenta el número de veces que aparece un ítem: Código ["Hola", "mundo", "mundo"].count("Hola") Resultado index() Devuelve el índice en el que aparece un ítem (error si no aparece): Código ["Hola", "mundo", "mundo"].index("mundo") Resultado insert() Agrega un ítem a la lista en un índice específico: Primera posición (0): Código l = [1,2,3] l.insert(0,0) l Resultado Penúltima posición (-1): Código l = [5,10,15,25] l.insert(-1,20) l Resultado Última posición en una lista con len(): Código l = [5,10,15,25] n = len(l) l.insert(n,30) l Resultado Una posición fuera de rango añade el elemento al final de la lista (999): Código l.insert(999, 35) l Resultado pop() Extrae un ítem de la lista y lo borra: Código l = [10,20,30,40,50] print(l.pop()) print(l) Resultado Podemos indicarle un índice con el elemento a sacar (0 es el primer ítem): Código print(l.pop(0)) print(l) Resultado remove() Borra el primer ítem de la lista cuyo valor concuerde con el que indicamos: Código l = [20,30,30,30,40] l.remove(30) print(l) Resultado reverse() Le da la vuelta a la lista actual: Código l.reverse() print(l) Resultado Las cadenas no tienen el método .reverse() pero podemos simularlo haciendo unas conversiones: Código lista = list("Hola mundo") lista.reverse() cadena = "".join(lista) cadena Resultado sort() Ordena automáticamente los ítems de una lista por su valor de menor a mayor: Código lista = [5,-10,35,0,-65,100] lista.sort() lista Resultado Podemos utilizar el argumento reverse=True para indicar que la ordene del revés: Código lista.sort(reverse=True) lista
Muy buen aporte, muchas gracias!
Metodos de las listas:
buen aporte..
RESUMEN: Listas y mutabilidad
Estructura de objetos mutable.Lista.
Son secuencias de objetos pero a diferencia de tuplas si son mutables Cuando modificas una lista pueden existir efectos secuendarios (sideffects), Podemos ir creciendo la memoria. Cada vez que mutamos la lista puede haber un bug. Es posible iterar con ellas.
Podemos utilizar, appedn, pop, remove, insert, etc... métodos de lista.
lista=[]
Tambien podemos usar la notación de slices.
lista_one=[1,2,3] lista_one.append(n) => Me igresa n valor de cualquier tipo.
a =[1,2] b = a id(a) = id(b) Y esto no debe ocurrir Al asignar b y a volviendolos el mismo objeto si hago un append en uno será reflejado en el otro.
CONCEPTO:Clonación
Muchos patrones de diseño obligan a que no exista muabilidad precismanete para eliminar el problema de llistas apuntando al mismo espcio en memoria.
Esto evita los side effects.
a = [1, 2, 3, 4] b = a c = list(a) print(f' Mi lista a {a[:]} tiene en memoria el id de: {id(a)}') print(f' Mi lista b {b} tiene en memoria el id de: {id(b)}') print(f' Mi lista {c} tiene en memoria el id de: {id(c)}')
Una forma de clonar más compacta es:
d = a[::] => Le estoy indicando que me tome desde el principio hasta el final contando de 1 en 1.
CONCEPTO:List comprehension
my_list = list(range(100)) print(f'quiero operar my_list de valores: \n {my_list}') print('A continuación la notación de List comprehensión \n') double =[i ** 2 for i in my_list] print('[i ** 2 for i in my_list] ') print(f'Mi lista con todos sus valores elevados al cuadrado:\n {double}') pares = [i for i in my_list if i % 2 == 0] print(f'Mi lista con todos sus valores pares:\n {pares}')
Existen metodos como: .extend .insert .remove .pop .append .clear .index .count .sort
Para ver más de la docuementación:
list.append(x) Agrega un ítem al final de la lista. Equivale a a[len(a):] = [x].
list.extend(iterable) Extiende la lista agregándole todos los ítems del iterable. Equivale a a[len(a):] = iterable.
list.insert(i, x) Inserta un ítem en una posición dada. El primer argumento es el índice del ítem delante del cual se insertará, por lo tanto a.insert(0, x) inserta al principio de la lista, y a.insert(len(a), x) equivale a a.append(x).
list.remove(x) Quita el primer ítem de la lista cuyo valor sea x. Es un error si no existe tal ítem.
list.pop([i]) Quita el ítem en la posición dada de la lista, y lo devuelve. Si no se especifica un índice, a.pop() quita y devuelve el último ítem de la lista.
list.clear() Quita todos los elementos de la lista. Equivalente a del a[:].
list.index(x[, start[, end]]) Devuelve un índice basado en cero en la lista del primer ítem cuyo valor sea x. Levanta una excepción ValueError si no existe tal ítem. Los argumentos opcionales start y end son interpetados como la notación de rebanadas y se usan para limitar la búsqueda a una subsecuencia particular de la lista. El index retornado se calcula de manera relativa al inicio de la secuencia completa en lugar de con respecto al argumento start.
list.count(x) Devuelve el número de veces que x aparece en la lista.
list.sort(key=None, reverse=False) Ordena los ítems de la lista in situ (los argumentos pueden ser usados para personalizar el orden de la lista, ve sorted() para su explicación).
list.reverse() Invierte los elementos de la lista in situ.
list.copy() Devuelve una copia superficial de la lista. Equivalente a a[:].
Buen aporte, gracias!! 😄
