Tuplas en Python – tuple

Tuplas en Python

Las tuplas son uno de los tipos básicos que provee Python y son muy utilizadas. Son objetos inmutables capaces de almacenar información en forma de vectores, lo que favorece el ahorro de espacio en memoria.

¿Qué es una tupla en Python?

Las tuplas son un tipo de dato que permite almacenar información, por tanto forma parte de los tipos de datos colección.

Las tuplas guardan los datos en forma de vectores y su uso es muy similar a las listas, con la salvedad de que las tuplas son inmutables, y por lo tanto no pueden modificar los datos una vez inicializados.

Tuplas vs listas en Python

La gran diferencia entre las listas y las tuplas en Python es la mutabilidad de ambas. Las tuplas son inmutables, mientras que las listas son mutables.

La gran ventaja que ofrecen las tuplas es el poco espacio que ocupan en memoria, dado que al ser inmutables, no necesitan reservar espacio adicional como en el caso de las listas.

Si se crean listas y tuplas de 10,000,000 elementos numéricos (desde el 0 hasta el 9,999,999) se obtienen los siguientes resultados:

  • Espacio usando listas: 87002288 bytes (~87Mb).
  • Espacio usando tuplas: 80000040 bytes (~80Mb).
  • Supone una reducción de casi 7Mb.
>>> from sys import getsizeof
>>> lst = list(x for x in range(10**7))
>>> getsizeof(lst)
87002288
>>> tple = tuple(x for x in range(10**7))
>>> getsizeof(tple)
80000040

Crear tuplas en Python

La forma de crear una tupla es usando el constructor de listas tuple o como literal usando ().

>>> tple = (45, 32, 'hello', b'jiji')
>>> tple[1]
32
>>> for x in tuple('Hello World'):
...     print(x)
...
H
e
l
l
o

W
o
r
l
d
>>> values = (True, None, 'h', 4)
>>> if values[1] is None:
...     print(values)
...
(True, None, 'h', 4)

Acceso a elementos de tuplas en Python

El acceso a las tuplas se hace usando enteros, tanto positivos como negativos.

Para acceder a la primera posición de la tupla se utiliza 0 y para acceder a la última se utiliza -1, y en ese intervalo se pueden acceder a todas las posiciones.

>>> acc, dec = 0, -1
>>> name = ('t', 'u', 'p', 'l', 'e', 's')
>>> for _ in name:
...     print(f'name[{acc}] = {name[acc]} | name[{dec}] = {name[dec]}')
...     acc += 1
...     dec -= 1
...
name[0] = t | name[-1] = s
name[1] = u | name[-2] = e
name[2] = p | name[-3] = l
name[3] = l | name[-4] = p
name[4] = e | name[-5] = u
name[5] = s | name[-6] = t

Slicing en tuplas – subtuplas

Python implementa una forma avanzada y simple de crear sub-tuplas de elementos internos de una tupla, usando la técnica del slicing. Esta técnica está disponible para cualquier iterador y es muy útil.

La forma básica del slicing es:

[posicion_inicial:posicion_final[:paso]]

Con esta sintaxis tan simple, se pueden obtener subtuplas fácilmente. Las posiciones y los pasos pueden ser positivos o negativos como se ve a continuación.

>>> letters = tuple('ABCDEFGHI')
>>> letters
('A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I')
>>> letters[:7]
('A', 'B', 'C', 'D', 'E', 'F', 'G')
>>> letters[4:]
('E', 'F', 'G', 'H', 'I')
>>> letters[4:-4]
('E',)
>>> letters[1:-2:3]
('B', 'E')
>>> letters[1:200:4]
('B', 'F')
>>> letters[:200]
('A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I')
>>> letters[200:]
()
>>> letters[-3:]
('G', 'H', 'I')

Métodos disponibles sobre tuple

Los métodos disponibles para tuplas son:

>>> dir(letters)
['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__',
'__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__gt__',
'__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__',
'__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmul__',
'__setattr__', '__sizeof__', '__str__', '__subclasshook__',
'count', 'index']
MétodoDescripciónEjemplo
countDevuelve el número de ocurrencias de un elemento en la listatuple.count('p')
indexDevuelve el índice que ocupa un elementotuple.index('e')

La lista de métodos disponible es corta, mayormente porque no se pueden cambiar los valores de una tupla una vez creada, al ser inmutables.

>>> letters[1] = 'h'
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment
>>> new_letters = tuple(letters[:1] + ('h',) + letters[1:])
>>> new_letters
('A', 'h', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I')

Lo que sí que se permite hacer con las tuplas es crear nuevas desde otras.

>>> tple = (1, 2, 3)
>>> tple_abc = tuple('ABCD')
>>> tple
(1, 2, 3)
>>> tple_abc
('A', 'B', 'C', 'D')
>>> tple + tple_abc
(1, 2, 3, 'A', 'B', 'C', 'D')
>>> tple_abc * 3
('A', 'B', 'C', 'D', 'A', 'B', 'C', 'D', 'A', 'B', 'C', 'D')
>>> tple_abc == tple
False

Cómo usar tuplas desde CSV en Python

En el siguiente ejemplo se puede ver cómo leer un CSV llamado ‘areas.csv’ y que al utilizar listas de listas o tuplas de tuplas cambia el tamaño usado en memoria.

>>> rows_list = []
>>> rows_tple = []
>>> with open('areas.csv', 'r') as fr:
...     reader = csv.reader(fr)
...     for row in reader:
...         rows_tple.append(tuple(row))
...         rows_list.append(row)
...
>>> getsizeof(rows_tple)
4264
>>> getsizeof(rows_list)
4264
>>> tple = tuple(rows_tple)  # convertir a tuplas de tuplas
>>> getsizeof(tple)
4072

Libros recomendados para aprender Python

Estos son los libros que pueden ayudarte a aprender Python, aprender a programar, tipos de datos, algoritmia y mucho más.

Disponible en:

Compartir

Deja una respuesta

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

Información básica sobre protección de datos Ver más

  • Responsable Oscar Ramirez.
  • Finalidad Moderar los comentarios. Responder las consultas.
  • Legitimación Su consentimiento.
  • Destinatarios  ionos.
  • Derechos Acceder, rectificar y suprimir los datos.

Publicar un comentario