Cómo usar listas, diccionarios, tuplas y sets en Python

¡Hola! Una de las cosas que más interesante me pareció cuando empecé a aprender Python (yo que vengo de currar con PHP muchos años) fue ver que no existían los arrays como tal, sino que había varios tipos de estructuras de datos distintos. Por eso esta vez, he decidido hacer un tutorial sobre como se usan las listas, diccionarios, tuplas y sets, ya que tienen un potencial enorme.

¿Qué son las listas?

Una lista es una estructura de datos en la que puedes añadir elementos para su posterior uso. Como en otros lenguajes de programación, las listas permiten guardar cualquier tipo de dato, ya sea enteros, cadenas, objetos e incluso otras listas.

Inicializar una lista

Para declarar una lista vacía se puede hacer con list() o con [].

my_list = list()
my_list = []

También podemos crear una lista con información predefinida:

my_list = list([7,6,3,4])
my_list2 = ['a', 'x', 'd']

Para obtener el valor de una posición en concreto deberemos escribir el nombre de la lista, abrir corchetes, poner el número de la posición donde se encuentra el dato que queremos obtener y cerrar corchete. Para obtener el primer elemento la posición sería la número 0, para el segundo valor la posición número 1 y así sucesivamente.

my_list = list([7,6,3,4])

# Mostrará el primer valor de la lista que es 7
print(my_list[0])

# Mostrará el segundo valor de la lista que es 6
print(my_list[1])

En el caso de querer recorrer todos los valores de una lista podemos hacerlo con el bucle for.

my_list = [7, 5, 9, 2, 3, 4]

for value in my_list:
    print(value)

Operaciones disponibles para la manipulación de listas

Si quieres añadir un elemento a la última posición de la lista lo haríamos con el método append.

my_list.append('hello')
# Después de esto el contenido de la lista será [7, 6, 3, 4, 'hello']

En caso de que queramos añadir un elemento en una posición en concreto usaremos el método insert donde el primer parámetro será la posición y el segundo el dato a insertar.

my_list = list([7,6,3,4,5])
my_list.insert(3, 'test')
print(my_list)
# Ahora el valor de la lista es [7, 6, 3, 'test', 4, 5]

Al hacer esto, el valor que estaba en esa posición y los siguientes se desplazarán una posición.

Cuando queramos sustituir el valor de una posición en concreto deberemos escribir el nombre de la lista, abrir corchetes y añadir la posición del dato que queremos reemplazar, cerramos corchetes, escribimos igual y ya añadimos el valor que le queramos dar.

my_list = list([7,6,3,4,5])

my_list[1] = 4

print(my_list)
# Ahora el valor de la lista es [7, 4, 3, 4, 5]

En este caso hemos sustituido el valor 6 que estaba en la posición uno de la lista por 4.

Si queremos eliminar un elemento que conozcamos su valor usaremos remove, en el caso de que esté repetido el valor pasado por parámetro, solo borraría el primer ítem que encontrase:

my_list = [7, 4, 3, 4, 5]

my_list.remove(4)

print(my_list)
# Print: [7, 3, 4, 5]

Al ejecutar este código solo elimina el primer valor igual a 4, el segundo y si hubiera más se mantendrían.

En el caso de que lo queramos hacer por clave usaremos su posición en la lista con el método pop, si no pasamos un parámetro, eliminará el valor guardado en la última posición:

my_list = ['z', 'x', 'm', 'r', 'b']

my_list.pop(2)

print(my_list)
# Print: ['z', 'x', 'r', 'b']
my_list.pop()

print(my_list)
# Print: ['z', 'x', 'r']

Para unir listas podemos usar el operador + como se ve en el siguiente ejemplo, esto nos devolverá una nueva lista con los elementos de las otras dos listas.

my_list = ['x']
my_list2 = ['m', 'c', 'r']
my_list3 = my_list + my_list2
print(my_list3)
# Print: ['x', 'm', 'c', 'r']

Para repetir los elementos de una lista usaremos el operador * sobre la lista en la que queramos multiplicar sus valores.

my_list = ['a']
my_list_x_5 = my_list * 5
print(my_list_x_5)
# Print: ['a','a','a','a','a']

