Python Language
Lista

Introducción

Sintaxis

• [valor, valor, ...]
• lista ([iterable])

Observaciones

Acceso a los valores de la lista

Las listas de Python están indexadas a cero, y actúan como matrices en otros idiomas.

lst = [1, 2, 3, 4]
lst[0]  # 1
lst[1]  # 2

Intentar acceder a un índice fuera de los límites de la lista generará un IndexError .

lst[4]  # IndexError: list index out of range

Los índices negativos se interpretan como contadores desde el final de la lista.

lst[-1]  # 4
lst[-2]  # 3
lst[-5]  # IndexError: list index out of range

Esto es funcionalmente equivalente a

lst[len(lst)-1]  # 4

Las listas permiten usar notación de lst[start:end:step] como lst[start:end:step] . La salida de la notación de división es una nueva lista que contiene elementos desde el start hasta el end-1 del índice. Si se omiten las opciones, start defecto al principio de la lista, de end a extremo de la lista y step al 1:

lst[1:]      # [2, 3, 4]
lst[:3]      # [1, 2, 3]
lst[::2]     # [1, 3]
lst[::-1]    # [4, 3, 2, 1] 
lst[-1:0:-1] # [4, 3, 2]
lst[5:8]     # [] since starting index is greater than length of lst, returns empty list
lst[1:10]    # [2, 3, 4] same as omitting ending index

Con esto en mente, puede imprimir una versión invertida de la lista llamando

lst[::-1]    # [4, 3, 2, 1]

Cuando se usan longitudes de pasos de cantidades negativas, el índice inicial debe ser mayor que el índice final, de lo contrario, el resultado será una lista vacía.

lst[3:1:-1] # [4, 3]

El uso de índices de pasos negativos es equivalente al siguiente código:

reversed(lst)[0:2] # 0 = 1 -1
                   # 2 = 3 -1

Los índices utilizados son 1 menos que los utilizados en la indexación negativa y se invierten.

Rebanado avanzado

Cuando las listas se __getitem__() se llama al método __getitem__() del objeto de lista, con un objeto de slice . Python tiene un método de división integrado para generar objetos de división. Podemos usar esto para almacenar una porción y reutilizarla más tarde como así,

data = 'chandan purohit    22 2000'  #assuming data fields of fixed length 
name_slice = slice(0,19)
age_slice = slice(19,21)
salary_slice = slice(22,None)

#now we can have more readable slices
print(data[name_slice]) #chandan purohit     
print(data[age_slice]) #'22'
print(data[salary_slice]) #'2000'

Esto puede ser de gran utilidad al proporcionar funcionalidad de corte a nuestros objetos al reemplazar __getitem__ en nuestra clase.

Lista de métodos y operadores soportados.

Comenzando con una lista dada a :

a = [1, 2, 3, 4, 5]

1. append(value) : agrega un nuevo elemento al final de la lista.

   # Append values 6, 7, and 7 to the list
   a.append(6)
   a.append(7)
   a.append(7)
   # a: [1, 2, 3, 4, 5, 6, 7, 7]
   
   # Append another list
   b = [8, 9]
   a.append(b)
   # a: [1, 2, 3, 4, 5, 6, 7, 7, [8, 9]]
   
   # Append an element of a different type, as list elements do not need to have the same type
   my_string = "hello world"
   a.append(my_string)
   # a: [1, 2, 3, 4, 5, 6, 7, 7, [8, 9], "hello world"]
   

   Tenga en cuenta que el método append() solo agrega un elemento nuevo al final de la lista. Si agrega una lista a otra, la lista que agregue se convertirá en un elemento único al final de la primera lista.

   # Appending a list to another list
   a = [1, 2, 3, 4, 5, 6, 7, 7]
   b = [8, 9]
   a.append(b)
   # a: [1, 2, 3, 4, 5, 6, 7, 7, [8, 9]]
   a[8]
   # Returns: [8,9]
   

2. extend(enumerable) : extiende la lista agregando elementos de otro enumerable.

   a = [1, 2, 3, 4, 5, 6, 7, 7]
   b = [8, 9, 10]
   
   # Extend list by appending all elements from b
   a.extend(b)
   # a: [1, 2, 3, 4, 5, 6, 7, 7, 8, 9, 10]
   
   # Extend list with elements from a non-list enumerable:
   a.extend(range(3))
   # a: [1, 2, 3, 4, 5, 6, 7, 7, 8, 9, 10, 0, 1, 2]
   

   Las listas también se pueden concatenar con el operador + . Tenga en cuenta que esto no modifica ninguna de las listas originales:

   a = [1, 2, 3, 4, 5, 6] + [7, 7] + b
   # a: [1, 2, 3, 4, 5, 6, 7, 7, 8, 9, 10]
   

