A煤n no tienes acceso a esta clase

Crea una cuenta y contin煤a viendo este curso

Listas y mutabilidad

23/31
Recursos

Aportes 294

Preguntas 27

Ordenar por:

驴Quieres ver m谩s aportes, preguntas y respuestas de la comunidad? Crea una cuenta o inicia sesi贸n.

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

  • lista.extend(iterable) #extiende la lista con valores dentro de un iterable como un range()
  • lista.insert(i, 鈥榲alor鈥) #Agrega un valor en la posici贸n i y recorre todos los dem谩s. No borra nada.
  • lista.pop(i) #Elimina valor en la posici贸n i de la lista.
  • lista.remove(鈥榲alor鈥) #Elimina el primer elemento con ese valor.
  • lista.clear() #Borra elementos en la lista.
  • lista.index(鈥榲alor鈥) #Retorna posici贸n del primer elemento con el valor.
  • lista.index(鈥榲alor鈥, start, end) #Retorna posici贸n del elemento con el valor dentro de los elementos desde posici贸n start hasta posici贸n end)
  • lista.count(鈥榲alor鈥) #Cuenta cu谩ntas veces esta ese valor en la lista.
  • lista.sort() #Ordena los elementos de mayor a menor.
  • lista.sort(reverse = True) #Ordena los elementos de menor a mayor.
  • lista.reverse() #Invierte los elementos
  • lista.copy() #Genera una copia de la lista. Tambi茅n 煤til para clonar listas.
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)

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()
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]

Les comparto el link de la** documentaci贸n oficial** de python para listas 馃槂 :
https://docs.python.org/3/tutorial/datastructures.html

#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

**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 鈥淰alueError鈥 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 鈥淰alueError鈥 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铆

Una tercera forma para clonar una lista es usando el m茅todo copy()

a = [1,2,3]
b = a.copy()

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

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

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

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 ** 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:

Metodos de las listas:

  • append(x): Agrega un item al final de la lista.
  • extend(iterable): extiende la lista a帽adiendo todos los items desde el iterable
  • insert(i,x): Inserta un item en la posici贸n i
  • remove(x): Elimina el primer item de la lista que tenga el valor de x, plantea un Value Error si no encuentra el valor
  • pop([i]): Elmina el item en la posici贸n dada en la lista y lo retorna, si no tiene item elimina el ultimo.
  • clear(): Elimina todos los items de la lista
  • index(x[, start, [, end]]): Retorna la lista de items cuyo valor es igual a x o el slice aplicado como opcional.
  • count(x): Retorna el n煤mero de veces que x aparece en la lista
  • sort(key=None, reverse=False): Ordena los items de la lista en su lugar
  • reverse(): Invierte los valores de la lista en su lugar
  • copy(): Retorna una copia superficial de la lista.

Profesor :
"las listas son mutables y pueden generar bugs"
yo :
馃く

Tambi茅n podemos voltear (ordenar al rev茅s) una lista. (Tambi茅n aplica para cadenas de texto)

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[:].

Listas

  • Lista vac铆a > lista = []
  • 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鈥

Me pareci贸 muy interesante el m茅todo split , que convierte un mensaje en una cadena formada por las palabras del mensaje.

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

Las direcciones en memoria las podemos imaginar como un cubo dividido en bloques. Cuando declaramos una lista y le asignamos un valor la computadora de manera automatice 鈥渁lmacena鈥 este valor en uno de bloques del cubo, por ejemplo al bloque: 6001.

Cuando el profesor codifica:
a=[1,2,3] b=a

simplemente crea una variable 鈥渂鈥 que apunta al mismo bloque de memoria que 鈥渁鈥. Es decir tanto a como b apuntan al bloque 6001.

Entonces, si modificamos a, modificaremos b. Y esto es uno de los bugs mas comunes de los desarrolladores. Para evitar este error, se emplea la CLONACI脫N. Es decir crear una variable que se almacene en el bloque 6002 pero que lea y copie los valores del bloque 6001.

Los m茅todos que se pueden aplicar a las listas son los siguentes:
tomado de: https://docs.python.org/3/tutorial/datastructures.html

list.append()
list.extend()
list.insert()
list.remove()
list.pop()
list.clear()
list.index()
list.count()
list.sort()
list.reverse()
list.copy()```

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 item with the specified value
reverse() Reverses the order of the list
sort() Sorts the list

Esta es la estructura general para un list comprehesion

1.- Valor a agregar a la lista
2.- Un ciclo

Ejemplo:

lista=['x cosa' for valor in range (0,101)] ```

Lo que obtendremos es 100 veces el string 'x cosa'

Y finalmente las condiciones van al final del ciclo



