Apéndice J — Tuplas.

Objetivo. Describir la estructura de datos tuple mediante la exposición de ejemplos.

J.1 Introducción.

Recordemos los cuatro tipos de colecciones que se tienen en Python:

Tipo Ordenada Inmutable Indexable Duplicidad
List SI NO SI SI
Tuple SI SI SI SI
Sets NO NO NO NO
Dict NO NO SI NO

J.2 Tuplas.

  • Consisten en una secuencia ordenada e inmutable de elementos.
    • Ordenadas significa que cada elemento dentro de la tupla está indexado y mantiene su orden definido en su creación.
    • Inmutable significa que los elementos de la tupla NO se pueden modificar, tampoco que se pueden agregar o eliminar elementos.
  • Las tuplas pueden tener elementos duplicados, es decir, elementos del mismo tipo y con el mismo contenido.
  • Las tuplas se definen usando paréntesis (()) y comas (,) para separar sus elementos.
Ejemplo J.1: Creación de tuplas.

Construiremos las siguientes tuplas:

t1 = ('a', 'b', 'c', 'b', 'd', 'e', 'f', 'z')
t2 = (1, 2, 3, 4, 5, 6, 7, 8)
t3 = ('gatos', ['Persa', 'Sphynx'], [2.3, 3,5])

Creamos las tuplas:

t1 = ('a', 'b', 'c', 'b', 'd', 'e', 'f', 'z')
t2 = (1, 2, 3, 4, 5, 6, 7, 8)
t3 = ('gatos', ['Persa', 'Sphynx'], (2.3, 3.5))
print(type(t1), t1)
print(type(t2), t2)
print(type(t3), t3)     
<class 'tuple'> ('a', 'b', 'c', 'b', 'd', 'e', 'f', 'z')
<class 'tuple'> (1, 2, 3, 4, 5, 6, 7, 8)
<class 'tuple'> ('gatos', ['Persa', 'Sphynx'], (2.3, 3.5))
  • Observa que la tupla t1 y t2 contienen elementos del mismo tipo (str e int).
  • Las tuplas pueden tener elementos repetidos como en t1.
  • La tupla t3 contiene tres elementos, cada uno de distinto tipo: str, list y tuple.

J.3 Tuplas de un solo elemento.

Si deseamos una tupla de un solo elemento debemos realizar lo siguiente:

tupla_un_elemento = (1,)
print(tupla_un_elemento, type(tupla_un_elemento))
(1,) <class 'tuple'>

La siguiente expresión no construye una tupla, si no un entero:

tupla_un_elemento = (1)
print(tupla_un_elemento, type(tupla_un_elemento))
1 <class 'int'>

J.4 Indexado.

El indexado de las tuplas es similar al de las cadenas (veáse Sección E.3). Por ejemplo, usando la tupla t1:

print(t1)
('a', 'b', 'c', 'b', 'd', 'e', 'f', 'z')
t1[0]  # Primer elemento
'a'
t1[-1] # Último elemento
'z'
t1[2:5] # Todos los elementos, desde el 2 hasta el 4
('c', 'b', 'd')
t1[::-1] # Todos los elementos en reversa
('z', 'f', 'e', 'd', 'b', 'c', 'b', 'a')

Usando el indexado, podemos ver el contenido y tipo de los elementos, por ejemplo:

print(type(t3[0]), t3[0]) # Elemento 1
print(type(t3[1]), t3[1]) # Elemento 2
print(type(t3[2]), t3[2]) # Elemento 3
<class 'str'> gatos
<class 'list'> ['Persa', 'Sphynx']
<class 'tuple'> (2.3, 3.5)
  • Observa que los elementos 2 y 3 son una lista y una tupla respectivamente.
  • La lista contiene cadenas, mientras que la tupla contiene flotantes.
  • Podemos acceder a los elementos individuales de la lista y la tupla como sigue:
# Primer elemento de la lista t3[1]
print(type(t3[1][0]), t3[1][0], )

# Segundo elemento de la tupla t3[2]
print(type(t3[2][1]), t3[2][1])
<class 'str'> Persa
<class 'float'> 3.5

Las tuplas son usadas, entre otras cosas, en funciones para regresar valores o enviar argumentos. Más acerca de funciones se describe en Apéndice O.

J.5 Inmutabilidad.

Los elementos de las tuplas no se pueden modificar. Por ejemplo, si intentamos modificar el elemento tres de la tupla t1 obtendremos un error:

t1[2] = 'h'
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[17], line 1
----> 1 t1[2] = 'h'

TypeError: 'tuple' object does not support item assignment

J.6 Funciones incorporadas que operan sobre las tuplas.

Prácticamente todas las funciones incorporadas que se aplican a las listas, se pueden aplicar a las tuplas, por ejemplo:

print(len(t1))
print(max(t1))
print(min(t1))
print(all(t2))
print(any(t2))
print(sorted(t1))
print(sum(t2))
8
z
a
True
True
['a', 'b', 'b', 'c', 'd', 'e', 'f', 'z']
36
# Enumera los elementos de una tupla regresando tuplas (i, elemento)
tuple(enumerate(t1)) 
((0, 'a'),
 (1, 'b'),
 (2, 'c'),
 (3, 'b'),
 (4, 'd'),
 (5, 'e'),
 (6, 'f'),
 (7, 'z'))
# Agrupa los elementos de dos tuplas regresando tuplas: (t1[i], t2[i])
tuple(zip(t1, t2)) 
(('a', 1),
 ('b', 2),
 ('c', 3),
 ('b', 4),
 ('d', 5),
 ('e', 6),
 ('f', 7),
 ('z', 8))

Observa que para el caso de enumerate y zip el resultado se debe convertir a un tipo que se pueda desplegar. Podemos elegir convertir a una lista o a una tupla para desplegar el resultado.

Se pueden agrupar dos tuplas con zip aunque sean de distinto tamaño:

tuple(zip(t3, t2))
(('gatos', 1), (['Persa', 'Sphynx'], 2), ((2.3, 3.5), 3))

Se puede agrupar una tupla y una lista:

tuple(zip((1,2,3,4,5),['a','b','c','d','e']))
((1, 'a'), (2, 'b'), (3, 'c'), (4, 'd'), (5, 'e'))

J.7 Operadores sobre tuplas.

Se pueden usar los operadores +, * e in sobre las tuplas.

t1 + t2
('a', 'b', 'c', 'b', 'd', 'e', 'f', 'z', 1, 2, 3, 4, 5, 6, 7, 8)
t3 * 2
('gatos',
 ['Persa', 'Sphynx'],
 (2.3, 3.5),
 'gatos',
 ['Persa', 'Sphynx'],
 (2.3, 3.5))
'Persa' in t3
False
'Persa' in t3[1]
True

J.8 Métodos de las listas.

La clase <class 'tuple'> define dos métodos que se pueden aplicar sobre los objetos del tipo tuple:

  • tuple.index(o): regresa el índice donde está el objeto o dentro de la tupla
  • tuple.count(o): cuenta las veces que aparece el objeto o en la tupla.

Por ejemplo:

t1.index('z')
7
t1.count('b')
2

J.9 ¿Copiando tuplas?

No es posible crear una copia de una tupla en otra. Lo que se recomienda es transformar la tupla en otra estructura de datos compatible (por ejemplo list o set).

Si intentamos realizar una copia obtendremos el mismo objeto:

# nueva tupla
t1 =(1,3) 

# copiando todos los elementos de t1 en t2
t2 = t1[:] 

# copiando usando el módulo copy
import copy
t3 = copy.copy(t1)
print(t1, type(t1), id(t1))
print(t2, type(t2), id(t2))
print(t3, type(t3), id(t3))
(1, 3) <class 'tuple'> 2226687724992
(1, 3) <class 'tuple'> 2226687724992
(1, 3) <class 'tuple'> 2226687724992

Observa que las tres tuplas tienen el mismo identificador en memoria.