3. index(value, [startIndex]) índice de inicio index(value, [startIndex]) : obtiene el índice de la primera aparición del valor de entrada. Si el valor de entrada no está en la lista, se ValueError una excepción ValueError . Si se proporciona un segundo argumento, la búsqueda se inicia en ese índice especificado.

   a.index(7)
   # Returns: 6
   
   a.index(49) # ValueError, because 49 is not in a.
   
   a.index(7, 7)
   # Returns: 7
   
   a.index(7, 8) # ValueError, because there is no 7 starting at index 8
   

4. insert(index, value) : inserta un value justo antes del index especificado. Así después de la inserción el nuevo elemento ocupa el index posición.

   a.insert(0, 0)  # insert 0 at position 0
   a.insert(2, 5)  # insert 5 at position 2
   # a: [0, 1, 5, 2, 3, 4, 5, 6, 7, 7, 8, 9, 10]
   

5. pop([index]) : elimina y devuelve el elemento en el index . Sin ningún argumento, elimina y devuelve el último elemento de la lista.

   a.pop(2)
   # Returns: 5
   # a: [0, 1, 2, 3, 4, 5, 6, 7, 7, 8, 9, 10]
   a.pop(8)
   # Returns: 7
   # a: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
   
   # With no argument:
   a.pop()
   # Returns: 10
   # a: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
   

6. remove(value) : elimina la primera aparición del valor especificado. Si no se puede encontrar el valor proporcionado, se ValueError un ValueError .

   a.remove(0)
   a.remove(9)
   # a: [1, 2, 3, 4, 5, 6, 7, 8]
   a.remove(10)
   # ValueError, because 10 is not in a
   

7. reverse() : invierte la lista en el lugar y devuelve None .

   a.reverse()
   # a: [8, 7, 6, 5, 4, 3, 2, 1]
   

   También hay otras formas de revertir una lista .

8. count(value) : cuenta el número de apariciones de algún valor en la lista.

   a.count(7)
   # Returns: 2
   

9. sort() : ordena la lista en orden numérico y lexicográfico y devuelve None .

   a.sort()
   # a = [1, 2, 3, 4, 5, 6, 7, 8]
   # Sorts the list in numerical order
   

   Las listas también se pueden revertir cuando se ordenan usando la reverse=True en el método sort() .

   a.sort(reverse=True)
   # a = [8, 7, 6, 5, 4, 3, 2, 1]
   

   Si desea ordenar por atributos de elementos, puede usar el argumento de palabra key clave:

   import datetime
   
   class Person(object):
       def __init__(self, name, birthday, height):
           self.name = name
           self.birthday = birthday
           self.height = height
   
       def __repr__(self):
           return self.name
   
   l = [Person("John Cena", datetime.date(1992, 9, 12), 175),
        Person("Chuck Norris", datetime.date(1990, 8, 28), 180),
        Person("Jon Skeet", datetime.date(1991, 7, 6), 185)]
   
   l.sort(key=lambda item: item.name)
   # l: [Chuck Norris, John Cena, Jon Skeet]
   
   l.sort(key=lambda item: item.birthday)
   # l: [Chuck Norris, Jon Skeet, John Cena]
   
   l.sort(key=lambda item: item.height)
   # l: [John Cena, Chuck Norris, Jon Skeet]
   

   En caso de lista de dictados el concepto es el mismo:

   import datetime
   
   l = [{'name':'John Cena', 'birthday': datetime.date(1992, 9, 12),'height': 175},
    {'name': 'Chuck Norris', 'birthday': datetime.date(1990, 8, 28),'height': 180},
    {'name': 'Jon Skeet', 'birthday': datetime.date(1991, 7, 6), 'height': 185}]
   
   l.sort(key=lambda item: item['name'])
   # l: [Chuck Norris, John Cena, Jon Skeet]
   
   l.sort(key=lambda item: item['birthday'])
   # l: [Chuck Norris, Jon Skeet, John Cena]
   
   l.sort(key=lambda item: item['height'])
   # l: [John Cena, Chuck Norris, Jon Skeet]
   

   Ordenar por subdivisión:

   import datetime
   
   l = [{'name':'John Cena', 'birthday': datetime.date(1992, 9, 12),'size': {'height': 175, 'weight': 100}},
    {'name': 'Chuck Norris', 'birthday': datetime.date(1990, 8, 28),'size' : {'height': 180, 'weight': 90}},
    {'name': 'Jon Skeet', 'birthday': datetime.date(1991, 7, 6), 'size': {'height': 185, 'weight': 110}}]
   
   l.sort(key=lambda item: item['size']['height'])
   # l: [John Cena, Chuck Norris, Jon Skeet]
   

