Listas en Python

Las listas en Python son contenedores de elementos no ordenados que permiten almacenar valores de diferentes tipos y son de tamaño flexible, pueden expandirse y reducirse cuando se añaden o eliminan elementos.

Hay dos formas para crear listas en Python:

  1. Usando un par de corchetes «[]» vacíos para crear listas vacías.
  2. Usando la clase list() para crear listas vacías.

Con ambas formas podemos crear listas vacías o llenarlas con elementos de forma predeterminada. Veremos ambas formas y como usar todos sus métodos para trabajar sobre ellas.



Creando listas usando corchetes «[]» vacíos
lista = []

Esta es la forma más común y sencilla de crear una lista vacía en Python, declaramos la variable y después del signo «=» ponemos un par de corchetes «[]» vacíos. Si queremos crear una lista con elementos predeterminados, solo hay agregarlos separados con una coma «,»; por ejemplo: [1, 2, "America", True, 5.0].

Existen más formas de crear listas con elementos predeterminados usando el juego de corchetes «[]», que pueden ser o no ser más eficientes, dependiendo del contexto en el que se usen. Veremos varias de ellas.

Creando lista en base a otra ya existente

Si ya tenemos una lista existente con anterioridad, podemos usarla para crear una nueva, de la siguiente forma:

* Usando desempaquetado de tuplas:

tupla = (5, 90, 19, "0", True, "America")
lista = [*tupla]

Creamos una tupla con «n» cantidad de valores y luego la pasamos como argumento en los corchetes «[]», junto con el signo «*», esto toma los elementos de la tupla y los desempaca como una copia en el mismo orden en la nueva lista.

* Usando desempaquetado de listas:

lista = [1, "America", 2, True, 5.0]
lista2 = [*lista]

Creamos una lista con «n» cantidad de elementos y luego la pasamos como argumento en el juego de corchetes «[]», junto con el signo «*», esto desempaca los elementos y almacena una copia en el mismo orden en la nueva lista. Esta forma es muy similar a la que veremos a continuación, conocida como copia superficial.

* Copia superficial:

lista = [1, "America", 2, True, 5.0, False, 3.1415]
lista2 = lista[:]

En la copia superficial creamos una lista asignando una lista a una variable como se observa en el fragmento de código, con la ventaja que podemos indicar el rango de elementos que deseamos que tenga nuestra nueva lista usando Slicing o rebanadas (que veremos más adelante). Al momento de asignar la lista debemos indicar que deseamos que todos los elementos de la lista sean copiados, esto se hace usando la sintaxis «[:]».

Creando listas usando List Comprehensions (Comprensión de Listas)

La Comprensión de Listas es una forma compacta de crear listas, en la cual cada elemento de la lista es el resultado de una operación previa sobre algún tipo de datos; por ejemplo, crear una lista con los números pares de un rango.

* Crear una lista con un rango de números:

lista = [x for x in range(1, 21) if x % 2 == 0]

Esta es la forma más básica de crear una lista usando Comprensión de Listas. En este ejemplo generamos una lista con un rango de números que van desde 1 hasta 100, la función range() no tiene en cuenta el último valor de los rangos.

El anterior fragmento de código es equivalente al siguiente:

lista = []

for x in range(1, 101):
    if x % 2 == 0:
        lista.append(x)

Un código menos compacto, además, la variable «x» queda viva en la memoria durante todo el programa sin que se le llegue dar un uso realmente útil. Hagamos otro ejemplo, pero esta vez con strings.

* Crear una lista de caracteres:

lista = [c if c != c.lower() else c.upper() for c in "Hola MundO, BiEnvenidos!!"]

En este ejemplo cambia todo, ya no trabajamos con números y aparecen las sentencias if .. else. La idea es crear una lista con los caracteres del string en mayúscula cada uno, ignorando los caracteres que ya están en mayúscula.

Hay dos casos en los cuales el uso de la sentencia if es válido:

  1. Usar después del bucle for, solo cuando no hay sentencia else, como se ve en el ejemplo anterior.
  2. Usar antes del bucle for, solo cuando hay una sentencia else, como se ve en el ejemplo actual del string.