Si queremos invertir el orden de una lista lo haremos como en el siguiente ejemplo.

my_list = [1, 2, 3, 4, 5]
my_list_reversed = my_list[::-1]
print(my_list_reversed)
# Print: [5, 4, 3, 2, 1]

En el caso de que queramos ordenar la lista utilizaremos el método sort, que ordenará nuestra lista de forma ascendente.

my_list = [2,1,5,4,3]
my_list.sort()
print(my_list)
# Print: [1,2,3,4,5]

Si queremos vaciar una lista, podemos utilizar el método clear().

my_list = [2,1,5,4,3]
my_list.clear()
print(my_list)
# Print: []

DICCIONARIOS

Un diccionario es una estructura de datos que almacena la información en forma de pares con una clave única y un valor asociado. Los diccionarios se pueden declaran con (llaves) {} o con la función dict().

# Diccionario vacío inicializado con dict()
my_dict = dict()
# Diccionario vacío inicializado con llaves
my_dict = {}
# Diccionario inicializado con valores
my_dict = {'status': True, 'msg': 'ok'}

Para acceder al valor de un elemento, escribiremos el nombre de la variable seguido de apertura de corchetes, el nombre de la clave y cierre de corchetes:

my_dict = {
    'hello': 'World',
    'msg': 'ok'
}

print(my_dict['hello'])
# Print: World

Cuando iteramos en diccionarios podemos hacerlo a través de las claves, valores o ítems (pares clave-valor). Para ello podremos usar el bucle for y para iterar sobre las claves, el nombre del diccionario y el método keys(), en el caso de los valores utilizaremos el método values() y para iterar sobre la clave y el valor, usaremos el método items().

my_dict = {
    'hello': 'World',
    'msg': 'ok'
}

# Iterar en llaves
for key in my_dict.keys():
    print(key)

# Iterar en valores
for value in my_dict.values():
    print(value)

# Iterar en ítems
for key, value in my_dict.items():
    print(f'key {key}, value {value}')

Operaciones disponibles para la manipulación de diccionarios

Si queremos vaciar un diccionario, al igual que en las listas, podremos usar el método clear().

my_dict.clear()
print(my_dict)
# Print: {}

Otra forma de obtener el valor de una clave de un diccionario es utilizando el método get(). Dentro de este método podremos pasar la clave que estamos buscando y opcionalmente un valor por defecto si no encuentra ese valor. En el caso de no encontrarlo y no poner ningún valor por defecto, devolverá None.

print(my_dict.get('hello'))
# Print: World
print(my_dict.get('new_key'))
# Print: None
print(my_dict.get('new_key', 'default'))
# Print: default

Si queremos obtener un listado con todas las claves de un diccionario, podemos convertirlo en una lista de la siguiente forma:

my_dict = {
    'hello': 'World',
    'msg': 'ok'
}

print(list(my_dict))
# Print: ['hello', 'msg']

Para obtener el número de elementos de un diccionario usando la función len.

my_dict = {
    'hello': 'World',
    'msg': 'ok'
}

print(len(my_dict))
# Print: 2

Para comprobar si existe una clave o no dentro de un diccionario, podemos usar el operador in, esto nos devolverá True en caso de encontrarlo y False si no lo encuentra, también podemos utilizar el operador not in para verificar que una clave no esté en un diccionario:

my_dict = {
    'hello': 'World',
    'msg': 'ok'
}

result = 'hello' in my_dict
print(result)
# Print: True
result2 = 'msg' not in my_dict
print(result2)
# Print: False

TUPLAS

Son similares a las listas, pero lo que las diferencia es que estas son inmutables, esto quiere decir que no puede modificarse de ninguna forma después de su creación.

Se pueden definir de estas dos formas:

my_tuple = (1,2,3,4)

# También de esta forma

my_tuple = tuple((1, 2, 3, 4))

Para acceder a un valor dada una posición lo haremos igual que con las listas, escribiendo el nombre de la tupla seguido de apertura de corchetes, posición que buscamos y cierre de corchetes:

my_tuple = tuple(('x', 'b', 'm', 'r'))
print(my_tuple[1])
# Print: b

SETS