pares=[i for i in my_list if i%2==0]```

Espera sea de ayuda, comunidad Platzi

Listas

  • append: A帽ade un elemento al final de una lista

    • sintaxis: lista.append(鈥榟ola鈥)
  • clear: Elimina todos los elementos de la lista.

    • sintaxis: lista.clear()
  • copy: hace un retorno de los elementos de una lista.

    • sintaxis: nueva_lista = lista.copy()
  • count: retorna el numero de elementos de un valor especifico.

    • sintaxis: list = [1,2,5,1,53,5,3,4,5]; list.count(5) => returned 3
  • extend: Agrega los elementos de una lista al final de la lista actual.

    • sintaxis: nueva_lista.extend(list)
  • index: Devuelve el indice del primer elemento con el valor esfecificado.

    • sintaxis: list.index(5) => returned 2
  • insert: Agrega un elemento en una posici贸n especifica.

    • sintaxis: list.insert(4, 4) => [1,2,5,1,4,53鈥
  • pop: Elimina un elemento de una posici贸n especifica (si no le pasamos nada por parametros, elimina el ultimo elemento de la lista).

    • sintaxis: list.pop(0) => [2,5,1,4,53鈥
  • remove: Elimina los elementos de un valor espefico.

    • sintaxis: list.remove(5) => [2,1,4,53,3,4]
  • reverse: Invierte el orden de la lista

    • sintaxis: list.reverse() => [4,3,53,4,1,2]
  • sort: Ordena la lista.

    • sintaxis: list.sort() => [1,2,3,4,4,53]

Documentaci贸n oficial de las listas en python:
https://docs.python.org/3/library/stdtypes.html#list

https://www.w3schools.com/python/python_ref_list.asp Ac谩 est谩n super bien explicados 馃槃

En 茅sta p谩gina espec铆fica me doy cuenta que es de la que m谩s recursos tiene, por si alguien tambi茅n est谩 aprendiendo otro lenguaje.

hola probe el, pop,con la posicion de la lista que queremos borrar de esta forma:

>>> print(my_list)
[1, 2, 4, 5]
>>> my_list.pop(0) 
1   
>>> print(my_list)    
[2, 4, 5]

Python List/Array Methods

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

Asi pueden ver todos los metodos que se le pueden aplicar a una veriable, en este caso una variable de tipo lista

>>> dir(my_list)
['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']

Notas 馃槂
Listas y mutabilidad

  • Es una estructura de objetos que si es mutable. Son secuencias de objetos.
  • Cuando modificas una lista, pueden existir efectos secundarios (side effects); cada vez que mutamos un tipo de datos, es una posible fuente de bugs.
  • Es posible iterar con ellas.
  • Para modificar una lista:
    • Asignar v铆a 铆ndice my_lista[0] = 5.
    • Utilizar los m茅todos de la lista (append, pop, remove, instert, etc).
  • Si hacemos a = [1, 2, 3], y luego b = a, 隆ambas listas son la misma!, tienen el mismo id (la misma direcci贸n en memoria) porque no estamos declarando b, mas bien la estamos igualando a otro objeto. Para evitar este tipo de errores, debemos hacer b = a.copy().
  • Clonaci贸n:
    • Casi siempre es mejor clonar una lista en vez de mutarla.
    • Para clonar una lista podemos utilizar rebanadas (slices) b = a[::], o la funci贸n list. (En el ejemplo anterior b = list(a)).
  • List comprehension:
    • Es una forma concisa de aplicar operaciones a los valores de una secuencia.
    • Tambi茅n se pueden aplicar condiciones para filtrar.
my_list = [1, 2.3, 'ola', True]
print(my_list[0]) #Primer elemento
print(my_list[1:]) #Todo menos primero

my_list.append(4) #Agregamos 4 al final
my_list[0] = 'a' #Modificamos indice 0

#Nos da el ultimo elemento y lo saca de la lista
ultimo = my_list.pop() 

#Podemos iterarla:
for element in my_list:
	print(my_list)

# Para copiar una lista
other_list = list(my_list)

#Dos nombres para mismo objeto
same_list = my_list
my_list = list(rango(100)) #Lista desde rango

double = [x*2 for x in my_list] #Operaciones

#Condicionales
pares = [x for x in my_list if x%2 == 0]

Ejemplo de:

5. Data Structures - Python 3.9.1 documentation

>>> fruits = ['orange', 'apple', 'pear', 'banana', 'kiwi', 'apple', 'banana']
>>> fruits.count('apple')
2
>>> fruits.count('tangerine')
0
>>> fruits.index('banana')
3
>>> fruits.index('banana', 4)  # Find next banana starting a position 4
6
>>> fruits.reverse()
>>> fruits
['banana', 'apple', 'kiwi', 'banana', 'pear', 'apple', 'orange']
>>> fruits.append('grape')
>>> fruits
['banana', 'apple', 'kiwi', 'banana', 'pear', 'apple', 'orange', 'grape']
>>> fruits.sort()
>>> fruits
['apple', 'apple', 'banana', 'banana', 'grape', 'kiwi', 'orange', 'pear']
>>> fruits.pop()
'pear'

Wow que buena onda, creo que este curdo deber铆a de ir antes que el curso b谩sico de Python

Hola bella comunidad de Platzi

Hoy les comparto que he llegado a la misma cantidad de puntos que la del a帽o en el que nos encontramos. Gracias a todos por sus aportes y apoyo que lo han hecho posible.

Para la ultima version mas estable de Pyhton (3.8), se puede consultar la documentacion de metodos aqui en este LINK

Las listas

Tipo compuesto de dato que puede almacenar distintos valores (llamados 铆tems) ordenados entre [ ] y separados con comas.

numeros = [1,2,3,4]

datos = [4,"Una cadena",-15,3.14,"Otra cadena"]

脥ndices y slicing

Funcionan de una forma muy similar a las cadenas de caracteres.

datos[0]

4

datos[-1]

'Otra cadena'

datos[-2:]

[3.14, 'Otra cadena']

Suma de listas

Da como resultado una nueva lista que incluye todos los 铆tems.

numeros + [5,6,7,8]

[1, 2, 3, 4, 5, 6, 7, 8]

Son modificables

A diferencia de las cadenas, en las listas s铆 podemos modificar sus 铆tems utilizando 铆ndices:

pares = [0,2,4,5,8,10]

pares[3]= 6

pares

[0, 2, 4, 6, 8, 10]

Integran funcionalidades internas, como el m茅todo .append() para a帽adir un 铆tem al final de la lista

pares.append(12)

pares

[0, 2, 4, 6, 8, 10, 12]

pares.append(7*2)

pares

[0, 2, 4, 6, 8, 10, 12, 14]

Y una peculiaridad, es que tambi茅n aceptan asignaci贸n con slicing para modificar varios 铆tems en conjunto

letras = ['a','b','c','d','e','f']

letras[:3]

['a', 'b', 'c']

letras[:3] = ['A','B','C']

letras

['A', 'B', 'C', 'd', 'e', 'f']

Asignar una lista vac铆a equivale a borrar los 铆tems de la lista o sublista

letras[:3] = []

letras

['d', 'e', 'f']

letras = []

letras

[]

La funci贸n len() tambi茅n funciona con las listas del mismo modo que en las cadenas:

len(letras)

0

len(pares)

8

Listas dentro de listas (anidadas)

Podemos manipular f谩cilmente este tipo de estructuras utilizando m煤ltiples 铆ndices, como si nos refier茅ramos a las filas y columnas de una tabla.

a = [1,2,3]

b = [4,5,6]

c = [7,8,9]

r = [a,b,c]

r

[[1, 2, 3], [4, 5, 6], [7, 8, 9]]

r[0]  # Primera sublista

[1, 2, 3]

r[-1]  # 脷ltima sublista

[7, 8, 9]

r[0][0]  # Primera sublista, y de ella, primer 铆tem

1

r[1][1]  # Segunda sublista, y de ella, segundo 铆tem

5

r[2][2]  # Tercera sublista, y de ella, tercer 铆tem

9

r[-1][-1]  # 脷ltima sublista, y de ella, 煤ltimo 铆tem

9
dir(list)
['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']```