El bucle for va a recorrer los caracteres del string, la sentencia if verifica si ya están en mayúscula y solo los agrega a la lista; mientras que en la sentencia else se convierten a mayúscula con el método .upper() y luego se añade a la lista.

El anterior fragmento de código es equivalente al siguiente:

for c in "Hola MundO, BiEnveNidos!!":
    if c != c.lower():
        lista.append(c)
    else:
        lista.append(c.upper())

La variable c que aparece al inicio de los corchetes «[]» corresponde a lista.append(c) en la línea 3 de este fragmento de código, el método .append() añade el valor de c a la lista. De nuevo se genera un código menos compacto.

* Crear una lista con dos bucles for:

anios = [1974, 1932, 1919, 2018, 2007, 1992]
anios2 = [1983, 1820, 1950, 2001, 2007, 1981]

lista = [x - y if x > y else y - x for x in anios for y in anios2]

print(lista)

En este ejemplo básicamente se muestra como usar 2 bucles for en la Comprensión de Listas, aquí se comparan los elementos de cada lista y luego se realizan operaciones de resta para determinar la diferencia de años que hay. Este fragmento de código es equivalente al siguiente:

anios = [1974, 1932, 1919, 2018, 2007, 1992]
anios2 = [1983, 1820, 1950, 2001, 2007, 1981]

lista = []

for x in anios:
    for y in anios2:
        if x > y:
            lista.append(x - y)
        else:
            lista.append(y - x)

print(lista)

Muy notable la diferencia, pasando de 6 a 13 líneas de código. Los ejemplos que se muestran aquí solo son una pequeña parte de las diferentes formas en las que se pueden hacer listas con Comprensión de Listas y parecen básicos, pero en realidad se pueden hacer operaciones avanzadas con pocos limitantes.


Creando listas usando la clase list()
lista = list()

Otra forma sencilla de crear una lista vacía es usando la clase list(). Esta clase tiene dos constructores, el primero es el que se muestra en este fragmento de código y el segundo recibe un iterable con los elementos que deseamos agregar a la lista. Si deseamos crear una lista con elementos predeterminado debemos usar el segundo constructor de la siguiente forma, aunque no es la única:

lista = list([1, "America", 2, True, 5.0])

En este caso el constructor recibe los elementos que deseamos agregar a la lista entre corchetes «[]», en forma de una lista; pero se puede con cualquier tipo de iterable como tuplas o rangos. El Iterable también puede ir entre paréntesis «()», al estilo de una tupla:

lista = list((5, 90, 19, "0", True, "America"))

Pero estas dos formas son estáticas y poco eficientes si deseamos agregar un número mayor de elementos, en este caso podemos usar la función range() si tenemos pensado añadir solo números, así:

lista = list(range(1, 21))

De esta forma creamos una lista con 20 número enteros.

* Usando listas:

lista1 = [5, 90, 19, "0", True, "America"]
lista = list(lista1)

También podemos crear listas a partir de otra lista, solo debemos pasar la lista ya existente al constructor de la clase list() como se muestra en el ejemplo; pero no podremos usar desempaquetado de listas como se vio anteriormente.

* Usando tuplas:

tupla = (5, 90, 19, "0", True, "America")
lista = list(tupla)

Si tenemos una tupla de valores ya diseñada, también podemos usarla para crear una lista, solo basta con pasar la tupla como argumento del constructor de la clase list(); pero no podremos usar desempaquetado de tuplas.

La clase list() no soporta Comprensión de Lista como si lo soporta la creación de listas usando los corchetes «[]».

Slicing o rebanadas, extrayendo sublistas

Básicamente es una técnica en la cual se puede partir una lista en pequeños rangos de valores para obtener sublistas sin alterar la lista original, o invertirla. Usando Slicing podemos crear nuevas listas, como lo veremos en los ejemplos.

* Obteniendo sublista:

lista = [x for x in range(1, 21)]
print(lista[4:10])

Primero se crea una lista con 20 elemento y luego extraemos la sublista usando la expresión [4:10], esto nos devuelve los valores que se encuentran en los índices desde 4 hasta el 9 ya que no se cuenta el índice 10 y como resultado nos devuelve los siguientes elementos [5, 6, 7, 8, 9, 10], el primer elemento se encuentra en el índice 0. Si lo que estamos buscando es obtener una sublista desde el índice 4 hasta el final, solo basta con usar la expresión [4:].