Los sets son muy similares a las listas, pero estas no permiten elementos repetidos e incluso si lo declaras con valores repetidos, solo se guardará un valor único.

Para declarar un set, escribiremos set, abriremos paréntesis y dentro introduciremos una lista, después cerramos paréntesis y listo:

my_set = set([1, 2, 3])

Operaciones disponibles para la manipulación de sets

Si queremos añadir un nuevo elemento a un set ya existente, utilizaremos el método add() y pasaremos por parámetro el valor a añadir:

my_set = set([2, 6, 8, 5])
my_set.add(11)
print(my_set)
# Print: {2, 5, 6, 8, 11}

En el caso de querer eliminar un elemento, utilizaremos el método remove() y pasaremos por parámetro a eliminar, si este existe lo eliminará, si no, lanzará una excepción.

my_set = set([2, 6, 8, 5])
my_set.remove(8)
print(my_set)
# Print: {2, 5, 6}

También podemos usar el método discard() que es igual a remove() pero en este caso no lanzará una excepción si no encuentra el valor.

my_set = set([2, 6, 8, 5])
my_set.discard(1)
print(my_set)
# Print: {8, 2, 5, 6}

Para vaciar un set podemos utilizar el método clear().

Si queremos fusionar dos sets podemos utilizar el método union().

my_set_1 = set([1, 2, 3])
my_set_2 = set([3, 4, 5])
my_new_set = my_set_1.union(my_set_2)

print(my_new_set)
# Print: {1, 2, 3, 4, 5}

a.union(b) # set([1,2,3,4,5])
a.intersection(b) # set([3])
a.difference(b) # set([1,2])

Para averiguar la coincidencia entre dos sets, usaremos el método intersection(), esto nos devolverá un set con los valores que comparten ambos sets.

my_set_1 = set([1, 2, 3])
my_set_2 = set([3, 4, 5])
my_new_set = my_set_1.intersection(my_set_2)

print(my_new_set)
# Print: {3}

Si queremos comparar que valores de un set no están en un segundo set, usaremos el método difference().

my_set_1 = set([1, 2, 3])
my_set_2 = set([3, 4, 5])
my_new_set = my_set_1.difference(my_set_2)

print(my_new_set)
# Print: {1, 2}

Bonus, dictionary comprehensions y list comprehensions

Para terminar os hablaré de los dictionary comprehensions y list comprehensions que nos permite generar listas y diccionarios de forma más sencilla al poder comprimir varias líneas de código en una sola línea.

Si por ejemplo queremos crear una lista que contenga los múltiplos de tres de un rango de números:

multiplos = []
for num in range(1, 11):
    multiplos.append(num*3)

Con list comprehensions lo podemos encapsular todo en una sola línea como os muestro a continuación:

multiplos = [num*3 for num in range(1, 11)]

El primer valor que aparece (num*3) es el que se guardará en la lista, luego se crea el for y por último, aunque en este caso no lo estamos usando, se podría añadir una condición. Como veis, hemos conseguido condensar tres líneas en una, lo que hará que nuestro código se vea más compacto y limpio.

Para el caso de dictionary comprehensions serían bastante similar como vamos a ver en el siguiente ejemplo en el que queremos guardar los múltiplos de 4 además de una clave numérica.

multiplos = {}
for num in range(1, 11):
    multiplos[num] = (num*4)

Con dictionary comprehensions lo haríamos de esta forma:

multiplos = {num: num*4 for num in range(1, 11)}

La primera variable num sería la clave, el valor sería num*4 y luego ya tendríamos el bucle for.

Como veis, Python nos ofrece varias herramientas para trabajar con nuestros datos, os animo a que las uséis y cualquier duda recordad que la podéis poner en los comentarios ;).

Espero que este post te ayude y como siempre, te recomiendo seguirme en Twitter para estar al tanto de los nuevo contenido. Ahora también puedes seguirme en Instagram donde estoy subiendo tips, tutoriales en vídeo e información sobre herramientas para developers.

Por último os dejo mi guía para aprender a trabajar con APIs donde explico todo el funcionamiento de una API, el protocolo HTTP y veremos como construir una API con arquitectura REST.

Nos leemos 👋.