my_list.reverse(): la lista se coloca al reverso.
my_list.remove(1): elimina el espacio con el contenido que le mandes como par谩metro.
my_list.insert(0,鈥榟ola鈥): inserta en la lista el par谩metro que le mandes, aunque tienes que mandarle tambi茅n el indice.
my_list.count(2): muestra cuantas veces se repite un valor en la lista.
cmp(list1, list2) :compara los elements de dos listas
len(my_list): muestra la longitud de una lista
my_list.extend(my_list): agrega una secuencia a la lista, en este caso agregue la misma

Para comparar los id tambi茅n podemos hacer en la misma l铆nea y separarlos por comas:

>>> id(a), id(b), id(c)
(140470791671552, 140470791671552, 140470791685760)

M茅todos de las Listas:

append():
A帽ade un 铆tem al final de una 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.

insert():
Agrega un 铆tem a la lista de un 铆ndice espec铆fico.

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.

sort():
Ordena autom谩ticamente los 铆tems de una lista por su valor de menor a mayor.

M茅todos de 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
insert()
Agrega un 铆tem a la lista en un 铆ndice espec铆fico
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
sort()
Ordena autom谩ticamente los 铆tems de una lista por su valor de menor a mayor

https://docs.python.org/es/3.8/tutorial/datastructures.html en la documentacion esta super bien explicado

Listas y mutabilidad

  • Son secuencias de objetos, pero a diferencia de las tuplas, s铆 son mutables.
  • Cuando modificas una lista, pueden existir efectos secundarios (side effects).
  • Es posible iterar con ellas.

Para modificar una lista:

  • Asignar via indice (mi_lista[0] = 5)

  • Utilizar los m茅todos de la lista

    • lista.append(): Agregar un elemento a la lista.
    • lista.pop(): Eliminar el ultimo elemento de la lista.
    • lista.extend(iterable): Extiende la lista con valores dentro de un iterable como un range().
    • lista.insert(i, 鈥榲alor鈥): Agrega un valor en la posici贸n i y recorre todos los dem谩s. No borra nada.
    • lista.pop(i): Elimina valor en la posici贸n i de la lista.
    • lista.remove(鈥榲alor鈥):Elimina el primer elemento con ese valor.
    • lista.clear(): Borra elementos en la lista.
    • lista.index(鈥榲alor鈥): Retorna posici贸n del primer elemento con el valor.
    • lista.index(鈥榲alor鈥, start, end): Retorna posici贸n del elemento con el valor dentro de los elementos desde posici贸n start hasta posici贸n end.
    • lista.count(鈥榲alor鈥): Cuenta cu谩ntas veces esta ese valor en la lista.
    • lista.sort(): Ordena los elementos de mayor a menor.
    • lista.sort(reverse = True): Ordena los elementos de menor a mayor.
    • lista.reverse(): Invierte los elementos.
    • lista.copy(): Genera una copia de la lista. Tambi茅n 煤til para clonar listas.

    >>> mi_lista = [1, 2, 3]
    >>> mi_lista[0]
    1
    >>> mi_lista[1:]
    [2, 3]
    >>> mi_lista.append(4)
    >>> print(mi_lista)
    [1, 2, 3, 4]
    >>> mi_lista[0] = 'a'
    >>> print(mi_lista)
    ['a', 2, 3, 4]
    >>> mi_lista.pop()
    4
    >>> print(mi_lista)
    ['a', 2, 3]
    
    >>> for element in mi_lista:
    ...     print(element)
    a
    2
    3
    >>> a = [1, 2, 3]
    >>> b = a
    >>> a
    [1, 2, 3]
    >>> b
    [1, 2, 3]
    >>> id(a)
    1369622733760256
    >>> id(b)
    1369622733760256 **#Tienen el mismo id, estan apuntando al mismo lugar en memoria
    # A diferencia de las tuplas, si hacemos b = a, ambas estan
    # apuntando al mismo lugar en memoria, por lo que si se modifica
    # una lista se vera reflejado en todas las que se haya asignado**
    
    >>> c = [a, b]
    >>> c
    [[1, 2, 3], [1, 2, 3]]
    >>> a.append(5) **#modificamos solo la lista a**
    >>> a
    [1, 2, 3, 5]
    >>> c
    [[1, 2, 3, 5], [1, 2, 3, 5]] **#como b tenia la misma direccion que a
    #tambien resulto modificada y c, que esta formada por (a, b), que
    #basicamente esta apuntando al mismo lugar que a, tambien resulta modificada**
    
    

    <h3>Clonaci贸n</h3>
    • Casi siempre es mejor clonar una lista en vez de mutarla.
    • Para clonar una lista podemos utilizar rebanadas o la funci贸n list.
    >>> a = [1, 2, 3]
    >>> id(a)
    136962733798656
    >>> b = a
    >>> id(b)
    136962733798656 **#mismo id que a**
    >>> c = lista(a)
    >>> a
    [1, 2, 3]
    >>> b
    [1, 2, 3]
    >>> c
    [1, 2, 3] **#todos tienen el mismo contenido**
    >>> id(a)
    136962733798656
    >>> id(c)
    136962733797936 **#pero como usamos la funcion list con c, tiene una
    #direccion diferente, por lo que es independiente de a
    
    #otra forma de clonar una lista**
    >>> d = a[::] **#recorre toda la lista de uno en uno**
    >>> print(d)
    [1,2,3]
    >>> id(d)
    136962733798096 **#tiene su propia direccion en memoria**
    
    

    <h3>List comprehension</h3>
    • Es una forma concisa de aplicar operaciones a los valores de una lista o secuencia.
    • Tambi茅n se pueden aplicar condiciones para filtrar.
    >>> lista = list(range(100))
    >>> lista
    [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, ... , 99]
    >>> double = [i * 2 for i in lista] #multiplica x2 cada valor de i que recorre la lista
    >>> double
    [0, 2, 4, 6, 8, 10, 12, 14, 16, 18, ... , 198]
    >>> pares = [i for i in list if i % 2 == 0] #filtro para valores pares
    >>> pares
    [0, 2, 4, 6, 8, 10, ... , 96, 98]
    
    

