Las listas en Python son similares a los arreglos en JavaScript. Son uno de los tipos de datos integrados en Python que se utilizan para almacenar colecciones de datos.

Uso básico

Cómo crear una lista

Se crea una lista vacía usando un par de corchetes:

>>> lista_vacia = []
>>> type(lista_vacia)
<class 'lista'>
>>> len(lista_vacia)
0

Se puede crear una lista con elementos encerrando una lista de elementos separados por comas entre corchetes. Las listas permiten que los elementos sean de diferentes tipos (heterogéneos) pero más comúnmente son de un solo tipo (homogéneos):

>>> lista_homogenea = [1, 1, 2, 3, 5, 8]
>>> type(lista_homogenea)
<class 'lista'>
>>> print(lista_homogenea)
[1, 1, 2, 3, 5, 8]
>>> len(lista_homogenea)
6
>>> lista_heterogenea = [1, "¡Hola Campistas!"]
>>> print(lista_heterogenea)
[1, "¡Hola Campistas!"]
>>> len(lista_heterogenea)
2

El constructor list también se puede utilizar para crear una lista:

>>> lista_vaciat = list()                            # Crea una lista vacia
>>> print(lista_vacia)
[]
>>> lista_de_iterable = list("¡Hola Campistas!")    # Crea una lista a partir de un iterable.
>>> print(lista_de_iterable)
['!', 'H', 'o', 'l', 'a', ' ', 'c', 'a', 'm', 'p', 'i', 's', 't', 'a', 's', '!']

También puedes utilizar Compresión de listas (List Comprehension) para crear listas, que trataremos más adelante en este artículo.

Acceder a elementos en la lista

>>> mi_lista = [1, 2, 9, 16, 25]
>>> print(mi_lista)
[1, 2, 9, 16, 25]

Indexación al 0

>>> mi_lista[0]
1
>>> mi_lista[1]
2
>>> mi_lista[2]
9

Indexación desde el fin de la lista

>>> mi_lista[-1]
25
>>> mi_lista[-2]
16

Desempaquetado de listas para python-3

>>> print(*mi_lista)
1 2 9 16 25

Las Listas son mutables

Las listas son contenedores mutables. Los contenedores mutables son contenedores que permiten cambios en los objetos que contienen el contenedor.

Los elementos de una lista se pueden extraer y reorganizar utilizando otra lista como índice.

>>> mi_lista = [1, 2, 9, 16, 25, 34, 53, 21]
>>> mi_indice = [5, 2, 0]
>>> mi_nueva_lista = [mi_lista[i] for i in mi_indice]
>>> print(mi_nueva_lista)
[34, 9, 1]

Métodos de lista

len()

El método len() devuelve la longitud de un objeto, ya sea una lista, una cadena, una tupla o un diccionario.

len() toma un argumento, que puede ser una secuencia (como una cadena, bytes, tupla, lista o rango) o colección (como un diccionario, conjunto o conjunto "set" congelado "set frozen").

lista1 = [123, 'xyz', 'zara'] # lista
print(len(lista1)) # Muestra 3 ya que hay 3 elementos en lista1

str1 = 'baloncesto' # string
print(len(str1)) # Muestra 10 ya que str1 está compuesto por 10 carácteres

tupla1 = (2, 3, 4, 5) # tupla 
print(len(tupla1)) # Muestra 4 ya que hay 4 elementos en tupla1

dict1 = {'nombre': 'John', 'edad': 4, 'puntaje': 45} # diccionario
print(len(dict1)) # Muestra 3 ya que hay 3 pares de clave/valor en dict1

index()

index() devuelve la primera aparición / índice del elemento en la lista dada como argumento de la función.

numeros = [1, 2, 2, 3, 9, 5, 6, 10]
palabras = ["Yo", "amo", "Python", "Yo", "amo"]

print(numeros.index(9)) # 4
print(numeros.index(2)) # 1
print(palabras.index("Yo")) # 0
print(palabras.index("soy")) # Devuelve un ValueError ya que  'soy' no está en la lista `palabras`

Aquí la primera salida es muy obvia, pero la segunda y la tercera pueden parecer confusas al principio. Pero recuerda que index() devuelve la primera aparición del elemento y, por tanto, en este caso, 1 y 0 son los índices donde 2 y "Yo" aparecen primero en las listas, respectivamente.

Además, si un elemento no se encuentra en la lista, se devuelve un ValueError como en el caso de indexar "soy" en la lista palabras.

Argumentos opcionales

También puedes usar argumentos opcionales para limitar tu búsqueda a una sub secuencia particular de la lista:

palabras = ["Yo", "soy", "un", "Yo", "soy", "Pythonista"]

print(palabras.index("soy", 2, 5)) # 4

Aunque el elemento se busca entre los índices 2 (inclusive) y 5 (no incluido), el índice devuelto se calcula con relación al comienzo de la lista completa en lugar del argumento de inicio.