Si lo que deseamos es obtener una sublista desde el índice 0 hasta el índice n, solo basta con usar la expresión [: 15] que nos devuelve los valores [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15] sin tener en cuenta el índice 15.

* Creando listas a partir de sublistas:

lista = [x for x in range(1, 21)]
listan = lista[6:17]

Aquí creamos una lista con los elementos que están en los índices 6 hasta el 17 sin tener en cuenta el índice 17. La nueva lista quedó conformada por los elementos [7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17]. Si deseamos usar la clase list(), solo basta con pasar la sublista de la siguiente forma:

listan = list(lista[6:17])

Este ejemplo produce exactamente el mismo resultado que el anterior ejemplo, se extrae una sublista entre los índices del 6 al 17 sin tener en cuenta el índice 17 y se toma como iterable.

* Usando índices negativos:
Los índices negativos empiezan desde -1 y van hasta -n, esto nos permite hacer Slicing pero de forma invertida.

lista = [x for x in range(1, 21)]
print(lista[-5:])

En este ejemplo obtenemos los últimos 5 elementos de la lista indicando el índice -5, lo que nos da como resultado la siguiente sublista [16, 17, 18, 19, 20] de 5 elementos. En Python los índices negativos son inclusivos, lo que quiere decir que siempre obtenemos los elementos completos desde -1 hasta -n, o hasta -n desde -1.

El anterior ejemplo es equivalente al siguiente:

lista = [x for x in range(1, 21)]
print(lista[15:])

Obtenemos exactamente los mismos 5 elementos, pero usando índices positivos. Aquí le estamos diciendo a Python que queremos la sublista a partir del índice 15 hasta el final. Si por el contrario, lo que queremos es obtener una sublista hasta -n desde cualquier número índice negativo, podemos hacer lo siguiente:

lista = [x for x in range(1, 21)]
print(lista[:-10])

En este ejemplo le estamos pidiendo a Python los elementos que van desde -10 hasta el final de la lista invertida, es decir, hasta -20 en este caso; el resultado es la siguiente sublista [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], los 10 primeros elementos de la lista original. Recuerde que estamos trabajando con una lista de 20 elementos.

El anterior ejemplo es equivalente al siguiente:

lista = [x for x in range(1, 21)]
print(lista[:10])

Obtenemos el mismo resultado, una sublista con los primeros 10 elementos de la lista que van desde el índice 0 hasta el 9 ya que no se incluye el valor del índice 10. Recuerde que el Slicing con índices positivos excluye el último valor.

Slicing o rebanadas intercaladas o por paso

Python también permite realizar Slicing intercalados, es decir, extraer sublistas con valores no continuos. Por ejemplo:

lista = [x for x in range(1, 21)]
print(lista[1::2])

Al usar la expresión [1::2] le estamos diciendo a Python que deseamos extraer una sublista cuyos valores empiezan en el índice 1, pero que cada uno de los valores siguientes deben ser seleccionado cada 2 índices; dando como resultado la siguiente sublista [2, 4, 6, 8, 10, 12, 14, 16, 18, 20]. ¿Cómo funciona? Veamos.

['*', 2, '*', 4, '*', 6, '*', 8, '*', 10, '*', 12, '*', 14, '*', 16, '*', 18, '*', 20]

La sublista empieza en el elemento 2, el cual está en el índice 1 y se seleccionan todos los valores que están ubicados en cada 2 índices. Los «*» representa los valores ignorados, pero si quiere generar una sublista con todos los números impares, solo debe cambiar el índice 1 a índice 0.

Invirtiendo la lista, Slicing intercalado
lista = [x for x in range(1, 21)]
print(lista[::-1])

También podemos invertir la lista haciendo Slicing con la misma sintaxis de los ejercicios anteriores, pero usando índices negativos. En este ejemplo se muestra cómo invertir toda la lista, dando el siguiente resultado:

[20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1]

Ojo! No confundir ordenar lista con invertir la lista, ya que esta ultima lo unico que hace es tomar los elementos que se encuentran al final y asignarlos a los primeros índices sin determinar qué valores son menores o mayores.

Para obtener una sublista invertida de números pares, solo hay hacer lo siguiente:

