Listas y mutabilidad

😄 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, ‘valor’) #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(‘valor’) #Elimina el primer elemento con ese valor.
• lista.clear() #Borra elementos en la lista.
• lista.index(‘valor’) #Retorna posición del primer elemento con el valor.
• lista.index(‘valor’, start, end) #Retorna posición del elemento con el valor dentro de los elementos desde posición start hasta posición end)
• lista.count(‘valor’) #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

Metodos de las listas:

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

#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

https://docs.python.org/3/tutorial/introduction.html#lists

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

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:

• Listas y más

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.

Aquí hay algunos ejemplos que pueden servir de práctica
https://programacionpython80889555.wordpress.com/2018/09/05/list-comprehension-en-python-ejercicio-basio/

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 “almacena” 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 “b” que apunta al mismo bloque de memoria que “a”. 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(‘hola’)

• 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']```

List methods

Aqui les dejo la pagina we que encontre de los metodos: https://entrenamiento-python-basico.readthedocs.io/es/latest/leccion3/tipo_listas.html

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,‘hola’): 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, ‘valor’): 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(‘valor’):Elimina el primer elemento con ese valor.
  • lista.clear(): Borra elementos en la lista.
  • lista.index(‘valor’): Retorna posición del primer elemento con el valor.
  • lista.index(‘valor’, start, end): Retorna posición del elemento con el valor dentro de los elementos desde posición start hasta posición end.
  • lista.count(‘valor’): 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

https://www.w3schools.com/python/python_lists.asp

Espero que les sirva de guia.

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.

https://docs.python.org/3/tutorial/datastructures.html?highlight=list comprehension

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

https://entrenamiento-python-basico.readthedocs.io/es/latest/leccion3/tipo_listas.html#metodos

Una explicación clara de los métodos

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

https://devcode.la/tutoriales/listas-python/

me sorprendio y agrado mucho list comprehension.

Para calcular los ‘nones’

https://docs.python.org/3/tutorial/datastructures.html

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 “Charmin” 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 “asignación” o “assignment”.

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 “bugs’, 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 “shallow 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 “deepcopy”, 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