Mejor manera de ordenar usando attrgetter y itemgetter

Las listas también se pueden clasificar utilizando las funciones attrgetter y itemgetter del módulo del operador. Estos pueden ayudar a mejorar la legibilidad y la reutilización. Aquí hay unos ejemplos,

from operator import itemgetter,attrgetter

people = [{'name':'chandan','age':20,'salary':2000},
          {'name':'chetan','age':18,'salary':5000},
          {'name':'guru','age':30,'salary':3000}]
by_age = itemgetter('age')
by_salary = itemgetter('salary')

people.sort(key=by_age) #in-place sorting by age
people.sort(key=by_salary) #in-place sorting by salary

itemgetter también se puede dar un índice. Esto es útil si desea ordenar según los índices de una tupla.

list_of_tuples = [(1,2), (3,4), (5,0)]
list_of_tuples.sort(key=itemgetter(1))
print(list_of_tuples) #[(5, 0), (1, 2), (3, 4)]

Utilice el attrgetter si desea ordenar por atributos de un objeto,

persons = [Person("John Cena", datetime.date(1992, 9, 12), 175),
           Person("Chuck Norris", datetime.date(1990, 8, 28), 180),
           Person("Jon Skeet", datetime.date(1991, 7, 6), 185)] #reusing Person class from above example

person.sort(key=attrgetter('name')) #sort by name
by_birthday = attrgetter('birthday')
person.sort(key=by_birthday) #sort by birthday

10. clear() : elimina todos los elementos de la lista

    a.clear()
    # a = []
    

11. Replicación : multiplicar una lista existente por un número entero producirá una lista más grande que consiste en tantas copias del original. Esto puede ser útil, por ejemplo, para la inicialización de listas:

    b = ["blah"] * 3
    # b = ["blah", "blah", "blah"]
    b = [1, 3, 5] * 5
    # [1, 3, 5, 1, 3, 5, 1, 3, 5, 1, 3, 5, 1, 3, 5]
    

    Tenga cuidado al hacer esto si su lista contiene referencias a objetos (por ejemplo, una lista de listas), vea Errores comunes: multiplicación de listas y referencias comunes .

12. Eliminación de elementos : es posible eliminar varios elementos de la lista utilizando la palabra clave del y la notación de segmento:

    a = list(range(10))
    del a[::2]
    # a = [1, 3, 5, 7, 9]
    del a[-1]
    # a = [1, 3, 5, 7]
    del a[:]
    # a = []
    

13. Proceso de copiar

    La asignación predeterminada "=" asigna una referencia de la lista original al nuevo nombre. Es decir, el nombre original y el nuevo nombre apuntan al mismo objeto de lista. Los cambios realizados a través de cualquiera de ellos se reflejarán en otro. Esto a menudo no es lo que pretendías.

    b = a
    a.append(6)
    # b: [1, 2, 3, 4, 5, 6]
    

    Si desea crear una copia de la lista, tiene las siguientes opciones.

    Puedes cortarlo:

    new_list = old_list[:]
    

    Puedes usar la función integrada en la lista ():

    new_list = list(old_list)
    

    Puedes usar copy.copy genérico ():

    import copy
    new_list = copy.copy(old_list) #inserts references to the objects found in the original.
    

    Esto es un poco más lento que list () porque primero tiene que averiguar el tipo de datos de old_list.

    Si la lista contiene objetos y también desea copiarlos, use copy.deepcopy genérico ():

    import copy
    new_list = copy.deepcopy(old_list) #inserts copies of the objects found in the original.
    

    Obviamente, el método más lento y que más memoria necesita, pero a veces inevitable.

    aa = a.copy()
    # aa = [1, 2, 3, 4, 5]

Longitud de una lista

Use len() para obtener la longitud unidimensional de una lista.

len(['one', 'two'])  # returns 2

len(['one', [2, 3], 'four'])  # returns 3, not 4

len() también funciona en cadenas, diccionarios y otras estructuras de datos similares a las listas.

Tenga en cuenta que len() es una función incorporada, no un método de un objeto de lista.

También tenga en cuenta que el costo de len() es O(1) , lo que significa que tomará la misma cantidad de tiempo para obtener la longitud de una lista, independientemente de su longitud.