lista = [x for x in range(1, 21)]
print(lista[::-2])

Le indicamos a Python que deseamos extraer una sublista con todos los elementos que se encuentran cada 2 índices negativos, obteniendo el mismo resultado del Slicing normal con índices positivos [20, 18, 16, 14, 12, 10, 8, 6, 4, 2]; pero invertida la sublista.

Obteniendo sublista en un rango de valores usando índices negativos
lista = [x for x in range(1, 21)]
print(lista[-11::-1])

Trabajar con Slicing de índices negativos para crear sublistas con rangos de elementos invertidos es similar a trabajar con índices positivos vistos en ejemplos pasados, se excluye el último índice del rango. En este ejemplo se explica cómo extraer los 10 primeros elementos de una lista invertida, produciendo el siguiente resultado [10, 9, 8, 7, 6, 5, 4, 3, 2, 1] que ignora el elemento en el índice -11.

El anterior ejemplo es equivalente al siguiente con índices positivos:

lista = [x for x in range(1, 21)]
print(lista[:10])

Aquí se extraen los 10 primeros elementos de la lista desde el índice 0 hasta el 9, ignorando el índice 10.


Métodos de las lista

En Python las listas en realidad son objetos, sin importar cual de las formas para crear listas que se vieron al principio usamos y como tal poseen métodos con los que podemos realizar diferentes operaciones.

Método .append():

Agrega un elemento al final de la lista.

lista = []
lista.append(5)
Método .insert(ind, item):

Inserta un elemento en la lista en el índice indicado.

lista = [5, 18, 40, 33]
lista.insert(2, 90)

En este ejemplo se inserta el número 90 en el índice 2 y el valor actual es desplazado al índice 3. El resultado sería el siguiente: [5, 18, 90, 40, 33].

Método .extend(iterable):

Extiende la lista actual anexando los elementos de un iterable, como lo son una lista, tupla o rango.

lista = [5, 18, 40, 33]
lista.extend([90, 32, 81, 11])

En este ejemplo extendemos la lista anexando todos los elementos del iterable entre los«[]», la lista ahora se ve de la siguiente forma: [5, 18, 40, 33, 90, 32, 81, 11]. También podemos pasar como argumento una lista o tupla ya existente lista.extend(lista1).

Método .count(item):

Indica la cantidad de veces que se encuentra item en la lista.

lista = [5, 18, 40, 33, 5, 20, 15, 5, 20]
print(lista.count(20))

El número 20 se encuentra 2 veces en la lista.

Método .index(index, [init, end]):

Devuelve el elemento ubicado en el indice index, los argumentos entre «[]» son opcionales, le indican a Python el inicio (init) y el final (end) de una sublista en la que deseamos buscar buscar el elemento.

lista = [5, 18, 40, 33, 5, 20, 15, 5, 20]
print(lista.index(20))

En su uso básico solo basta con indicar el elemento a buscar, si el elemento está repetido entonces solo muestra el índice del primero que coincida. En este primer ejemplo queremos saber en cual índice se encuentra el número 20 y el método .index() nos indica que se encuentra en el índice 5 ya que el número está repetido y el primero que coincide está en ese índice.

* Estableciendo índice inicial de la sublista:

lista = [5, 18, 40, 89, 33, 5, 20, 15, 5, 20, 90, 75, 5, 89]
print(lista.index(5, 6))

El uso básico cuando queremos buscar un elemento en una sublista es indicando el índice a partir del cual deseamos hacer la búsqueda o índice inicial. En este ejemplo tenemos una lista más amplia y deseamos buscar el número 5 pero a partir del índice 6, como resultado nos devuelve el índice del primer elemento que coincida a partir del índice 6, el cual se encuentra en el índice 8 y no en el índice 0.

* Establecer el índice inicial e índice final de la sublista:

lista = [5, 18, 40, 89, 33, 5, 20, 15, 5, 20, 90, 75, 5, 89]
print(lista.index(5, 2, 7))

Si lo que deseamos es hacer una búsqueda sobre un rango de elementos específicos, solo hay que indicar el índice inicial y el índice final. En este ejemplo deseamos buscar el número 5 pero una sublista entre los índices 3 y 7, el método .index() nos indica que la primera coincidencia se encuentra en el índice 5 y no en el índice 0.

