183

7 Tipos de datos estructurados

Además de los tipos de datos básicos revisados en las secciones anteriores, Python
admite estructuras de datos denominadas colecciones que permiten agrupar datos, los
cuales pueden ser de tipos diferentes. Estos datos estructurados o colecciones son:
Listas, Tuplas, Cadenas de caracteres (strings), Diccionarios y Conjuntos. Los tipos
de datos estructurados se pueden combinar y formar tipos de datos compuestos.

Un caso muy importante del tipo lista, son los arreglos. Los arreglos son listas de una o
más dimensiones cuyos elementos son del mismo tipo (usualmente numérico) y su
manejo se define y realiza con los operadores y funciones de la librería NumPy de gran
importancia para aplicaciones matemáticas. Los arreglos son el soporte para el manejo
computacional de los vectores y matrices.

Las estructuras de datos en el lenguaje Python son tipos de datos dinámicos, es decir
que pueden extenderse o modificarse en forma interactiva y durante la ejecución de
programas.

Este capítulo es muy importante incluyendo el estudio de las librerías especiales

disponibles en Python para operar con este tipo de datos.

Una de las propiedades más útiles del lenguaje Python es la facilidad para el manejo de
los componentes de algunas estructuras de datos (listas, arreglos, cadenas de caracteres
y tuplas) mediante una notación especial de los índices que permite referirse o extraer
parte del contenido de la estructura. Esta propiedad se denomina “slicing” (rebanar). La
sintaxis es simple y elegante y será revisada mediante ejemplos y aplicaciones

7.1 Listas
Las listas constituyen el tipo de datos estructurado más importante, versátil y común de
Python. Una lista es una colección de datos que pueden tener diferente tipo. Los datos se
escriben entre corchetes, separados por comas:

[dato, dato, dato, ..., dato]

Una lista es una estructura de datos dinámina cuyos componentes se pueden modificar.

Las celdas son numeradas desde cero. El primer componente o primera celda, tiene
índice 0. El segundo componente, o segunda celda, tiene índice 1, etc.

Se puede acceder a los componentes de una lista mediante un índice entre corchetes.

Python es muy flexible en la notación de índices para manejo de los componentes. Esta
propiedad se denomina “slicing” (rebanar) y se la revisa en los ejemplos.

En la notación de índices, se puede especificar el acceso a varios elementos o

componentes mediante un rango para el índice. El rango no incluye el extremo derecho
especificado.

Python Programación
 184

Ejemplos. Creación en la ventana interactiva de una lista con 5 componentes, algunos de

tipos diferentes:

>>> x = ['abc', 73, 5.28, 'rs', 50]

La representación visual de la lista se puede describir con el siguiente gráfico en el que los
componentes se almacenan en celdas de memoria numeradas desde cero:

'abc' 73 5.28 'rs' 50

0 1 2 3 4

Ejemplos de especificación de índices para manejo de los componentes de la lista. Si se

especifica un elemento, el resultado es un valor. Si se especifica mediante un rango, el
resultado también es una lista.

>>> x[0] Componente 0 (ubicado en la celda 0)

'abc' (es el primer componente o primera celda)

>>> x[2] Componente 2 (ubicado en la celda 2)

5.28 (es el tercer componente o tercera celda)

>>> x[1:4] Componentes desde 1 hasta el 3 (celdas 1 a 3)

[73, 5.28, 'rs'] (con el rango no se incluye el extremo final)

>>> x[1]
45 El resultado es un elemento

>>> x[1:2]
[45] El resultado es una lista

>>> x[6] El índice fuera de rango produce un error

IndexError: list index out of range

>>> x[2:] Componentes 2 hasta el final (celda 2 hasta el final)

[5.28, 'rs', 50] los resultados también son listas

>>> x[:4] Componenetes desde el primero hasta el 3

['abc', 73, 5.28, 'rs'] (el rango no incluye el extremo final)

>>> x[0:5:2] Todos los componentes en celdas pares

['abc', 5.28, 50] El tercer índice es el incremento de número de celda

>>> x[-1] Es el último componente (componente 4)

50

>>> x[-2] Penúltimo componente (componente 3)

'rs'

>>> x[-3] Antepenúltimo componente (componente 2)

5.28

>>> x[-4]
73

Python Programación
 185

>>> x[:-3] Componentes desde el primero hasta el -4

['abc', 73] (el rango no incluye el extremo final)