Iterando sobre una lista

Python admite el uso de un bucle for directamente en una lista:

my_list = ['foo', 'bar', 'baz']
for item in my_list:
    print(item)

# Output: foo
# Output: bar
# Output: baz

También puede obtener la posición de cada elemento al mismo tiempo:

for (index, item) in enumerate(my_list):
    print('The item in position {} is: {}'.format(index, item))
 
# Output: The item in position 0 is: foo
# Output: The item in position 1 is: bar
# Output: The item in position 2 is: baz

La otra forma de iterar una lista basada en el valor del índice:

for i in range(0,len(my_list)):
    print(my_list[i])
#output:
>>>
foo
bar
baz

Tenga en cuenta que cambiar elementos en una lista mientras se iteran en ella puede tener resultados inesperados:

for item in my_list:
    if item == 'foo':
        del my_list[0]
    print(item)

# Output: foo
# Output: baz

En este último ejemplo, eliminamos el primer elemento en la primera iteración, pero eso hizo que se omitiera la bar .

Comprobando si un artículo está en una lista

Python hace que sea muy sencillo comprobar si un elemento está en una lista. Simplemente use el operador in .

lst = ['test', 'twest', 'tweast', 'treast']

'test' in lst
# Out: True

'toast' in lst
# Out: False

Nota: el operador in en conjuntos es asintóticamente más rápido que en las listas. Si necesita usarlo muchas veces en listas potencialmente grandes, puede convertir su list en un set y probar la presencia de elementos en el set .

slst = set(lst)
'test' in slst
# Out: True

Elementos de la lista de inversión

Puede utilizar la función reversed que devuelve un iterador a la lista invertida:

In [3]: rev = reversed(numbers)

In [4]: rev
Out[4]: [9, 8, 7, 6, 5, 4, 3, 2, 1]

Tenga en cuenta que la lista de "números" permanece sin cambios por esta operación, y permanece en el mismo orden en que estaba originalmente.

Para invertir en su lugar, también puede utilizar el método reverse .

También puede revertir una lista (al obtener una copia, la lista original no se ve afectada) utilizando la sintaxis de corte, estableciendo el tercer argumento (el paso) como -1:

In [1]: numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9]

In [2]: numbers[::-1]
Out[2]: [9, 8, 7, 6, 5, 4, 3, 2, 1]

Comprobando si la lista está vacía

El vacío de una lista está asociado al booleano False , por lo que no tiene que marcar len(lst) == 0 , sino solo lst o not lst

lst = []
if not lst:
    print("list is empty")

# Output: list is empty

Concatenar y fusionar listas

1. La forma más sencilla de concatenar list1 y list2 :

   merged = list1 + list2
   

2. zip devuelve una lista de tuplas , donde la i-th tupla contiene el elemento i-th de cada una de las secuencias de argumentos o iterables:

   alist = ['a1', 'a2', 'a3']
   blist = ['b1', 'b2', 'b3']
   
   for a, b in zip(alist, blist):
       print(a, b)
    
   # Output:
   # a1 b1
   # a2 b2
   # a3 b3
   

   Si las listas tienen diferentes longitudes, el resultado incluirá solo tantos elementos como el más corto:

   alist = ['a1', 'a2', 'a3']
   blist = ['b1', 'b2', 'b3', 'b4']
   for a, b in zip(alist, blist):
       print(a, b)
   
   # Output:
   # a1 b1
   # a2 b2
   # a3 b3
   
   alist = []
   len(list(zip(alist, blist)))
   
   # Output:
   # 0
   

   Para listas de relleno de longitud desigual a la más larga con None s use itertools.zip_longest ( itertools.izip_longest en Python 2)

   alist = ['a1', 'a2', 'a3']
   blist = ['b1']
   clist = ['c1', 'c2', 'c3', 'c4']
   
   for a,b,c in itertools.zip_longest(alist, blist, clist):
       print(a, b, c)
   
   # Output: 
   # a1 b1 c1
   # a2 None c2
   # a3 None c3
   # None None c4
   

3. Insertar en un índice de valores específicos:

    alist = [123, 'xyz', 'zara', 'abc']
    alist.insert(3, [2009])
    print("Final List :", alist)
   

   Salida:

    Final List : [123, 'xyz', 'zara', 2009, 'abc']
   

Todos y cada uno

Puede usar all() para determinar si todos los valores en una evaluación iterable a True

nums = [1, 1, 0, 1]
all(nums)
# False
chars = ['a', 'b', 'c', 'd']
all(chars)
# True

Del mismo modo, any() determina si uno o más valores en una evaluación iterable a True

nums = [1, 1, 0, 1]
any(nums)
# True
vals = [None, None, None, False]
any(vals)
# False

Si bien este ejemplo utiliza una lista, es importante tener en cuenta que estos elementos integrados funcionan con cualquier iterable, incluidos los generadores.

vals = [1, 2, 3, 4]
any(val > 12 for val in vals)
# False
any((val * 2) > 6 for val in vals)
# True

Eliminar valores duplicados en la lista

La eliminación de valores duplicados en una lista se puede hacer convirtiendo la lista en un set (es decir, una colección desordenada de objetos distintos). Si se necesita una estructura de datos de list , entonces el conjunto se puede convertir de nuevo a una lista usando la list() funciones list() :

names = ["aixk", "duke", "edik", "tofp", "duke"]
list(set(names))
# Out: ['duke', 'tofp', 'aixk', 'edik']

Tenga en cuenta que al convertir una lista en un conjunto, el pedido original se pierde.

Para preservar el orden de la lista, se puede usar un OrderedDict

import collections
>>> collections.OrderedDict.fromkeys(names).keys()
# Out: ['aixk', 'duke', 'edik', 'tofp']

Acceso a valores en lista anidada

Comenzando con una lista tridimensional:

alist = [[[1,2],[3,4]], [[5,6,7],[8,9,10], [12, 13, 14]]]

Accediendo a los elementos de la lista:

print(alist[0][0][1])
#2
#Accesses second element in the first list in the first list

print(alist[1][1][2])
#10
#Accesses the third element in the second list in the second list

Realizando operaciones de soporte:

alist[0][0].append(11)
print(alist[0][0][2])
#11
#Appends 11 to the end of the first list in the first list

Usando anidados para bucles para imprimir la lista:

for row in alist: #One way to loop through nested lists
    for col in row:
        print(col)
#[1, 2, 11]
#[3, 4]
#[5, 6, 7]
#[8, 9, 10]
#[12, 13, 14]

Tenga en cuenta que esta operación se puede utilizar en una lista de comprensión o incluso como un generador para producir eficiencias, por ejemplo:

[col for row in alist for col in row]
#[[1, 2, 11], [3, 4], [5, 6, 7], [8, 9, 10], [12, 13, 14]]

No todos los elementos en las listas externas tienen que ser listas ellos mismos:

alist[1].insert(2, 15)
#Inserts 15 into the third position in the second list

Otra forma de utilizar anidados para bucles. La otra forma es mejor, pero he necesitado usar esto en ocasiones:

for row in range(len(alist)): #A less Pythonic way to loop through lists
    for col in range(len(alist[row])):
       print(alist[row][col])

#[1, 2, 11]
#[3, 4]
#[5, 6, 7]
#[8, 9, 10]
#15
#[12, 13, 14]

Usando rebanadas en la lista anidada:

print(alist[1][1:])
#[[8, 9, 10], 15, [12, 13, 14]]
#Slices still work

La lista final:

print(alist)
#[[[1, 2, 11], [3, 4]], [[5, 6, 7], [8, 9, 10], 15, [12, 13, 14]]]

Comparacion de listas

Es posible comparar listas y otras secuencias lexicográficamente usando operadores de comparación. Ambos operandos deben ser del mismo tipo.

[1, 10, 100] < [2, 10, 100]
# True, because 1 < 2
[1, 10, 100] < [1, 10, 100]
# False, because the lists are equal
[1, 10, 100] <= [1, 10, 100]
# True, because the lists are equal
[1, 10, 100] < [1, 10, 101]
# True, because 100 < 101
[1, 10, 100] < [0, 10, 100]
# False, because 0 < 1

Si una de las listas está contenida al comienzo de la otra, la lista más corta gana.

[1, 10] < [1, 10, 100]
# True

Inicializando una lista a un número fijo de elementos

Para elementos inmutables (por ejemplo, None , literales de cadenas, etc.):

my_list = [None] * 10
my_list = ['test'] * 10

Para elementos mutables , la misma construcción dará como resultado que todos los elementos de la lista se refieran al mismo objeto, por ejemplo, para un conjunto:

>>> my_list=[{1}] * 10
>>> print(my_list)
[{1}, {1}, {1}, {1}, {1}, {1}, {1}, {1}, {1}, {1}]
>>> my_list[0].add(2)
>>> print(my_list)
[{1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}]

En su lugar, para inicializar la lista con un número fijo de objetos mutables diferentes , use:

my_list=[{1} for _ in range(10)]