Método .count(item)

Nos indica cuantas veces se repite un elemento item en la lista.

lista = [5, 18, 40, 89, 33, 5, 20, 15, 5, 20, 90, 75, 5, 89]
print(lista.count(5))

En este ejemplo nos indica que el número 5 se repite 4 veces.

Método .remove(item)

Elimina el elemento item de la lista, si el elemento está repetido entonces elimina el primero que coincida.

lista = [5, 18, 40, 89, 33, 5, 20, 15, 5, 20, 90, 75, 5, 89]
lista.remove(20)

En este ejemplo deseamos eliminar el número 20 que se encuentra repetido 2 veces, entonces se elimina el primero que coincide. La lista ahora queda conformada de la siguiente manera:

[5, 18, 40, 89, 33, 5, 15, 5, 20, 90, 75, 5, 89]

Para saber como eliminar todos los elementos repetidos con este método, ingrese a este link.

Método .pop(index)

Elimina un elemento ubicado en el índice index y lo devuelve. El índice index es opcional y si no se indica entonces se elimina el último elemento de la lista.

lista = [5, 18, 40, 89, 33, 5, 20, 15, 5, 20, 90, 75, 5, 89]
print(lista.pop(7))

En este ejemplo deseamos eliminar el elemento ubicado en el índice 7 y la función print() nos muestra en pantalla el elemento que hemos eliminado, el cual es devuelto por este método.

Método .clear()

Elimina todos los elementos de la lista. Esto es equivalente a lista[:] = [].

lista = [5, 18, 40, 89, 33, 5, 20, 15, 5, 20, 90, 75, 5, 89]
lista.clear()

En este ejemplo eliminamos todos los elementos de la lista, como resultado quedamos con una lista vacía.

* Sentencia del:

Elimina rangos de elementos de una lista, todos los elementos o la variable.

lista = [5, 18, 40, 89, 33, 5, 20, 15, 5, 20, 90, 75, 5, 89]
del lista[:10]

Elimina los elementos desde el índice 0 hasta el índice 9, excluyendo el índice 10.

lista = [5, 18, 40, 89, 33, 5, 20, 15, 5, 20, 90, 75, 5, 89]
del lista[:]

Elimina todos los elementos de la lista, equivalente a lista[:] = [].

lista = [5, 18, 40, 89, 33, 5, 20, 15, 5, 20, 90, 75, 5, 89]
del lista

Elimina el objeto lista, liberando la memoria ocupada por los elementos y como consecuencia se pierde el acceso. Si se intenta acceder se produce el siguiente error:

Traceback (most recent call last):
  File "/home/fixedtorres/SumaDeDigitos.py", line 3, in <module>
    print(lista)
NameError: name 'lista' is not defined
Método .sort(reverse = True || False)

Por defecto, el valor de reverse es False y la lista se ordena de menor a mayor. Si desea ordenar la lista la lista de mayor a menor, debe pasar como argumento nombrado a reverse con el valor True.

lista = [5, 18, 40, 89, 33, 5, 20, 15, 5, 20, 90, 75, 5, 89]
lista.sort()

En este ejemplo ordenamos la lista de menor a mayor, recuerde que por defecto reverse es False.

lista = [5, 18, 40, 89, 33, 5, 20, 15, 5, 20, 90, 75, 5, 89]
lista.sort(reverse = True)

En este ejemplo ordenamos la lista de mayor a menor, note como hemos pasado el argumento reverse con valor True.

Método .reverse()

Invierte todos los elementos de la lista.

lista = [5, 18, 40, 89, 33, 5, 20, 15, 5, 20, 90, 75, 5, 89]
lista.reverse()

La lista invertida ahora se ve así: [89, 5, 75, 90, 20, 5, 15, 20, 5, 33, 89, 40, 18, 5].

Método .copy()

Devuelve una copia superficial de la lista actual. Esto es equivalente a lista2 = lista[:].

lista = [5, 18, 40, 89, 33, 5, 20, 15, 5, 20, 90, 75, 5, 89]
lista2 = lista.copy()

Esta es otra forma de crear listas a partir de otra lista. Ahora la variable lista2 es una lista que contiene los mismos elementos de la lista lista.



Añadir un comentario

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *