¿Qué son las listas en programación y por qué son fundamentales en Python?
Las listas son esenciales en la programación con Python debido a su capacidad para almacenarse como secuencias de objetos mutables. Esto significa que podemos modificar una lista directamente sin tener que crear una nueva copia asignada a la misma variable. Las listas ofrecen flexibilidad en el manejo de datos gracias a su capacidad de cambiar y crecer dinámicamente en memoria.
Mutabilidad: A diferencia de las tuplas, rangos o cadenas, las listas son mutables. Esto permite operaciones como agregar, eliminar o modificar elementos directamente.
Efectos secundarios: Al modificar una lista, es crucial estar al tanto de los efectos secundarios potenciales, como apuntar al mismo lugar en la memoria, lo que puede llevar a errores inesperados en el programa.
Iteración sobre listas: Podemos recorrer una lista para acceder o modificar sus elementos usando bucles for.
¿Cómo modificar y gestionar listas en Python?
Modificar listas implica cambiar sus elementos internos o su estructura, y Python ofrece múltiples métodos para ello.
Métodos esenciales para modificar listas
Existen varios métodos útiles para trabajar y manipular listas:
append(): Añade un elemento al final de la lista.
pop(): Elimina el último elemento de la lista y lo devuelve.
remove(): Elimina el primer elemento que coincide con un valor especificado.
insert(): Inserta un elemento en un índice específico de la lista.
Aquí tienes un ejemplo de cómo crear y modificar una lista:
mi_lista =[1,2,3]mi_lista.append(4)# [1, 2, 3, 4]mi_lista[0]='a'# ['a', 2, 3, 4]mi_lista.pop()# Devuelve 4, dejando la lista como ['a', 2, 3]
Evitar errores con alias y clones en listas
En Python, dos variables pueden apuntar al mismo objeto en memoria. Esto se convierte en una fuente común de errores si se modifica una lista a través de un alias involuntario. Aquí te mostramos cómo evitarlo mediante la clonación:
Clonación con rebanadas: Crea una copia independiente de una lista usando la notación de rebanadas [:].
Uso de la función list(): También puedes usar list() para clonar listas y evitar efectos secundarios.
Ambas formas de clonación crean listas nuevas con las mismas propiedades pero ubicadas en diferentes direcciones de memoria, evitando efectos secundarios no deseados.
¿Cómo optimizar operaciones y filtros en listas?
Comprensiones de listas
Las comprensiones de listas son una herramienta poderosa en Python, que permite aplicar operaciones y filtrar de una manera compacta. Ofrecen una sintaxis rápida para iterar sobre secuencias, aplicar operaciones y generar listas filtradas.
Ejemplo de comprensión de listas para duplicar y filtrar números pares:
mi_lista =list(range(100))# Lista del 0 al 99dobles =[x *2for x in mi_lista]# Multiplica cada elemento por 2pares =[x for x in mi_lista if x %2==0]# Filtra solo números pares
Este enfoque no solo simplifica el código sino que mejora la legibilidad y eficiencia al trabajar con datos dentro de listas.
Invitación a explorar la documentación de Python
Para fortalecer tu comprensión sobre listas y otros conceptos, te recomendamos explorar la documentación oficial de Python. Allí podrás encontrar todos los métodos disponibles para listas, con lo cual no solo expandirás tus conocimientos, sino que podrás compartir tus hallazgos con la comunidad, enriqueciendo el proceso de aprendizaje colectivo. ¡Sigue explorando y aprendiendo!
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 [::]
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
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
Lista con único elemento > lista = [1] (A diferencia de las tuplas a las que se les debía colocar una coma al final para especificar que fuera una tupla y no un entero).
Agregar valor al final > lista.append(n)
Modificar elementos existentes > lista[0] = 1 (Modifica el valor que está en la posición 0 de la lista por el número 1).
Insertar elementos > lista.insert(0,2) (El primer argumento es el índice o ubicación dentro de la lista y el segundo argumento es el elemento a insertar en la lista)
Remover elementos > lista.remove(1) (Remueve el primer elemento que coincida con el argumento indicado, en este caso removería el primer 1 que encuentre). El segundo método es usando DEL > del lista[1] (Elimina el elemento en la posición 1 dentro de la lista, se puede también utilizar el slicing para eliminar varios elementos y para borrar todos los elementos simplemente del lista[:])
Cantidad de elementos > len(lista)
Conversiones > mitupla = tuple(lista) (Convierte de lista a tupla) y milista = list(mitupla) (convierte de tupla a lista).
Buscar elementos > si tengo lista = [1,2,3] hago 3 in lista y me arrojaría True si hago 4 in lista me arrojaría False (en resumen, ValorBuscado in Lista). Otra forma de buscar sería con not in, por ejemplo 1 not in lista arrojaría False porque 1 si está en la lista mientras que 4 not in lista arrojaría True.
Concatenación > Se puede hacer simplemente con lista1 + lista2 o con el comando extend así: lista1.extend(lista2)
Ordenado de elementos > lista.sort()
Invertir Orden > lista.reverse()
Ordenar de mayor a menor > es una combinación de sort y reverse, primero se ejecuta sort y luego reverse.
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
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[:].
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 inmylist:print(elem)Actualizar elementos:mylist =[1,2,3,4,5]for i inrange(len(mylist)): mylist[i]+=5print(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)
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:
Asignar vía índice (my_lista[0] = 5)
Utilizar los métodos de la lista (append, pop, remove, insert, etc.)
"""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()4print(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 *2for 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]
#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
++¿Cuáles son todos los métodos que Python incluye en las listas?++
append()
Añade un ítem al final de la lista:
clear()
Vacía todos los ítems de una lista:
extend()
Une una lista a otra:
count()
Cuenta el número de veces que aparece un ítem:
index()
Devuelve el índice en el que aparece un ítem (error si no aparece):
insert()
Agrega un ítem a la lista en un índice específico:
Primera posición (0):
Penúltima posición (-1):
Última posición en una lista con len():
Una posición fuera de rango añade el elemento al final de la lista (999):
pop()
Extrae un ítem de la lista y lo borra:
Podemos indicarle un índice con el elemento a sacar (0 es el primer ítem):
remove()
Borra el primer ítem de la lista cuyo valor concuerde con el que indicamos:
reverse()
Le da la vuelta a la lista actual:
sort()
Ordena automáticamente los ítems de una lista por su valor de menor a mayor:
append()Añade un ítem al final de la lista:Código
lista =[1,2,3,4,5]lista.append(6)lista
Resultadoclear()Vacía todos los ítems de una lista:Código
lista.clear()lista
Resultadoextend()Une una lista a otra:Código
l1 =[1,2,3]l2 =[4,5,6]l1.extend(l2)l1
Resultadocount()Cuenta el número de veces que aparece un ítem:Código
["Hola","mundo","mundo"].count("Hola")Resultadoindex()Devuelve el índice en el que aparece un ítem(error si no aparece):Código
["Hola","mundo","mundo"].index("mundo")Resultadoinsert()Agrega un ítem a la lista en un índice específico:Primeraposición(0):Código
l =[1,2,3]l.insert(0,0)l
ResultadoPenúltimaposició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
ResultadoUna posición fuera de rango añade el elemento al final de la lista(999):Código
l.insert(999,35)l
Resultadopop()Extrae un ítem de la lista y lo borra:Código
l =[10,20,30,40,50]print(l.pop())print(l)ResultadoPodemos indicarle un índice con el elemento a sacar(0 es el primer ítem):Código
print(l.pop(0))print(l)Resultadoremove()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)Resultadoreverse()Le da la vuelta a la lista actual:Código
l.reverse()print(l)ResultadoLas 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
Resultadosort()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
ResultadoPodemos utilizar el argumento reverse=True para indicar que la ordene del revés:Código
lista.sort(reverse=True)lista
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.
Los side effect
Sucede por ejemplo cuando estamos apuntando al mismo lugar en memoria desde dos variables
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.
Casi siempre e mejor clonar na lista en vez de mutarla
Para clonar podemos usar la notación de slices o podemos usar la función list que vien por defecto en python.
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.
Siempre es mejor clonar las listas
CONCEPTO:List comprehension
Es una forma concisa de crear listas en las que se puede aplicar operaciones a los valores de una secuencia o lista.
También se pueden aplicar condiciones para filtrar.
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 **2for 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}')
