UD008461_V(02) MD.PlantillaTexto(03)Esp.

dot

ESTRUCTURAS DE DATOS EN PYTHON

 ESTRUCTURAS DE DATOS EN PYTHON

ÍNDICE

TU RETO EN ESTA UNIDAD ........................................................................ 3

1. ESTRUCTURAS DE DATOS ..................................................................... 5
1.1. SECUENCIAS .................................................................................................. 6
1.1.1. LISTAS .................................................................................................... 6
1.1.1.1. Métodos de consulta y modificación de listas ..................................... 13
1.1.2. TUPLAS ................................................................................................ 19
1.1.3. DE VUELTA CON LAS STRINGS .................................................................. 22
1.2. CONJUNTOS (DATASET) ............................................................................. 22
1.3. DICCIONARIOS ............................................................................................. 26
1.4. DEFINICIONES POR COMPRENSION .......................................................... 29
1.5. GENERADORES ............................................................................................ 33
¿QUÉ HAS APRENDIDO? .......................................................................... 37
BIBLIOGRAFÍA ......................................................................................... 39

1
 ESTRUCTURAS DE DATOS EN PYTHON

TU RETO EN ESTA UNIDAD

Ya has llegado hasta aquí… ¡enhorabuena! Empiezas a disponer de conocimien-

tos para crear tus propios programas, pero aún te falta por ver algo esencial y
de suma importancia: las estructuras de datos.

¿Sabrías decir con unas pocas palabras lo que son este tipo de estructuras? No
te preocupes si ahora mismo no sabes describirlo con exactitud. Al finalizar esta
unidad, comprenderás perfectamente su uso y los diferentes tipos que existen,
así como las propiedades de cada una.

Vamos a ello…

3
 ESTRUCTURAS DE DATOS EN PYTHON

1. ESTRUCTURAS DE DATOS
Python incorpora varios tipos compuestos de datos de forma nativa. Podemos
ver un tipo compuesto como una estructura de datos que nos permite almace-
nar una colección de elementos o valores. Si has trabajado con otros lenguajes,
un ejemplo sencillo sería un vector o array de elementos. Python nos ofrece
más alternativas, con características diferentes dependiendo de cómo se alma-
cenan los valores dentro de la estructura y de qué operaciones podemos hacer.

Aunque podríamos englobar también a las cadenas (str y unicode) y los conjun-
tos (set y frozenset) o los constructores dentro de esta categorización, en esta
unidad vamos a ver las tres estructuras de datos principales de Python:

 Tuplas.

 Listas.

 Diccionarios (o tablas hashing).

Resumiendo, y para comenzar con la unidad, las forma de acceder a estas es-
tructuras de control (independientemente del tipo que sean) son:

 Mediante Índices: secuencia[0], secuencia[1], secuencia[2]...

secuencia[n].

 Mediante slicing o porciones: secuencia[comienzo:fin:paso].

 Mediante iteradores y estructuras de control (bucle for).

5
ESTRUCTURAS DE DATOS EN PYTHON

Las estructuras de datos en Python podríamos dividirlas en dos grupos, las se-
cuenciales (formadas por secuencias de datos ordenados) y los conjuntos de
datos, que no son ordenados. A su vez, también podemos dividirlos por estruc-
turas de datos mutables e inmutables, como vimos en la unidad de iniciación.
Vamos a profundizar un poco más en todos estos términos.

1.1. SECUENCIAS

Empezaremos por las estructuras de tipo secuencial. Son tipos de datos com-
puestos por una serie de elementos, preservando el orden o posición en el que
se añaden a la estructura. Por este motivo, se dice que son tipos ordenados.

Como a veces se presta a confusión, vamos a recalcarlo. Aquí ordenado no sig-

nifica que conforme añades elementos, estos se reordenen (p.ej. numéricamen-
te o alfabéticamente). Solo hace referencia a que conservan el orden en el que
son añadidos, es decir, su orden posicional.

Todos los subtipos de secuencias en Python tienen en común varias operacio-

nes, como el acceso indexado o por posición, el rebanado (por lo que más quie-
ras, no lo llames nunca así) o “slicing”, la concatenación o la pertenencia. Va-
mos a verlo todo más en profundidad.

1.1.1. LISTAS

Comenzamos con esta estructura de datos secuencial y mutable (podemos

acceder a sus componentes y modificarlos por medio de sus métodos propios).
En Python, las listas son probablemente el tipo compuesto de uso más extendi-
do por su versatilidad y sencillez. Una lista es una secuencia ordenada de ele-
mentos. A diferencia de los vectores o arrays de otros lenguajes, en una lista se
pueden mezclar elementos de tipos distintos sin problema. Aunque lo habitual
es que todos los elementos tengan el mismo tipo.

La forma común de definir una lista es incluyendo los elementos separados por
comas entre un par de corchetes.

6
 ESTRUCTURAS DE DATOS EN PYTHON

Ejemplos de listas

Si te has fijado, la última lista de ejemplo tiene listas anidadas como elementos.
¿Cuantos elementos dirías que tiene la lista de nivel superior? ¿Serías capaz de
identificarlos? Podemos usar lo que hemos aprendido de bucles para compro-
barlo…

for elemento in listas_anidadas:

print(elemento)

Aqui hay

['listas', 'anidadas']

[1, 2]

Para acceder a los elementos de una lista por su índice o posición, ponemos el
índice entre corchetes también.

7
ESTRUCTURAS DE DATOS EN PYTHON

El primer elemento de una lista (y de cualquier se-

cuencia) tiene el índice cero. Así que, si una lista tiene
n elementos, para acceder al último tendremos que
usar el índice (n - 1).

Si queremos obtener la longitud de una lista (el número de elementos que con-
tiene), tan solo debemos hacer uso de la función len().

# Longitud de la lista

len(lista_nums)

# Resultado: 6

# Longitud de la lista anidada:

# cada "sub‐lista" interna es vista como un único elemento

len(listas_anidadas)

# Resultado: 3

# Seleccionar un elemento

lista_nums[0] # El primer valor lo obtenemos con el índice cero

# Resultado: 1

lista_nums[5] # El elemento para el índice 5

# Resultado: 4

lista_nums[len(lista_nums) ‐ 1] # El último elemento está en LEN ‐

1

# Resultado: 4

# Al seleccionar en una lista anidada

listas_anidadas[1] # El elemento devuelto puede ser otra lista

# Resultado: ['listas', 'anidadas']

8
 ESTRUCTURAS DE DATOS EN PYTHON

# Si usamos índices negativos, empezamos a contar desde el final

lista_nums[‐1] # Devuelve el último elemento de la lista

# Resultado: 4

lista_nums[‐len(lista_nums)] # Devuelve el primer elemento de la li

sta

# Resultado: 1

Para que comprendas mejor cómo funcionan los índices para acceder a un
elemento, imagina que tenemos la lista [ 'A', 'B', 'C', 'D', 'E', 'F' ].
La siguiente figura muestra a qué posición referencia un índice positivo o un
índice negativo.

En lugar de ver los índices "apuntando" a cada elemento, pensemos que los índi-
ces marcan las posiciones entre elementos de la secuencia. En este caso, el índice
6 referencia una posición fuera de los límites de la lista y produciría un error.

Ahora es más fácil ver cómo podemos seleccionar un "slice" de elementos conti-
guos de una lista. Indicamos el índice o posición inicial desde donde empeza-
mos la selección y la posición final hasta donde queremos llegar, escribiéndolos
dentro de los corchetes separados por dos puntos (:). En las slices, el elemento
correspondiente al límite inicial siempre se incluye, pero el elemento en el límite
final queda excluido.

9
ESTRUCTURAS DE DATOS EN PYTHON

letras = ['A','B','C','D','E','F']

# Seleccionamos una "slice" con los dos primeros elementos

letras[0:2]

# Resultado: ['A', 'B']

letras[2:5]

# Resultado: ['C', 'D', 'E']

# Si no especificamos el segundo índice, seleccionamos hasta el fin

letras[2:]

# Resultado: ['C', 'D', 'E', 'F']

# y si no especificamos el primer índice, seleccionamos desde el pr

incipio

letras[:4]

# Resultado: ['A', 'B', 'C', 'D']

# También podemos usar la notación de índices negativos.

# Seleccionamos desde la penúltima posición (incluida) hasta el

final

letras[‐2:]

# Resultado: ['E', 'F']

# Seleccionamos desde el inicio hasta la penúltima posición

(excluida)

letras[:‐2]

# Resultado: ['A', 'B', 'C', 'D']

# Como el primer índice siempre se incluye

# y el segundo siempre se excluye,

# podemos reconstruir la lista así

letras[:2] + letras[2:]

# Resultado: ['A', 'B', 'C', 'D', 'E', 'F']

10
 ESTRUCTURAS DE DATOS EN PYTHON

Como hemos comentado al empezar el apartado, las listas sí son mutables, es

decir, podemos modificar el contenido de los elementos de una lista de las si-
guientes formas…

print(lista_lenguajes)

["C", "python", "fortran", "cobol"]

# modificamos un elemento individual

lista_lenguajes[0] = "java"

print(lista_lenguajes)

["java", "python", "fortran", "cobol"]

# también podemos reemplazar los valores de una "slice"

lista_lenguajes[2:] = ["kotlin", "brainfuck"]

print(lista_lenguajes)

['java', 'python', 'kotlin', 'brainfuck']

# o eliminar algunos valores, reemplazando con la lista vacía

lista_lenguajes[1:3] = []

print(lista_lenguajes)

['java', 'brainfuck']

# o vaciarla entera

lista_lenguajes[:] = []

print(lista_lenguajes)

[]

Otra forma de modificar su valor es por medio de la concatenación (o réplica) de

listas. Es decir, podemos “sumar” dos listas o replicar su contenido.

11
ESTRUCTURAS DE DATOS EN PYTHON

lista_1 = ['a', 'b', 'c']

lista_2 = [100, 200, 300]

# concatenación

lista_1 + lista_2

['a', 'b', 'c', 100, 200, 300]

# replicar la lista tres veces

3 * lista_1

['a', 'b', 'c', 'a', 'b', 'c', 'a', 'b', 'c']

También podemos extraer los elementos de una lista y asignarlos a distintas

variables de forma sencilla con una sola instrucción.

x, y, z = lista_2

print(x)

print(y)

print(z)

# Resultado:

100

200

300

12
 ESTRUCTURAS DE DATOS EN PYTHON

1.1.1.1. Métodos de consulta y modificación de listas

Cuando necesitemos realizar consultas o modificar los valores de las mismas, en

Python disponemos de la ayuda de algunos métodos que podremos utilizar en
nuestro beneficio. Vamos a verlos…

 Agregar un elemento al final de la lista: append().

 Extraer el último elemento de la lista: pop().

 Insertar un elemento delante de una posición concreta: insert().

 Buscar la posición concreta de un elemento de la lista: index().

 Contar el número de veces que aparece un elemento: count().

 Borrar el primer elemento de la lista: remove().

 Ordenar los valores de la lista: sort().

 Invertir el orden de la lista: reverse().

 Limpiar los elementos de una lista (vaciar): clear().

Luego tenemos una orden que nos permite eliminar un valor concreto dentro
de una lista:

 Borrar un elemento indicando la posición: del.

Esta es diferente del método .pop(), el cual devuelve un valor. La instrucción del
también puede usarse para quitar secciones de una lista o vaciar la lista completa.

a = [‐1, 1, 66.25, 333, 333, 1234.5]

del a[0]

# Resultado: [1, 66.25, 333, 333, 1234.5]

del a[2:4]

# Resultado: [1, 66.25, 1234.5]

del a[:]

# Resultado: []

13
ESTRUCTURAS DE DATOS EN PYTHON

del puede usarse también para eliminar variables de

una lista.
del a.

No era ninguna broma cuando te contábamos las bondades de las listas y su

versatilidad, ¿no crees? Vamos a ver un ejemplo de cada método del listado que
acabas de leer para que te quedes aún más con su funcionamiento.

lista_1 = ['a', 'b', 'c']

# añadir un elemento al final de la lista

lista_1.append('d')

print(lista_1)

# Resultado: ['a', 'b', 'c', 'd']

# extraer el último elemento de la lista

ultimo_valor = lista_1.pop()

print(ultimo_valor)

print(lista_1)

# Resultado: d

#['a', 'b', 'c']

# insertar un elemento delante de una posición concreta

# inserta 'e' en la posición cero (al principio)

lista_1.insert(0, 'e')

# inserta 'c' en la posición 2

lista_1.insert(2, 'c')

print(lista_1)

# Resultado: ['e', 'a', 'c', 'b', 'c']

14
 ESTRUCTURAS DE DATOS EN PYTHON

# buscar en qué posición está un elemento

# (si no existe dará un error)

lista_1.index('b')

# Resultado: 3

# contar el número de veces que aparece un elemento

lista_1.count('c')

# Resultado: 2

# borrar el primer elemento de la lista

# que coincida con el valor dado

lista_1.remove('c')

print(lista_1)

# Resultado: ['e', 'a', 'b', 'c']

# ordenar los valores de la lista

# (dependiendo del tipo: alfabéticamente, numéricamente...)

lista_1.sort()

print(lista_1)

# Resultado: ['a', 'b', 'c', 'e']

# invertir el orden de la lista

lista_1.reverse()

print(lista_1)

# Resultado: ['e', 'c', 'b', 'a']

# borrar un elemento indicando la posición

del lista_1[2]

print(lista_1)

# Resultado: ['e', 'c', 'a']

# limpiar todos los elementos de la lista

lista_1.clear()

print(lista_1)

# Resultado: []

15
ESTRUCTURAS DE DATOS EN PYTHON

Antes de continuar, vamos a aprovechar para explicar un detalle más sobre las
variables, su contenido y lo que ocurre al hacer asignaciones en Python.

Imagina el siguiente caso habitual. Tienes una variable (pongamos lista1) y la

inicializas con unos valores cualesquiera. Más adelante, tal vez tras hacer varios
cálculos y operaciones con la primera variable, necesitas crear otra nueva varia-
ble (digamos lista2) e inicializarla con la misma lista que tenga la primera en ese
momento. Así que le asignas la primera variable a la última.

# Creamos e inicializamos la primera variable

lista1 = [1, 2, 3]

# Hacemos nuestras operaciones ...

# Y ahora necesitamos crear una nueva variable

# e inicializarla con la misma lista que tenga lista1

lista2 = lista1

print(lista2)

# Resultado: [1, 2, 3]

# Obviamente, ahora deben tener el mismo valor

lista1 == lista2

# Resultado: True

Obviamente, tras la asignación, ambas variables tienen el mismo valor. Pero es

que, en realidad, no solo tienen el mismo valor, si no que apuntan al mismo
contenido.

Ambas son dos nombres o referencias al mismo dato, a la misma lista, y no dos
copias distintas con los mismos valores (¿alguien se acuerda de los punteros en C++?).

Una variable en Python no deja de ser eso, un nombre o referencia a un valor

o estructura de datos que está almacenada de algún modo en memoria. En
Python, la operación de asignación de una variable a otra no copia el contenido,
si no que define un nuevo nombre o referencia al mismo contenido que la va-
riable original.

16
 ESTRUCTURAS DE DATOS EN PYTHON

Podemos ver que dos variables representan el mis-

mo objeto con el operador is.

¿Y esto qué implica? Piénsalo... Si modificamos un elemento en la segunda va-

riable, ¿qué ocurre con la primera? Como ambas variables no son más que
nombres o referencias para la misma lista en memoria, la primera variable mos-
trará también el nuevo valor.

# Comprobamos que las dos variables

# representan el mismo objeto

lista2 is lista1 # True

# Resultado: True

# Modificamos lista2

lista2[1] = 99

# Y vemos que lista1 nos devuelve

# el mismo contenido modificado

print(lista1)

# Resultado: [1, 99, 3]

No obstante, si en lugar de modificar el valor de los elementos de la lista, asig-

namos una lista distinta, estaremos definiendo un nuevo objeto o estructura de
datos. La variable usada pasará a nombrar ese nuevo objeto independiente; las
dos variables ya no serán referencias al mismo contenido.

# Si asignamos una nueva lista a la segunda variable

lista2 = [7, 8, 9]

17
ESTRUCTURAS DE DATOS EN PYTHON

# Dejan de referenciar al mismo contenido

lista2 is lista1 # False

# Incluso aunque usemos la primera variable

# en la expresión para definir de la segunda

lista2 = 2 * lista1 # Replicación de la primera lista

# Las estructuras de datos que referencian son distintas

lista2 is lista1 # False

A la hora de trabajar con estructuras de datos mutables (como las listas), debe-
rás tener todo esto en cuenta para evitar modificar accidentalmente el conteni-
do de una variable al manipular una segunda.

Si necesitas una copia idéntica pero independiente de una lista, puedes usar el
método copy().

lista1 = [1, 2, 3]

# Con .copy() creas una nueva lista, copia exacta de la original,

# pero independiente de esta

lista2 = lista1.copy()

# Los valores en las listas son iguales

lista2 == lista1 # True

# ¡¡Pero no son el mismo objeto!!

lista2 is lista1 # False

Como ves, dispones de una amplia cantidad de métodos para hacerte la vida
más sencilla la hora de trabajar con listas. Vamos a pasar a la siguiente estructu-
ra de datos, que también te encantará, pero de otra forma.

18
 ESTRUCTURAS DE DATOS EN PYTHON

1.1.2. TUPLAS

Las tuplas son un tipo de datos similar a las listas. Como ellas, las tuplas están
formadas por una secuencia de elementos ordenados. Las diferencias princi-
pales son dos:

 Desde el punto de vista sintáctico, se definen usando paréntesis en

lugar de corchetes (por eso es fácil equivocarse al declararlas).

 Desde el punto de vista semántico, las tuplas son inmutables.

¿Qué queremos decir con inmutables? Pues que una vez que has creado una tu-
pla definiendo sus elementos, ya no puedes modificar los valores que contiene.

Vamos a ver un ejemplo de tupla para que comprendas mejor esta estructura
de datos.

#!/usr/bin/python

# ‐*‐ coding: utf‐8 ‐*‐

# construimos las tuplas poniendo sus elementos

# separados por comas entre dos paréntesis

palos_baraja = ("bastos", "oros", "espadas", "copas")

valores_baraja = ('A', 2, 3, 4, 5, 6, 7, 8, 9, 10, 'sota',

'caballo', 'rey')

as_de_copas = (valores_baraja[0], palos_baraja[3])

caballo_de_bastos = (valores_baraja[11], palos_baraja[0])

# podemos usar tuplas como elementos anidados dentro otra tupla

mano = (as_de_copas, caballo_de_bastos)

print(mano)

# Resultado: (('A', 'copas'), ('caballo', 'bastos'))

print(mano[0])

# Resultado: ('A', 'copas')

19
ESTRUCTURAS DE DATOS EN PYTHON

print(mano[1])

# Resultado: ('caballo', 'bastos')

# también podemos usar listas como elementos,

# ¡cualquier objeto en realidad!

jugador = ("jugador_1", [as_de_copas, caballo_de_bastos])

print(jugador)

# Resultado: ('jugador_1', [('A', 'copas'), ('caballo', 'bastos')])

Si intentas modificar la tupla, obtendrás un error. In-

téntalo con el ejemplo que tienes justo arriba, agre-
gando esta sentencia.
mano[0] = ('caballo', "bastos").

En realidad, Python nos permite definir una tupla sin usar los paréntesis al
crearla. Es decir, poniendo simplemente los elementos separados por comas.

De todas formas, te recomendamos utilizar siempre los paréntesis. Para empezar,

porque así resaltas que es una tupla y entiendes más fácilmente tu código. Y des-
pués porque cuando uses tuplas anidadas o expresiones más complejas para
definir los elementos, vas a necesitar incluir los paréntesis obligatoriamente.

Así que, ¿para qué hacer distinciones? ¡Simplifiquemos!

Además, hay dos casos especiales de creación de tuplas: la tupla vacía y la tupla
de un solo elemento. Las tuplas vacías se crean con una pareja de paréntesis
vacía, sin ningún elemento dentro.

20
 ESTRUCTURAS DE DATOS EN PYTHON

Para crear una tupla con un único elemento, lo rodeamos entre paréntesis, pe-
ro es necesario añadir una coma justo detrás del elemento y antes del cierre de
paréntesis. Parece raro, pero como los paréntesis también sirven para "encapsu-
lar" una expresión (p.ej. (3 * 4)), Python necesita una pista para distinguir si
queremos construir una tupla con un solo valor o no.

# Creamos la tupla vacía con una pareja de paréntesis vacía, sin

ningún

elemento

tupla_vacia = ()

print(tupla_vacia)

# Resultado: ()

# Creamos una tupla con un solo elemento

tupla_un_elemento = (1,)

print(tupla_un_elemento)

# Resultado: (1,)

Resumiendo, existen tres tipos generales de tuplas:

 tupla = ( ) # Instancia vacía.

 tupla = (1,2,3) # tupla homogénea.

 tupla = ("hola", 20, [1, 2, 3]) # tupla heterogénea (varios tipos de datos).

Como ves, salvo por la particularidad de la inmutabilidad de las tuplas, la forma

de trabajar con esta estructura de datos es similar a las listas.

21
ESTRUCTURAS DE DATOS EN PYTHON

1.1.3. DE VUELTA CON LAS STRINGS

Si recuerdas, cuando presentamos las cadenas de caracteres en una unidad

anterior, vimos que podíamos extraer un elemento usando un índice entre cor-
chetes, y que podíamos seleccionar también una "slice", o concatenar cadenas, o
replicar una cadena n veces...

Sabes por donde voy, ¿verdad? Efectivamente, las cadenas de caracteres son
otro tipo de secuencia en Python (como ya te advertimos entonces). Unas
secuencias con la particularidad de que sólo se componen de caracteres de
texto, y que, a la hora de representarlas, se utiliza una notación más compacta y
sencilla para los humanos, escribiendo simplemente el texto entre comillas.
Además, son inmutables (como las tuplas) y llevan añadidas una serie de fun-
ciones o métodos especiales solo para su uso con cadenas.

1.2. CONJUNTOS (DATASET)

Ya has aprendido que en Python tenemos los tipos lista, tupla y cadena de texto,
y que son tipos secuenciales, es decir, son colecciones ordenadas de elementos.

Bueno, dejemos ahora las secuencias. En Python tenemos también tipos com-
puestos de datos que no son ordenados. Es decir, que sus elementos no con-
servan el orden en el que son colocados.

El tipo compuesto no ordenado más básico es el conjunto (o dataset en

Python). Un conjunto es una colección no ordenada de elementos, y donde
además no puede haber elementos repetidos. Un conjunto sí es modificable.
Podemos eliminar o añadir nuevos elementos, siempre que no estén ya inclui-
dos en el conjunto.

La utilidad de este tipo viene justamente cuando necesitamos controlar elemen-

tos duplicados o saber si un elemento ha sido incluido ya (pertenece) a un con-
junto, sin importarnos la posición.

22
 ESTRUCTURAS DE DATOS EN PYTHON

Para crear un conjunto escribimos los elementos entre un par de llaves y sepa-
rados por comas. Si queremos crear un conjunto vacío utilizaremos la función
set(), y no un par de llaves vacías ({}) como podrías pensar. Un poco más ade-
lante te mostraremos que un par de llaves vacías crean un diccionario vacío.

Vamos a ver un pequeño ejemplo campista, que seguro que te deja las cosas
mucho más claras con los datasets:

#!/usr/bin/python

# ‐*‐ coding: utf‐8 ‐*‐

# Vamos a controlar qué objetos

# añadimos en nuestra mochila para una excursión.

# Creamos un conjunto vacío

# (solo por probar, para este ejemplo no nos haría falta)

en_mochila = set()

# 'inicializamos' el dataset: incluimos varios objetos

en_mochila = {"bocadillo", "agua", "linterna", "agua", "cuerda"}

# si imprimimos el valor del dataset, veremos que el "agua"

# no aparece duplicada ‐ ya sabemos que llevamos agua

print(en_mochila)

# Resultado: {'cuerda', 'linterna', 'bocadillo', 'agua'}

# anotamos que metemos un cuchillo

en_mochila.add("cuchillo")

print(en_mochila)

# Resultado: {'agua', 'cuchillo', 'bocadillo', 'cuerda', 'linterna'

}

# para comprobar si un elemento está en el conjunto

# usamos 'in'

"bocadillo" in en_mochila # True

23
ESTRUCTURAS DE DATOS EN PYTHON

"cerillas" not in en_mochila # True

# también podemos quitar un elemento del conjunto

en_mochila.discard("cuerda")

print(en_mochila)

# Resultado: {'agua', 'cuchillo', 'bocadillo', 'linterna'}

En el uso de los dataset, también disponemos de las operaciones habituales