>>> x[-2:] Componentes desde el penúltimo hasta el final

['rs', 50]

>>> x[:-1] Todos los componentes menos el último

['abc', 73, 5.28, 'rs'] (el rango no incluye el extremo final)

>>> x[1]=45 Los componentes de una lista se pueden modificar

>>> x
['abc', 45, 5.28, 'rs', 50] La lista fue modificada

>>> x=[20,40,50,30,70,65,80,90,35]
>>> x[0:9:2] El tercer índice indica el incremento (cada dos
[20, 50, 70, 80, 35] elementos)

>>> x[0:-1:2]
[20, 50, 70, 80]

>>> x[:9:2]
[20, 50, 70, 80, 35]

>>> x[::2]
[20, 50, 70, 80, 35]

>>> x[::3]
[20, 30, 80]

>>> x[::-1] Esta notación especial invierte la lista

[35, 90, 80, 65, 70, 30, 50, 40, 20]

Listas anidadas. Una lista puede incluir componentes de tipo lista

>>> x=[123,'Algebra',[50,70],5,73.25]
>>> x[0]
123

>>> x[1]
'Algebra'

>>> x[2]
[50, 70]

>>> x[2][1] Se requiere un segundo índice para referirse

70 al contenido del componente de tipo lista

>>> x[2][1]=75 Se pueden modificar componentes de la lista

>>> x
[123, 'Algebra', [50, 75], 5, 73.25]

Python Programación
 186

>>> x[3]=[40,80]
>>> x
[123, 'Algebra', [50, 75], [40, 80], 73.25]

>>> t=[[123,'María',50.2],[234,'Juan',24.2]]

>>> t[1]
[234, 'Juan', 24.2]

>>> t[1][2]
24.2

Declaración de una lista vacía

>>> x=[] La lista x no contiene elementos

Listas multidimensionales: Una lista puede organizarse en más niveles

>>> x=[[[23,45],['abc',42]],35]
>>> x[0]
[[23, 45], ['abc', 42]]

>>> x[1]
35

>>> x[0][0]
[23, 45]

>>> x[0][0][1] Se requiere un tercer índice para manejar el

45 contenido de menor nivel

>>> x[0][1][0]
'abc'

>>> x[0][1][0]='rstu'
>>> x
[[[23, 45], ['rstu', 42]], 35]

Python Programación
 187

Los valores de una lista se pueden desempacar asignando a variables. Deben coincidir en
la cantidad de elementos.

>>> t = [34,'abc',42]
>>> a,b,c = t
>>> a
34
>>> b
'abc'
>>> c
42

Algunas funciones comunes para manejo de listas (numéricas)

Estas funciones están en la librería estándar residente en memoria al cargar Python

>>> x=[20,30,45,50,30]

>>> len(x) longitud o cantidad de elementos en una lista

5

>>> max(x) El mayor valor (listas numèricas)

50

>>> min(x) El menor valor (listas numèricas)

20

>>> sum(x) Suma de componentes (listas numèricas)

175

>>> x=[20,30,45,50,'abc',30]

>>> len(x) Longitud o cantidad de elementos en la lista

6 (los componentes pueden ser de cualquier tipo)

>>> max(x) Error: max, min solo aplicables con listas numèricas

TypeError: unorderable types: str() > int()

>>> sum(x) Error: sum solo aplicable a listas numéricas

TypeError: unsupported operand type(s) for +: 'int' and 'str'

Python Programación
 188

Funciones y operadores especiales para manejo de listas

En esta sección se establecen instrumentos adicionales para manejo de listas y sus

aplicaciones. La mayoría son aplicables a listas numéricas. Sin embargo, muchas
operaciones se pueden aplicar a listas con elementos de tipos diferentes.

Python dispone de dispositivos denominados Clases (se puede entender una clase como
librería) que contienen funciones definidas para ciertas aplicaciones. Estas funciones
también se denominan métodos.

La clase (librería) para manejo de listas se denomina list y es residente en la Python, por
lo que no se necesita importarla.

Al crear una variable u objeto de tipo lista se tiene acceso a las funciones o métodos
definidos en la clase y se los usa con la siguiente notación:
objeto.función

En el cuadro se muestran algunas funciones de la clase list para manejo de listas. Su

aplicación se describirá mediante ejemplos.

Sean x: objeto (o variable) de tipo lista

e: un elemento
Función Resultado
x.append(e) Agrega a la lista x el elemento e
x.insert(i,e) Inserta e en la posición i de la lista x
x.count(e) Conteo de instancias de e en la lista x
x.remove(e) Elimina el primer elemento e de la lista x
x.pop(i) Entrega el elemento en la posición i en la lista y lo elimina
x.index(e) Entrega la posición del primer elemento e en x
x.sort() Ordena x en forma creciente
x.reverse() Invierte la lista x
x.clear() Vaciar la lista x
x.copy() Entrega una copia de una lista de un nivel

Algunas de estas funciones producen un error de tipo ValueError si no se usan

apropiadamente

Operadores para manejo de listas

Se diponen de otras funciones y operadores para manejo de listas. Algunos operadores:

+ Operador de concatenación de listas

* Operador de reproducción de listas
in Operador de inclusión
not in

del Elimina elementos de una lista especificando el índice

Python Programación
 189

>>> x=[34,56,75,56,43]
>>> x.append(28) Agregar elemento con valor 28
>>> x
[34, 56, 75, 56, 43, 28]

>>> x.insert(2,62) Insertar 62 en la posición 2

>>> x
[34, 56, 62, 75, 56, 43, 28]
>>> n=x.count(56)
>>> n
2
>>> x.remove(75)
>>> x
[34, 56, 62, 56, 43, 28]

>>> k=x.index(56)
>>> k
1
>>> x.reverse()
>>> x
[28, 43, 56, 62, 56, 34]

>>> x.clear() Elimina la lista

>>> x
[] Lista vacía. Son dos corchetes juntos

>>> x=[3,7,8,2,8,5,4,6]
>>> 9 in x Determinar si un elemento está en una lista
False
>>> 8 in x Si el elemento está en la lista el resultado es True
True
>>> x.index(8) En este caso se puede determinar su posición en la lista
2
>>> e=x.pop(6) Entrega el elemento en la posición 6 y lo elimina de la lista
>>> e
4
>>> x
[3, 7, 8, 2, 8, 5, 6]

Para prevenir errores al usar algunas funciones, se debe usar el operador in

Ejemplo. Remover un elemento si está en la lista

>>> x=[3,7,8,2,8,5,4,6]
>>> if 9 in x:
x.remove(9)

>>> x La lista no es modificada y no se produjo un error

[3,7,8,2,8,5,4,6]

Python Programación
 190

Si no se hace esta validación y se intenta eliminar un elemento que no está en la lista se

genera un error de ejecución: ValueError

Ordenamiento de listas: sort

>>> x=[34,56,75,56,43]
>>> x.sort()
>>> x
[34, 43, 56, 56, 75]

>>> x=['Química','Algebra','Física','Biología']
>>> x.sort()
>>> x
['Algebra', 'Biología', 'Física', 'Química']

>>> x=[23,'Algebra','Biología',73,45]
>>> x.sort() No se pueden ordenar tipos diferentes
TypeError: unorderable types: str() < int()

>>> t = [[7, 3], [3, 6], [9, 8],[5, 4]] Ordena el primer componente
>>> t.sort()
>>> t
[[3, 6], [5, 4], [7, 3], [9, 8]]

>>> a = [[7, 'Algebra'], [3, 'Física'], [9, 'Química']]

>>> a.sort()
>>> a
[[3, 'Física'], [7, 'Algebra'], [9, 'Química']]

El operador + es una alternativa a la función append para concatenar listas

>>> x=[5,3,5,2]
>>> x=x+[9,3]
>>> x
[5, 3, 5, 2, 9, 3]

>>> a=[27,'abc',4.5]
>>> b=[3.2,73,'rt',35]
>>> c=a+b
>>> c
[27, 'abc', 4.5, 3.2, 73, 'rt', 35]

Algunos métodos se aplican igualmente a listas con elementos de diferente tipo

>>> x=[23,5.27,'lunes',49]

>>> x.append('martes')
>>> x
[23, 5.27, 'lunes', 49, 'martes']

Python Programación
 191

>>> x.remove('lunes')
>>> x
[23, 5.27, 49, 'martes']

>>> x.index('martes')
3

>>> x=x+['jueves']
>>> x
[23, 5.27, 49, 'martes', 'jueves']

Reproducción de listas con *

>>> x=[2,5.1,'lunes']
>>> r=2*x Reproduce la lista dos veces
>>> r
[2, 5.1, 'lunes', 2, 5.1, 'lunes']

Un operador especial para eliminar elementos de una lista mediante el índice: del

>>> x=[3,4,9,7,2,9,6]
>>> del x[3] Elimina el elemento en la celda 3
>>> x
[3, 4, 9, 2, 9, 6]
>>> del x[-1] Elimina el último elemento
>>> x
[3, 4, 9, 2, 9]

>>> x=[23, 5.27, 'lunes', 49, 'martes']

>>> del x[2] Elimina el elemento en la celda 2
>>> x
[23, 5.27, 49, 'martes']

>>> x=[3,4,9,7,2,9,6]
>>> del x[2:5] Elimina celdas en un rango
>>> x
[3, 4, 9, 6]

Una función para formar parejas entre dos listas: zip

>>> c=[101,231,725]
>>> m=['Algebra','Física','Química']
>>> p=zip(c,m)
>>> list(p)
[(101, 'Algebra'), (231, 'Física'), (725, 'Química')]

Una función para construir listas por mapeo: map

>>> def cubo(x):return x**3 Función para calcular un cubo
>>> c=map(cubo, range(5))

Python Programación
 192

>>> s=list(c)
>>> s
[0, 1, 8, 27, 64]

Una función para construir listas mediante un filtro: filter

>>> def par(x):return x%2==0 Función para detectar número par
>>> x=[3,6,7,8,10,5]
>>> t=filter(par,x)
>>> list(t)
[6, 8, 10]

Versiones más simples equivalentes a map y filter se indican a continuación

Construcción declarativa de listas numéricas

Las listas numéricas pueden crearse mediante declaraciones, interactivas o en programas

Mediante declaraciones implícitas

>>> u=range(5) Con la función range

>>> x=list(u)
>>> x
[0, 1, 2, 3, 4]
>>> x=list(range(5)) Directamente
>>> x
[0, 1, 2, 3, 4]

>>> c=[i for i in range(5)] Crea una lista numérica

>>> c
[0, 1, 2, 3, 4]

>>> c=[[i] for i in range(5)] Crea una lista de listas

>>> c
[[0], [1], [2], [3], [4]]

Declaración equivalente a la construcción de listas con map

>>> def cubo(x):return x**3

>>> c=[cubo(i) for i in range(5)]

>>> c
[0, 1, 8, 27, 64]

Declaración equivalente a la construcción de listas con filter

>>> x=[3,6,7,8,10,5] Filtra elementos pares de una lista

>>> p=[t for t in x if t%2==0]
>>> p
[6, 8, 10]

Python Programación
 193

Crear una lista de 10 elementos con ceros

>>> x=[0 for i in range(10)]

>>> x
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0]

Crear una lista con 8 números aleatorios de una cifra

>>> from random import*

>>> x=[randint(0,9) for i in range(8)]
>>> x
[0, 9, 8, 2, 6, 6, 1, 2]
Crear cuatro listas, cada una con cinco números aleatorios de una cifra

>>> a=[[randint(0,9) for j in range(5)] for i in range(4)]

>>> a
[[3, 4, 5, 2, 7], [2, 8, 4, 8, 1], [6, 1, 6, 6, 8], [0, 3, 0, 4, 1]]

Mediante declaraciones explícitas

>>> x=[] definición de una lista vacía

>>> for i in range(5): Crea una lista numérica
x.append(i)
>>> x
[0, 1, 2, 3, 4]

>>> x=[]
>>> for i in range(5): Crea una lista de listas con nos. naturales
x.append([i])
>>> x
[[0], [1], [2], [3], [4]]

>>> a=[]
>>> for i in range(5): Crear una lista de listas vacías
a=a+[[]]
>>> a
[[], [], [], [], []]

Llenar una lista con listas de 3 componentes conteniendo números aleatorios de una cifra

>>> from random import*

>>> a=[] Inicia la lista
>>> for i in range(4):
f=[] Inicia una fila
for j in range(3):
f=f+[randint(0,9)] Llena la fila
a=a+[f] Agrega la fila a la lista del primer nivel
>>> a
[[7, 2, 8], [5, 1, 0], [5, 8, 9], [0, 8, 3]]

Python Programación
 194

Se pueden crear listas pero sin especificar aún ni los valores ni su tipo

>>> x=[] Se inicia como una lista vacía

>>> for i in range(5):
x=x+[None]
>>> x
[None, None, None, None, None]

Se puede usar el operador + para agregar elementos, en lugar de append

>>> x=[] Se inicia como una lista vacía

>>> for i in range(5): Crea una lista numérica
x=x+[i] conteniendo enteros
>>> x
[0, 1, 2, 3, 4]

Una lista de listas con varios componentes

>>> s=[]
>>> for i in range(5):
e=[i,3*i,i**2]
s=s+[e]
>>> s
[[0, 0, 0], [1, 3, 1], [2, 6, 4], [3, 9, 9], [4, 12, 16]]

El operador + o la función append se pueden usarse para concatenar listas

>>> a=[2,5,7,6]
>>> b=[9,8,4]
>>> c=a+b Concatenación de listas
>>> c
[2, 5, 7, 6, 9, 8, 4]
>>> c=a+[b]
>>> c
[2, 5, 7, 6, [9, 8, 4]]

>>> c=[a]+[b]
>>> c
[[2, 5, 7, 6], [9, 8, 4]]

Enumeración de listas: enumerate

Entrega una lista indexada

>>> d=['lunes','martes','miércoles','jueves','viernes']
>>> list(enumerate(d))
[(0, 'lunes'), (1, 'martes'), (2, 'miércoles'), (3, 'jueves'), (4, 'viernes')]

Python Programación
 195

Esta instrucción es útil para iterar sobre una lista si se desea agregar el índice:

>>> d=['lunes','martes','miércoles','jueves','viernes']

>>> for i,e in enumerate(d):

print(i,e)
0 lunes
1 martes
2 miércoles
3 jueves
4 viernes

El uso de enumerate es equivalente a recorrer la lista con un índice

>>> for i in range(len(d)):

print(i,d[i])

0 lunes
1 martes
2 miércoles
3 jueves
4 viernes

Nombres de listas vinculados

Al asignar el nombre de una lista a otro nombre, ambos se refieren a las mismas celdas,
es decir comparten la misma dirección de memoria por lo que al modificar componentes,
estos cambios afectan a ambas variables.
>>> x=[20,30,50]
>>> u=x Los nombres x, u se refieren a las mismas celdas
>>> x[1]=40
>>> u La variable u contiene los mismos valores que x
[20, 40, 50]

Si se desea que la lista u tenga una copia de la lista x con celdas propias, puede crear
celdas para u y asignar los valores de x, o usar la función copy( ) como en el ejemplo
siguiente. También se puede usar la notación especial con dos puntos para obtener una
copia de la lista.

>>> x=[20,30,50]
>>> u=x.copy() La variable u tiene una copia de x en otras celdas
>>> x[1]=40 (aplicable solamente a listas de un nivel)
>>> u
[20, 30, 50]
>>> u=x[:] Esta notación especial actúa igual que u=x.copy()

Python Programación
 196

Salida de listas formateada

Para mostrar listas en pantalla se puede especificar la salida como se describe en el

siguiente ejemplo. Se muestra un vector sin formatear y el mismo vector con su salida
formateada indicando la cantidad de decimales:

>>> x=[1/3,2/5,3/7,4/3]
>>> print(x)
[0.3333333333333333, 0.4, 0.42857142857142855, 1.3333333333333333]
>>> print([float('%6.4f' % x[i]) for i in range(len(x))])
[0.3333, 0.4, 0.4286, 1.3333]

Evaluación de expresiones lógicas

Python evalua las expresiones lógicas en modo “short circuit”. Esto significa que la
expresión lógica se evalúa únicamente hasta donde sea necesario y suficiente para
determinar el valor lógico resultante.

Ejemplo. El siguiente programa producirá un error de índice fuera de rango:

lista=[30,50,20,40] #En las celdas: 0, 1, 2, 3

for i in range(len(lista)):
if lista[i]<50 and lista[i+1]>10: #Necesita evaluar lista[4]
print(lista[i])

IndexError: list index out of range

Ejemplo. Pero el siguiente programa no produce el error de índice fuera de rango:

lista=[30,50,20,40]
for i in range(len(lista)):
if lista[i]<20 and lista[i+1]>10: #No necesita evaluar lista[4]
print(lista[i])

Ejemplo. El siguiente programa tampoco produce error de índice fuera de rango:

lista=[30,50,20,40]
for i in range(len(lista)):
if lista[i]<50 or lista[i+1]>10: #No necesita evaluar lista[4]
print(lista[i])

Python Programación