2.7. Listas

Una lista es una secuencia de valores mutable y ordenada. A diferencia de las cadenas y los bytes, las listas pueden contener valores de cualquier tipo, y puedes cambiar, añadir o eliminar elementos en el sitio.

2.7.1. Crear listas

Los corchetes crean un literal de lista:

empty   = []
nums    = [1, 2, 3]
mixed   = [1, "two", 3.0, True, None]    # any types
nested  = [[1, 2], [3, 4], [5, 6]]       # lists of lists

El constructor list construye una lista a partir de cualquier iterable:

>>> list("abc")
['a', 'b', 'c']
>>> list(range(5))
[0, 1, 2, 3, 4]

2.7.2. Longitud, indexación y particionado

len() devuelve el número de elementos. La indexación y el particionado funcionan igual que con las cadenas: las posiciones empiezan en 0, los índices negativos cuentan desde el final, y una partición fuera del rango válido recorta silenciosamente en lugar de lanzar un error:

>>> nums = [10, 20, 30, 40, 50]
>>> len(nums)
5
>>> nums[0]
10
>>> nums[-1]
50
>>> nums[1:4]
[20, 30, 40]

Los índices positivos cuentan desde el principio; los índices negativos cuentan desde el final.

La sintaxis de partición es una abreviatura de un objeto slice que Python construye entre bastidores. nums[1:4] es lo mismo que nums[slice(1, 4)]. Rara vez construirás uno a mano, pero slice() resulta útil de vez en cuando para almacenar una partición como valor y reutilizarla:

head = slice(0, 3)
print(nums[head])             # [10, 20, 30]
print(letters[head])          # first three letters, same slice

2.7.3. Modificar una lista

Las listas admiten la asignación indexada y particionada en el sitio:

>>> nums = [10, 20, 30]
>>> nums[0] = 99
>>> nums
[99, 20, 30]
>>> nums[1:3] = [200, 300, 400]    # slice can change the length
>>> nums
[99, 200, 300, 400]

Los métodos de lista más comunes:

• list.append() – añade un solo elemento al final.

• list.extend() – añade todos los elementos de un iterable.

• list.insert() – inserta en una posición dada.

• list.remove() – elimina la primera aparición de un valor.

• list.pop() – elimina y devuelve un elemento (el último por defecto).

• list.clear() – elimina todos los elementos.

• list.sort() – ordena en el sitio. Pasa reverse=True para orden descendente.

• list.reverse() – invierte en el sitio.

>>> nums = []
>>> nums.append(1)
>>> nums.extend([2, 3])
>>> nums.insert(0, 99)
>>> nums
[99, 1, 2, 3]
>>> nums.pop()
3
>>> nums.sort()
>>> nums
[1, 2, 99]

Estos métodos modifican la lista en el sitio y devuelven None. Escribir

nums = nums.sort()    # nums is now None -- common bug

casi nunca es lo que quieres; la nums original se ha ordenado, pero la asignación sobrescribe entonces el nombre con el valor de retorno. O bien llama a nums.sort() en su propia línea, o bien usa la función incorporada sorted() para obtener una nueva lista ordenada sin modificar la original.

2.7.4. Operadores

• + concatena dos listas en una nueva lista.

• * repite una lista.

• in comprueba la pertenencia.

>>> [1, 2] + [3, 4]
[1, 2, 3, 4]
>>> [0] * 5
[0, 0, 0, 0, 0]
>>> 3 in [1, 2, 3]
True

2.7.5. Iterar sobre una lista

Un bucle for recorre los elementos en orden:

for n in [10, 20, 30]:
    print(n)

2.7.6. Alias y mutación

Una lista es un único valor en memoria; varios nombres pueden apuntar a la misma lista. La mutación a través de un nombre es visible a través de todos los demás nombres que apuntan a la misma lista.

a y b apuntan ambas a la misma lista. La mutación a través de cualquiera de los nombres cambia lo que ve cada uno de los demás nombres.

>>> a = [1, 2, 3]
>>> b = a
>>> a.append(4)
>>> b
[1, 2, 3, 4]                # same object, change is visible

Para hacer una copia independiente, particiona la lista entera o llama al constructor list:

>>> c = a[:]                # or list(a)
>>> a.append(5)
>>> c
[1, 2, 3, 4]                # c is unaffected

Esto solo copia la lista de nivel superior; las listas anidadas siguen compartidas entre el original y la copia.