pop()

El método pop()  borra y retorna el último elemento de una lista.

Existe un parámetro opcional que es el índice del elemento que se eliminará de la lista. Si no se especifica ningún índice, pop() elimina y devuelve el último elemento de la lista.

Si el índice pasado al método pop() no está en el rango, se lanza la excepción IndexError: índice pop fuera del rango.

ciudades = ['New York', 'Dallas', 'San Antonio', 'Houston', 'San Francisco'];

print "Ciudad borrada y retornada es: ", ciudades.pop() # Ciudad borrada y retornada  es: San Francisco
print "Ciudad al índice 2 es  : ", ciudades.pop(2) # Ciudad en en el índice 2 es: San Antonio

Funcionalidad de pila básica

El método pop() se usa a menudo junto con append() para implementar la funcionalidad básica de la pila en una aplicación Python:

pila = []

for i in range(5):
    pila.append(i)

while len(pila):
    print(pila.pop())

Compresión de listas

La comprensión de listas es una forma de recorrer una lista para producir una nueva lista basada en algunas condiciones. Puede resultar confuso al principio, pero una vez que te acostumbras a la sintaxis, es muy potente y rápido.

El primer paso para aprender a utilizar la comprensión de listas es observar la forma tradicional de recorrer una lista. El siguiente es un ejemplo simple que devuelve una nueva lista de números pares.

# Lista para ejemplo de demostración
alguna_lista = [1, 2, 5, 7, 8, 10]

# Lista vacía que se rellenará con un bucle
lista_par = []

for numero in alguna_lista:
  if numero % 2 == 0:
    lista_par.append(numero)

# lista_par ahora es igual a [2, 8, 10]

Primero se crea una lista con algunos números. Luego, creas una lista vacía que contendrá los resultados del bucle. En el bucle, verificas si cada número es divisible por 2 y, si es así, lo agregas a lista_par. Se han utilizado 5 líneas de código sin incluir comentarios y espacios en blanco, lo que no es mucho en este ejemplo.

Ahora el ejemplo de comprensión de lista.

# Lista para ejemplo de demostración
alguna_lista = [1, 2, 5, 7, 8, 10]

# Compresión de lista
lista_par = [numero for numero in alguna_lista if numero % 2 == 0]

# lista_par ahora es igual a [2, 8, 10]

Otro ejemplo, con los mismos dos pasos: El código siguiente creará una lista de números que corresponden a los números en mi_lista_de_inicio multiplicados por 7.

mi_lista_de_partida = [1, 2, 3, 4, 5, 6, 7, 8]
mi_nueva_lista = []

for elemento in mi_lista_de_partida:
    mi_nueva_lista.append(elemento * 7)

Cuando se ejecuta el código el valor final de mi_nueva_lista es: [7, 14, 21, 28, 35, 42, 49, 56]

Un desarrollador que use la comprensión de listas podría lograr el mismo resultado usando la siguiente comprensión de listas, que da como resultado la misma mi_nueva_lista.

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

mi_nueva_lista = [elemento * 7 para elemento en mi_lista_de_partida]

Una fórmula sencilla para escribir en forma de lista de comprensión es:

mi_lista = [{operacion con entrada n} for n in {python iterable}]

Reemplace {operacion con entrada n} con la forma en que deseas cambiar el elemento devuelto por el iterable. El ejemplo anterior usa n * 7 pero la operación puede ser tan simple o tan compleja como sea necesario.

Reemplaza {python iterable} con cualquier iterable. Los tipos de secuencia serán los más comunes. En el ejemplo anterior se usó una lista, pero las tuplas y los rangos también son comunes.

La comprensión de listas agrega un elemento de una lista existente a una nueva lista si se cumple alguna condición. Es más ordenado, pero también mucho más rápido en la mayoría de los casos. En algunos casos, la comprensión de lista puede dificultar la legibilidad, por lo que el desarrollador debe sopesar sus opciones al elegir utilizar la comprensión de la lista.

Ejemplos de comprensión de listas con condicionales

El flujo de control en las listas por comprensión se puede controlar mediante condicionales. Por ejemplo:

solo_lista_par = [i for i in range(13) if i%2==0]

Este es equivalente al siguiente bucle:

solo_lista_par = list()
for i in range(13):
  if i%2 == 0:
    solo_lista_par.append(i)

La comprensión de listas también puede contener condiciones if anidadas. Considera el siguiente bucle:

divisible = list()
for i in range(50):
  if i%2 == 0:
    if i%3 == 0:
      divisible.append(i)

Usando la comprensión de listas, esto se puede escribir como:

divisible = [i for i in range(50) if i%2==0 if i%3==0]

La sentencia If-Else también se puede utilizar junto con la comprensión de listas.

lista_1 = [i if i%2==0 else i*-1 for i in range(10)]

Mas Información:

Traducido del artículo Python Lists Explained: Len, Pop, Index, and List Comprehension