Buen video, poco a poco se va entendiendo m谩s lo especial de este mundo

Aqu铆 les dejo algunos m茅todos para las listas en Python

list.append( x )
Agregua un elemento al final de la lista.

list.extend( iterable )
Extienda la lista agregando todos los elementos del iterable.

list.insert( i , x )
Insertar un elemento en una posici贸n determinada. El primer argumento i es el 铆ndice/posici贸n del elemento a cual insertar, el argumento x es el valor a insertar en la posici贸n i.

list.remove( x )
Elimine el primer elemento de la lista cuyo valor es igual a x . Arroja un ValueError si no hay tal valor/铆ndice.

list.pop( [ i ] )
Elimina el elemento en la posici贸n dada en la lista y lo devuelve. Si no se especifica ning煤n 铆ndice, a.pop() elimina y devuelve el 煤ltimo elemento de la lista. (Los corchetes alrededor de la i en la firma del m茅todo indican que el par谩metro es opcional, no que debes escribir corchetes en esa posici贸n.

list.clear( )
Eliminar todos los elementos de la lista. Esto tambi茅n se puede hacer mediante el m茅todo: del a[:]

list.index( x [ , inicio [ , final ] ] )
Devuelve el 铆ndice basado en cero en la lista del primer elemento cuyo valor es igual a x . Arroja un ValueError si no hay tal valor.

Los argumentos opcionales start y end se interpretan como en la notaci贸n de corte y se usan para limitar la b煤squeda a una sub-secuencia particular de la lista. El 铆ndice devuelto se calcula en relaci贸n con el comienzo de la secuencia completa en lugar del argumento de inicio .

list.count( x )
Devuelve el n煤mero de veces que x aparece en la lista.

list.sort( clave = Ninguno , reversa = Falso )
Ordena los elementos de la lista en su lugar (los argumentos se pueden usar para ordenar la personalizaci贸n de estos).

list.reverse( )
Invierte los elementos de la lista en su lugar.

list.copy( )
Devuelve una copia superficial de la lista. Es lo mismo que: a[:].

Toda esta info y m谩s se puede apreciar aqu铆.

qu茅 buen curso ha sido 茅ste!! me ha gustado mucho!

Ac谩 pueden aprender mas sobre python: https://www.w3schools.com/python/python_lists_methods.asp

Una forma de ver los m茅todos disponibles de un objeto es con la funci贸n dir(objeto).

>>> dir(lista)
['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']

Muy buen curso, el profesor explica de una manera muy amena

Vaya cre铆a que la modificaci贸n era siempre mejor, hasta que mire la clase鈥 馃槄

Les recomiendo que prueben este c贸digo, tiene un poquito de todo

pares = [ i*3 for i in my_list if (i*3)%2 == 0]

Hay un keyword en python que sirve para copiar listas, chequenlo, es .copy(), y al hacer la prueba de id() nos da diferentes direcciones o objetos

Interesante!

Reverse() : Invertir los elementos de una lista.

Que apasionante estos temas de verdad, me motiva much铆simo.

El concepto de clonar es muy importante para evitar bugs.馃槈

Me est谩 fascinado Python 馃槂

Esta es otra forma de ver las funciones que permite utilizar python en las listas.

print(dir(my_list))
['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove',```

Nota:
Si creas otra una lista a partir de otras cualquier modificacion a una se vera reflejada en la otra

Existen otras funciones funciones como:
clear
index
count
sort
reverse
copy
del

Python tambi茅n tiene librer铆a para Queues

Otras formas de modificar listas:

  • Concatenar
  • Asignar usando slices
  • Insert

clear
index
count
sort
reverse
copy
del

Siempre es mejor clonar una lista, interesante clase, si alguno ha visto las lecturas CS50 en youtube existe una donde comentan todo este proceso de los mismos id y se les puede hacer mas facil la comprension de esta clase.

Super clase 馃挭

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

fuente: https://www.w3schools.com/python/python_ref_list.asp

Yo trabajo Web con PHP y podemos hacer for de este tipo:

for ($var as $key => $value) {}

Como seria el equivalente en Python?, E usado

for key, value in var:

pero a veces me a dado error y no se por que 馃槮

En mi caso utilice esta funci贸n de python para copiar un elemento.

e=a.copy()

E igualmente el id en el espacio de memoria es diferente tanto para a como para e.

List comprehension, se entiende como: forma de generar listas (u operarlas)

** Mutable objects:**
list, dict, set, byte array
** Immutable objects:**
int, float, complex, string, tuple, frozen set [note: immutable version of set], bytes

https://medium.com/@meghamohan/mutable-and-immutable-side-of-python-c2145cf72747

Modificar una lista
<lista>[i]=b (es posible)
Metodos de modificacion:
<lista>.appent(<valor>): a帽ade valor al final de la lista
<lista>.pop: regresa el ultimo valor de la lista y lo elimina
<lista>.remove(<valor>): remueve la primera coincidencia con valor
<lista>.insert(<indice>,<valor>): inserta valor en indice

Ac谩 esta mi c贸digo en el que explico linea por linea todos los conceptos vistos en esta clase y algunos mas sobre las listas!
En este link pueden verlo mas detalladamente: https://github.com/EdinsonRequena/articicial-inteligence-and-data-science/tree/master/introduccion-al-computo-con-python/modulo_VI

my_list = [1, 'dos', 3, True, 'cuatro', 5]
print(my_list)
print(my_list[0]) # Imprime indice 0
print(my_list[:2]) # Imprime desde el inidce 0 hasta el 2
print(my_list[1:3]) # Imprime desde indice 1 hasta el 3
print(my_list[2:]) # Imprime desde el indice 2 hasta el ultimo

my_list.append(1) # Agrega un elemento al ultimo indice de la lista, los elementos en una lista pueden repetirse.
print(my_list)

my_list[0] = 'hola' # Modificamos el indice 0 de la lista.
print(my_list)

my_list.pop() # Quitamos el ultimo indice de la lista. 
print(my_list)

z = 3
my_list.insert(1, z) # Aca insertamos el valor de una variable en el indice 1 de la lista.
print(my_list)

my_list.remove(3) # Remueve el valor del elemento (no el indice). 
# Si el elemento tiene el mismo valor que otro dentro de la lista se removera solo el de menor indice.
print(my_list)

for element in my_list: # Iteramos en los elementos de la lista.
    print(element)

a = [1, 2, 3]
b = a
print(b) # Vemos como los elementos de a pasan a estar en b

print(id(a)) # Aca podemos ver como a y b estan en el mismo lugar de
print(id(b)) # memoria, lo que quiere decir que son la misma lista.

c = [a, b] # c sera una lista que contigan las listas de a y b
print(c)
print(id(c)) # Aca podemos ver como c ocupa otro lugar en memoria.

a.append(5)
print(a) # Se agrega el elemento 5
print(b) # Se agrega el elemento 5 tambien porque a y b ocupan el mismo lugar en memoria
print(c) # Esto podemos verlo como si c fuese una caja que contiene las cajas a y b pero al a y b ocupar el mismo
 # espacio en memoria cuando se modifica a tambien se modifica b y viceversa.

a = [1, 2, 3]
b = a
print(b) # Vemos como los elementos de a pasan a estar en b

print(id(a)) # Aca podemos ver como a y b estan en el mismo lugar de
print(id(b)) # memoria, lo que quiere decir que son la misma lista.

c = list(a) # Aca estamos clonando lo que hay en a en c.
print(c) # Aca podemos ver que tienen los mismos elementos.
print(id(c)) # Aca podemos ver que ocupan distintos lugares en memoria.

a.append(5) # Modificamos a, lo que quiere decir que tambien se modifica b
print(a)
print(c) # Aca como podemos ver no se modifica c porque no ocupa el mismo lugar en memoria que a
         # ya que anteriormente habiamos clonado los elementos

d = a [::] # Otra forma de clonar una lista en otra en donde le indicamos que lo hara desde el indice 0 hasta el ultimo.
print(d)
print(id(d)) # Aca podemos ver que ocupan distintos lugares en memoria, lo que quiere decir que si se modifica a no se modificara d.

e = a [0:2] # Aca clonamos los elementos del 0 al 2 en el indice a
print(e)
print(id(e)) # Aca podemos ver que ocupa un lugar distinto en memoria.

lista = list(range(100)) # Creamos una lista con elementos que esten en el rango de 0 a 99.
print(lista)

double = [i * 2 for i in lista] # Multiplicamos por 2 los elementos de la lista.
print(double)

pares = [i for i in lista if i % 2 == 0] # Aca iteramos los elementos en lista si o solo si estos son divisibles entre 2, o sea, son pares.
print(pares)
// Para crear listas se utilizan brackets
my_list = [1, 2, 3, 4]

// Se puede acceder por 铆ndice
my_list[0]

// Se puede reemplazar elementos por su 铆ndice
my_list[0] = 'a'

// Append agrega un elemento al final de la lista
my_list.append(5)

// Pop devuelve y elimina el 煤ltimo elemento de una lista
my_list.pop(4)

print(my_list)

// Las lista se pueden iterar
for element in my_list:
    print(element)

// Aplica la notaci贸n de 'rebanadas'
my_list[1:]
my_list[:3]

Les comparto esta joyita para entender mejor lo que es mutable y no mutable:

Una duda yo quisiera saber si R tambien funciona como python en lo de apuntar a un espacio en memoria o R hace algo completamente distinto

Muy buen curso

desde la terminal pueden ver los m茅todos de las funciones escribiendo help(funcion).
por ejm, para ver los m茅todos de la funci贸n list pueden escribir en la terminar o el editor:
help(list)

Listas:
-Secuencias de objetos mutables
-Cuidado al mutarlas, es una posible funte de bugs
SIntaxis
<nombre>=[<valores>]

Apuntes de la clase

my_list = [1, 2, 3]
# my_list[0]
# 1

# Imprimir de un punto concreto de la lista hasta el final
my_list[1:]
# [2, 3]
# Posici贸n 1 hasta el final de la lista
print(my_list[1:])
# [2, 3]

# Agregar un valor en el siguiente espacio de la lista,
# en este ejemplo 5 se agrega al espacio 3 de la lista(array)
my_list.append(5)
print(my_list)
# [1, 2, 3, 5]

# Asignacion de un nuevo valor a un espacio espec铆fico de la lista
# en este ejemplo el valor 'a' sustituye al valor 1 en el espacio 0 de la lista(array)
my_list[0] = 'a'
print(my_list)
# ['a', 2, 3, 5]

# Eliminar el 煤ltimo valor del 煤ltimo espacio de la lista(array)
# en este ejemplo el valor '5' y el espacio 3 son eliminados de la lista(array)
my_list.pop()
# 4
print(my_list)
# ['a', 2, 3]

# Iteraci贸n de una lista
for element in my_list:
    print(element)
# a
# 2
# 3

# Cuidarnos del siguiente error
a = [1, 2, 3]
b = a
print(a)
# [1, 2, 3]
print(b)
# [1, 2, 3]
print(id(a))
# 123456789987
print(id(b))
# 123456789987

c = [a, b]
print(c)
# [[1, 2, 3], [1, 2, 3]]
a.append(5)
# [1, 2, 3, 5]
print(c)
# [[1, 2, 3, 5], [1, 2, 3, 5]]



# Clonar listas para evitar los errores side efect
a = [1, 2, 3]
b = a
print(a)
# [1, 2, 3]
print(b)
# [1, 2, 3]
print(id(a))
# 987654321123
print(id(b))
# 987654321123

c = list(a)

print(a)
# [1, 2, 3]
print(b)
# [1, 2, 3]
print(c)
# [1, 2, 3]

print(id(a))
# 987654321123
print(id(c))
# 987654781123 (Diferente ID) -> Diferente espacio en memoria

d = a[::]
print(d)
# [1, 2, 3]
print(id(d))
# 'd' tiene su propio ID en memoria
# 74125896325



# List Comprehension

my_list = list(range(100))
# [0, 1, 2, 3, 4 ,5, 6, 7... 97, 98, 99] --> -隆!- "Recordar que la funcion range() no es inclusiva" -隆!-

double = [i * 2 for i in my_list]
print(double)
# [0, 2, 4, 6, 8, 10... 190, 192, 194, 196, 198]

pares =  [i for i in my_list if i % 2 == 0]
print(pares)
# [0, 2, 4, 6, 8... 80, 82, 84, 86, 88, 90, 92, 94, 96, 98]```

append.- nos permite incluir un elemento
pop.- nos permite quitar el 煤ltimo elemento
remove.- nos permite quitar un elemento dentro de un 铆ndice
insert.- nos permite insertar un elemento en un 铆ndice concreto

me sorprendio y agrado mucho list comprehension.

Para calcular los 鈥榥ones鈥

python-docs

Estructuras de datos

Este cap铆tulo describe algunas cosas que ya has aprendido en m谩s detalle y agrega algunas cosas nuevas tambi茅n.

M谩s sobre listas

El tipo de dato lista tiene algunos m茅todos m谩s. Aqu铆 est谩n todos los m茅todos de los objetos lista:

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. Lanza un ValueError si no existe tal 铆tem.

list.pop([i])

Quita el 铆tem en la posici贸n dada de la lista y lo retorna. Si no se especifica un 铆ndice, a.pop() quita y retorna el 煤ltimo elemento de la lista. (Los corchetes que encierran a i en la firma del m茅todo denotan que el par谩metro es opcional, no que deber铆as escribir corchetes en esa posici贸n. Ver谩s 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 a[:].

list.index(x[, start[, end]])

Retorna el 铆ndice basado en cero del primer elemento cuyo valor sea igual a x. Lanza una excepci贸n ValueError si no existe tal elemento.

Los argumentos opcionales start y end son interpretados como la notaci贸n de rebanadas y se usan para limitar la b煤squeda a un segmento particular de la lista. El 铆ndice retornado se calcula de manera relativa al inicio de la secuencia completa en lugar de con respecto al argumento start.

list.count(x)

Retorna el n煤mero de veces que x aparece en la lista.

list.sort(*, key=None, reverse=False)

Ordena los elementos de la lista in situ (los argumentos pueden ser usados para personalizar el orden de la lista, ver sorted() para su explicaci贸n).

list.reverse()

Invierte los elementos de la lista in situ.

list.copy()

Retorna una copia superficial de la lista. Equivalente a a[:].

Aliasing o alias en Python

Todes, o al menos la mayor铆a, conocimos en alg煤n momento de nuestras vidas a alguien que tenia un apodo, un nombre extra al cual pod铆amos referirnos a dicha persona. En mi caso me dec铆an 鈥淐harmin鈥 porque era(sigo) gordo. Algo similar sucede en programaci贸n cuando a una variable, se le asigna un nombre extra al cual nos podemos referir a ella, a este se le conoce como 鈥渁signaci贸n鈥 o 鈥渁ssignment鈥.

Esto puede causarnos problemas, ya que si estamos usando dicha variable con un nombre especifico, los cambios que sucedan se dar谩n en todos los casos y si por alg煤n descuido usamos el alias en otra parte del c贸digo, es muy probable que tengamos errores o 鈥渂ugs鈥, es una buena practica evitar los alias. Es importante saber esto si trabajamos con objetos mutables, como por ejemplo los objetos tipo lista.

Ahora, lo interesante, si quisi茅ramos usar los mismos valores de una variable ya definida, pero sin caer en los errores de alias 驴Que tendr铆amos que hacer?
Para el caso de los objetos tipo lista es muy sencillo, necesitamos hacer una copia y para ello tenemos tres formas de hacerlo(mas una mas que hablare de ella al final).

  • list()
  • [:]
  • .copy()

Al hacer esto estamos haciendo una copia del objeto, pero ojo, los objetos que guardamos dentro de esta nueva lista tienen las mismas direcciones de referencia que la original. Es decir, apuntan al mismo lugar en la memoria. A esto se le llama 鈥渟hallow copy鈥.

Veamos los siguientes ejemplos:

import copy

# Realizamos las copias
a = [1, 2, 3]
b = a[:]
c = list(a)
d = copy.copy(a)

# Comparamos id del objeto lista copia y de los valores de la lista
print('a con b')
print(id(a) == id(b))
print(id(a[0]) == id(b[0]))

print('a con c')
print(id(a) == id(c))
print(id(a[0]) == id(c[0]))

print('a con d')
print(id(a) == id(d))
print(id(a[0]) == id(d[0]))

print(a, b, c, d)

a[0] = 5
print(a, b, c, d)
# Obtenemos
a con b
False
True
a con c
False
True
a con d
False
True
[1, 2, 3] [1, 2, 3] [1, 2, 3] [1, 2, 3]
[5, 2, 3] [1, 2, 3] [1, 2, 3] [1, 2, 3]


Como pueden observar los id de las listas son diferentes, pero si vamos a los id de los objetos dentro de las listas son iguales.
Ahora, esto tiene un gran inconveniente si trabajamos con listas anidadas(listas dentro de otras listas), para verlo veamos el siguiente ejemplo:

a2 = [[1,2,3], [4,5,6], [7,8,9]]
b2 = a2[:]
c2 = list(a2)
d2 = copy.copy(a2)

print('a2 con b2')
print(id(a2) == id(b2))
print(id(a2[0]) == id(b2[0]))

print('a2 con c2')
print(id(a2) == id(c2))
print(id(a2[0]) == id(c2[0]))

print('a2 con d2')
print(id(a2) == id(d2))
print(id(a2[0]) == id(d2[0]))

print(f'lista a2: {a2} y lista b2: {b2}')

a2[0][0] = 5
print(f'lista a2: {a2} y lista b2: {b2}, despues del cambio')

a2 con b2
False
True
a2 con c2
False
True
a2 con d2
False
True
lista a2: [[1, 2, 3], [4, 5, 6], [7, 8, 9]] y lista b2: [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
lista a2: [[5, 2, 3], [4, 5, 6], [7, 8, 9]] y lista b2: [[5, 2, 3], [4, 5, 6], [7, 8, 9]], despues del cambio

Como ven, los cambios se dieron en ambas listas, por obvias razones esto no es deseado.

Para resolverlo recurrimos a los 鈥渄eepcopy鈥, de esta forma si crearemos una copia mas profunda, veamos ahora el c贸digo:

b3 = copy.deepcopy(a2)
print('a2 con b3')
print(id(a2) == id(b3))
print(id(a2[0]) == id(b3[0]))

a2[0][0] = 5
print(f'lista a2: {a2} y lista b2: {b2}, despues del cambio')

print(f'lista a2: {a2} y lista b2: {b3}, despues del cambio')

a2 con b3
False
False
lista a2: [[5, 2, 3], [4, 5, 6], [7, 8, 9]] y lista b2: [[5, 2, 3], [4, 5, 6], [7, 8, 9]], despues del cambio
lista a2: [[5, 2, 3], [4, 5, 6], [7, 8, 9]] y lista b2: [[1, 2, 3], [4, 5, 6], [7, 8, 9]], despues del cambio

Problema solucionado!

Para finalizar, las shallow copy son mas r谩pidas que las deepcopy, depender谩 de ti cual es mejor o peor dependiendo de lo que est茅s haciendo.

Gracias por leerme 馃槂

Hola!

Con estos conocimientos trate de aplicarlos en un ejemplo pr谩ctico e hice este programa para poder elegir el tama帽o de una lista de n煤meros, luego elegir si quer茅s una lista de impares o pares y luego saber en qu茅 posici贸n se encuentra un n煤mero de esa lista.

Cualquier correcci贸n es bienvenida, saludos!

def run():
    def selector():
        tama帽o_de_lista = int(input(f'Ingresa el tama帽o que deseas que tenga tu lista: ')) + 1
        lista = list(range(1, tama帽o_de_lista))

        lista_pares = [i for i in lista if i % 2 == 0]
        lista_impares = [i for i in lista if i % 2 != 0]


        seleccion_ppal = int(input(f'''Selecciona:
        1 - Para elegir un n煤mero entre los n煤mero pares
        2 - Para elegir un n煤mero entre los n煤meros impares
        
        '''))

        if seleccion_ppal == 1:
            print(f'Los n煤mero pares a elegir son: {str(lista_pares)}')
            seleccion_pares = int(input(f'Selecciona la posici贸n del n煤mero par a elegir: '))
            print(str(f'El n煤mero seleccionado en la posici贸n {seleccion_pares} es {str(lista_pares[seleccion_pares - 1])}'))
        elif seleccion_ppal == 2:
            print(f'Los n煤mero impares a elegir son: {str(lista_impares)}')
            seleccion_impares = int(input(f'Selecciona la posici贸n del n煤mero par a elegir: '))
            print(f'El n煤mero seleccionado en la posici贸n {seleccion_impares} es {str(lista_impares[seleccion_impares - 1])}')
        else:
            print(f'''
            
Ingresa una opci贸n correcta.
            
            ''')
            selector()


    selector()

if __name__ == '__main__':
    run()

Hola amigos les comparto las pruebas que estuve haciendo con las funciones sobre listas 馃槃

Agregar valores al final de la lista

lista = [1,2,3,4]
lista.append(5)
print(lista)

lista += [5] # segunda forma
print(lista)

lista[len(lista):] = [5] # tercera forma
print(lista)


Agregar valores en cualquier posici贸n con insert

lista = [1,2,3,4]
lista.insert(2, 5) # agregar 5 en la posicion 2
lista.insert(10, 5) # si la posicion es mayor al largo de la lista, el valor se agrega al final
print(lista)

Reemplazar un valor

lista = [1,2,3,4]
lista[2] = 5 # reemplaza al valor de posicion 2 por un 5
print(lista)
#lista[10] = 5 # si la posicion es mayor al largo de la lista, ocurre un error index out of range
 

Eliminar valores con remove


lista = [1,2,3,4,2,1]
lista.remove(2) # remueve el primer valor que coincida con el argumento
print(lista)
#lista.remove(5) # si no se encuentra el valor devuelve un error: ValueError: list.remove(x): x not in list

Sacar valores de la lista (eliminar y retornar valor) con pop

lista = [1,2,3,4]
print(lista)
x1 = lista.pop() # Elimina y retorna el 煤ltimo valor
x2 = lista.pop(1) # Elimina y retorna el valor en el 铆ndice especif铆cado
print(f"x1 -> {x1}, x2 -> {x2}") 
print(lista) 
#x3 = lista.pop(2) # Si el indice es mayor al rango ocurre IndexError: pop index out of range

Vaciar una lista con clear

lista = [1,2,3,4]
lista.clear()
print(lista) 

Encontrar el 铆ndice de un elemento dentro de una lista

lista = [1,2,3,4,2]
i = lista.index(2) # retorna el 铆ndice de la primera coincidencia del valor 2
print(f"脥ndice: {i} -> valor {lista[i]}")

Contar las repetciones de un elemento dentro de una lista (con count)

lista = [1,2,3,4,2,2]
print(f"repeticiones de 2: {lista.count(2)}")
print(f"repeticiones de 5: {lista.count(5)}")

Ordenar una lista (con sort)

lista = [4,3,5,2,1,6]
lista.sort()
print(lista)
lista = ["1","3","2"]
lista.sort()
print(lista)
lista = [(1,20,3),(1,2),(1,3)]
lista.sort()
print(lista)

Invertir una lista

lista = [1,2,3,4,5]
lista.reverse()
print(lista)
print(lista[::-1]) # otra manera de invertir

Copiar una lista, para evitar side effects

lista = [1,2,3,4,5]
lista_copia = lista.copy() # con funcion copy
lista_copia2 = lista[::] # con slices
lista_copia3 = lista + [] # con "sumar" una lista vacia
print(f"Id de lista: \t\t{id(lista)} \nId de lista_copia \t{id(lista_copia)} \nId de lista_copia2 \t{id(lista_copia2)} \nId de lista_copia3 \t{id(lista_copia3)}")

Extender una lista

lista = [1,2,3,4,5]
lista.extend([6,7]) # con funcion extend, solo acepta objetos iterables como parametro
print(lista)

lista = [1,2,3,4,5]
lista += [6,7] # con operador +=
print(lista)

# no confundir con insert o append que agregan cualquier tipo de elemento a la lista
lista = [1,2,3,4,5]
lista.insert(len(lista),[6,7])
print(lista)

lista = [1,2,3,4,5]
lista.append([6,7])
print(lista)
impares = [i for i in my_list if i % 2 ==1]
print("solo los n煤meros impares de la lista:",impares)

Les dejo mis apuntes donde explico las listas, los m茅tyodos, las list comprehensions, la clonaci贸n y otras particularidades
Apuntes

Esta ha sido mi clase favorita隆隆

Tambi茅n podr铆amos mostrar los pares de la siguiente forma

 pares = [i for i in my_list [::2]]
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)

Listas:

  • secuencias de objetos

  • son mutables

  • side effects (efectos secundarios)

  • se puede iterar con ellas.

Para clonar listas tambi茅n podemos usar directamente el m茅todo copy de las listas, usandolo de la siguiente manera:

list.copy()

Hola. Encontr茅 este art铆culo con los m茅todos de las listas: https://j2logo.com/python/tutorial/tipo-list-python/#list-clase