entre conjuntos: unión, diferencia, intersección, etc…

a = {1, 2, 3, 5, 8}

b = {1, 2, 4, 8, 16}

# unión de a y b

a.union(b)

# Resultado: {1, 2, 3, 4, 5, 8, 16}

# también podemos hacerlo así: elementos que están en a ó en b

a | b

# Resultado: {1, 2, 3, 4, 5, 8, 16}

# intersección de a y b

a.intersection(b)

# Resultado: {1, 2, 8}

# también podemos hacerlo así: elementos que están en a y en b

a & b

# Resultado: {1, 2, 8}

# diferencia entre a y b

a.difference(b)

# Resultado: {3, 5}

24
 ESTRUCTURAS DE DATOS EN PYTHON

# también podemos hacerlo así: elementos que están en a pero no

están en

a ‐ b

# Resultado: {3, 5}

# diferencia simétrica o excluyente entre a y b

a.symmetric_difference(b)

# Resultado: {3, 4, 5, 16}

# también podemos hacerlo así: elementos que están exclusivamente

# bien en a o bien en b (pero no en ambos)

a ^ b

# Resultado: {3, 4, 5, 16}

s = {1, 2}

# ¿s es un subconjunto de a?

s.issubset(a)

# Resultado: True

# o dicho de otro modo: todos los elementos de s están en a

s <= a

# Resultado: True

# ¿a es un superconjunto de s?

a.issuperset(s)

# Resultado: True

# o bien…: a incluye todos los elementos que están en s

a >= s

# Resultado: True

25
ESTRUCTURAS DE DATOS EN PYTHON

Como puedes observar, la cantidad de acciones que podemos realizar a los da-
taset es brutal, lo que los posiciona como una forma genial de realizar labores
matemáticas con conjuntos de datos.

1.3. DICCIONARIOS

Otro tipo de dato útil incluido en Python de forma nativa es el diccionario. Los
diccionarios se encuentran a veces en otros lenguajes como “memorias asocia-
tivas” o “arreglos asociativos”. A diferencia de las secuencias, que se indexan
mediante un rango numérico, los diccionarios se indexan con claves, que pue-
den ser cualquier tipo inmutable; las cadenas y números siempre pueden ser
claves. Las tuplas pueden usarse como claves si solamente contienen cadenas,
números o tuplas; si una tupla contiene cualquier objeto mutable directa o indi-
rectamente, no puede usarse como clave. No puedes usar listas como claves,
ya que las listas pueden modificarse usando asignación por índice, asignación
por sección, o métodos como append() y extend(). Resumiendo, una clave
tiene que estar formada por un elemento inmutable, no puede cambiar una
vez que se ha añadido junto con su valor al diccionario.

Lo mejor es pensar en un diccionario como un conjunto no ordenado de pa-

res clave: valor, con el requerimiento de que las claves sean únicas (dentro de
un diccionario en particular). Colocar una lista de pares clave:valor separados
por comas entre las llaves añade pares clave:valor iniciales al diccionario; esta
también es la forma en que los diccionarios se presentan en la salida. Para ac-
ceder a un valor, utilizamos los corchetes como haríamos en una lista o una
tupla, solo que en este caso indicamos la clave y no un índice de posición.

Un par de llaves sin contenido crean un diccionario

vacío: {}.

26
 ESTRUCTURAS DE DATOS EN PYTHON

Las operaciones principales sobre un diccionario son:

 Guardar un valor con una clave.

 Extraer ese valor dada la clave.

También es posible borrar un par clave:valor con del. Si usas una clave que ya
está en uso para guardar un valor, el valor que estaba asociado con esa clave se
pierde. Extraer un valor usando una clave no existente nos arrojará un bonito
mensaje de error, como es lógico.

Vamos a verlo más fácilmente con algunos ejemplos sencillos:

extension = {'juan': 4098, 'pedro': 4139}

extension['guido'] = 4127

print(extension)

# Resultado: {'pedro': 4139, 'juan': 4098, 'guido': 4127}

extension['juan']

# Resultado: 4098

del extension['pedro']

extension['ivan'] = 4127

print(extension)

# Resultado: {'juan': 4098, 'ivan': 4127, 'guido': 4127}

print(extension.keys())

# Resultado: dict_keys(['juan', 'guido', 'ivan'])

print('guido' in extension)

# Resultado: True

27
ESTRUCTURAS DE DATOS EN PYTHON

El método keys() de un diccionario devuelve una lista de todas las claves en

uso de ese diccionario, pero en un orden arbitrario (si la quieres ordenada, sim-
plemente usa el metodo sort() sobre la lista de claves). Para verificar si una
clave está en el diccionario, utiliza la palabra clave in.

Tenemos distintas formas de iterar un diccionario. Podemos iterar sobre las

claves del diccionario de forma directa. También podemos iterar sobre las pare-
jas (clave, valor).

# Podemos iterar directamente sobre las claves de un diccionario

libreta_telefonos = {'Carlos': 5556033, 'Javier': 5556051,

'Daniel': 5556056}

for nombre in libreta_telefonos:

print(nombre, "=", libreta_telefonos[nombre]) # Resultado:

# Carlos = 5556033

# Javier = 5556051

# Daniel = 5556056

# O podemos iterar sobre las parejas clave,valor

for nombre, telefono in libreta_telefonos.items():

print(nombre, "=", telefono) # Resultado:

# Carlos = 5556033

# Javier = 5556051

# Daniel = 5556056

# Y si lo que queremos es iterar solo los valores,

# podemos hacerlo así

for telefono in libreta_telefonos.values():

print(telefono) # Resultado:

# 5556033

# 5556051

# 5556056

28
 ESTRUCTURAS DE DATOS EN PYTHON

El constructor dict() crea un diccionario directamente desde listas de pares

clave‐valor guardados como tuplas. Cuando los pares siguen un patrón, se
puede especificar de forma compacta la lista de pares clave:valor por compren-
sión.

dict([('pedro', 4139), ('guido', 4127), ('juan', 4098)])

# Salida: {'pedro': 4139, 'juan': 4098, 'guido': 4127}

dict([(x, x**2) for x in (2, 4, 6)])

# Salida: {2: 4, 4: 16, 6: 36}

Puedes seguir investigando por tu cuenta más usos de los diccionarios, como
almacén de información, por ejemplo… ¿Te recuerdan a la semántica del lengua-
je JSON?

1.4. DEFINICIONES POR COMPRENSION

Ahora que ya hemos visto los principales tipos compuestos de datos que ofrece
Python de forma nativa, vamos a presentarte un tipo de expresiones muy útiles
y potentes para crear y trabajar con estas estructuras de datos.

Las definiciones por comprensión son una forma muy concisa y simple de gene-
rar colecciones de datos de forma automática. Se utilizan sobre todo con listas,
pero son aplicables a todos los tipos compuestos haciendo los debidos ajustes.

En inglés aparecen normalmente como list comprehensions, y en español unos

autores denominan a estas expresiones listas por comprensión o también
comprensión de listas. Todos hacen referencia al mismo concepto.

Las definiciones por comprensión son expresiones que permiten construir una
nueva colección definiéndola a partir de otra colección de partida, una expre-
sión generadora de los nuevos elementos a incluir y un predicado o condición.

29
ESTRUCTURAS DE DATOS EN PYTHON

Escrito así, a lo mejor te parece complejo, pero verás que es muy sencillo. Lo
mejor será comenzar con un caso de ejemplo. Imagina que queremos guardar
en una lista la tabla de multiplicar del 7. Una forma de hacerlo con lo que has
aprendido hasta ahora sería mediante un bucle.

# Preparamos una lista vacía para ir poniendo los resultados

tabla_del_7 = []

# Iteramos los números del 0 al 9

for x in range(0, 10):

# añadimos a la lista el siguiente valor

# de la tabla de multiplicar del 7

tabla_del_7.append(7 * x)

print(tabla_del_7)

# Resultado: [0, 7, 14, 21, 28, 35, 42, 49, 56, 63]

Hemos tenido que crear una variable con una lista vacía al principio, y después
utilizar un bucle for para iterar por los valores de 0 a 9 e ir modificando en cada
paso la lista, para añadir cada valor de la tabla de multiplicar.

No es que sea un código muy complicado ni largo. Pero Python nos permite
hacer esto de forma más sencilla y breve.

tabla_del_7 = [ 7 * x for x in range(0, 10) ]

print(tabla_del_7)

Y obtenemos el mismo resultado… ¿no es genial? Continuemos un poquito

más…

30
 ESTRUCTURAS DE DATOS EN PYTHON

El dominio de valores de entrada puede ser cualquier objeto o expresión iterable.

lista_frutas = ["pera", "manzana", "ciruela", "cereza"]

[fruta.upper() for fruta in lista_frutas if fruta.startswith("c")]

# Resultado: ['CIRUELA', 'CEREZA']

También podemos combinar dos o más cláusulas for con sus dominios de en-
trada para construir la colección.

[ x * y for x in (1, 2, 3) for y in (4, 5, 6) ]

# Resultado: [4, 5, 6, 8, 10, 12, 12, 15, 18]

Esta expresión se evalúa para todas las combinaciones de valores de x e y. Si lo

piensas, es como si tuvieras dos bucles for anidados. Vamos a incluir en cada
elemento generado los valores de x e y, así quedará más claro.

[ (x, y, x * y) for x in (1, 2, 3) for y in (4, 5, 6) ]

# Resultado:

[(1, 4, 4),

(1, 5, 5),

(1, 6, 6),

(2, 4, 8),

(2, 5, 10),

(2, 6, 12),

(3, 4, 12),

(3, 5, 15),

(3, 6, 18)]

31
ESTRUCTURAS DE DATOS EN PYTHON

En este caso hemos hecho que la expresión generadora devuelva una tupla con
los valores de x, y y de x * y. Puede utilizarse cualquier expresión, todo lo
compleja que se necesite, siempre que devuelva un elemento válido.

Si en lugar de generar una lista queremos construir un conjunto, solamente

tenemos que reemplazar los corchetes por llaves.

{ x for x in range(10) if x % 2 != 0 }

# Resultado: {1, 3, 5, 7, 9}

Si queremos una tupla, no será suficiente con utilizar paréntesis. Tendremos

que utilizar el constructor tuple()

tuple( x for x in range(5) )

# Resultado: (0, 1, 2, 3, 4)

Y para construir un diccionario utilizando el mecanismo de comprensión, ade-

más de utilizar las llaves en lugar de los corchetes, la expresión generadora de-
berá tener la forma clave:valor

# aquí la clave es el factor multiplicador,

# y el valor es el resultado de la multiplicación

dict_tabla_7 = { num : 7 * num for num in range(0, 10) }

print(dict_tabla_7[3])

# Resultado: 21

32
 ESTRUCTURAS DE DATOS EN PYTHON

Como reto, te proponemos probar todos los ejem-

plos que ves en cada unidad y probarlos en tu intér-
prete de Python para ver el resultado. Algunos ya los
tienes en el campus para poderlos descargar en el
apartado “Ejemplos de la unidad”. Otros tendrás que
copiarlos y probarlos tú mismo. Ver código de otros
es una buena forma de ir aprendiendo y compren-
diendo el funcionamiento de un lenguaje.

1.5. GENERADORES

Un par de párrafos más arriba acabamos de ver que si queremos crear una tu-
pla definida por comprensión no basta con reemplazar los corchetes por parén-
tesis, tenemos que usar el constructor tuple().

Bueno, ¿y qué obtenemos entonces si usamos solamente los paréntesis? En

este caso, en lugar de devolver inmediatamente una secuencia completa con
todos los valores, Python nos devuelve un tipo especial de objeto que denomi-
namos generador.

Digamos que un generador es un objeto que se encarga de hacer los cálculos

para generar los valores resultantes uno a uno conforme los necesitemos y los
vayamos pidiendo, iterando sobre la colección de entrada, en lugar de construir
la secuencia entera de golpe.

La utilidad de este mecanismo es que así se ahorra espacio de memoria (no

tenemos que almacenar todos los resultados) y resulta más eficiente en los ca-
sos en los que no necesitamos la secuencia resultado completa de una vez, por
ejemplo, si queremos iterar los valores en un bucle.

# construimos un generador para la tabla de multiplicar del 7

gen_tabla_7 = ( 7 * x for x in range(0, 10) )

# si intentamos imprimir el contenido de 'gen_tabla_7'...

print(gen_tabla_7)

33
ESTRUCTURAS DE DATOS EN PYTHON

# no veremos una secuencia, sino un mensaje

# indicando que es un objeto de tipo 'generator'

<generator object <genexpr> at 0x7f9d9438dca8>

# vamos a usarlo en un bucle

for v in gen_tabla_7:

print(v)

# el generador va devolviendo un nuevo valor

# cada vez que se le pide

# hasta que agota todos los valores de su dominio de entrada

# La salida sería la siguiente:

14

21

28

35

42

49

56

63

34
 ESTRUCTURAS DE DATOS EN PYTHON

Si tenemos un generador y queremos extraer sus valores a una lista, podemos

utilizar el constructor list.

# si tenemos un generador

gen_tabla_3 = ( 3 * x for x in range(0, 10) )

# y queremos pasar todos sus elementos a una lista, usamos 'list'

lista_tabla_3 = list(gen_tabla_3)

print(lista_tabla_3)

# Resultado: [0, 3, 6, 9, 12, 15, 18, 21, 24, 27]

Fíjate que si intentas volver a utilizar el generador después de haber iterado

todos sus elementos (en un bucle o al extraerlos a una lista), no obtendrás na-
da, excepto posiblemente un error. El generador ha quedado vacío, está agota-
do y ya no tiene valores que devolver. Lo hemos “quemado”.

otra_lista_tabla_3 = list(gen_tabla_3)

# obtienes una lista vacía []

print(otra_lista_tabla_3)

# Resultado: []

Aprovecha todo lo que los generadores te ofrecen para ampliar tus skills como
programador de Python.

35
 ESTRUCTURAS DE DATOS EN PYTHON

¿QUÉ HAS APRENDIDO?

Hemos visto a lo largo de la unidad que existen 3 estructuras de datos impor-

tantes, sin contar a los conjuntos (datasets) y las cadenas (strings):

 Tuplas.

 Listas.

 Diccionarios.

Cada una de estas estructuras tienen unas características propias. Por ejemplo,
las tuplas son inmutables, las listas pueden ser modificadas con sus propios mé-
todos y los diccionarios disponen de una estructura clave:valor que nos ofre-
ce muchas posibilidades.

Lo que es común a todas ellas es que podemos seleccionar elementos indepen-

dientes de cada una de ellas para trabajar. Es su flexibilidad a la hora de tratar los
datos que contienen lo que confiere de versatilidad a estas estructuras.

Practica con los ejercicios que te proponemos y los ejemplos de la unidad para
comprender perfectamente su funcionamiento.

37
 ESTRUCTURAS DE DATOS EN PYTHON

BIBLIOGRAFÍA

 Iniciación al Big Data con Python. MasterD.

39