Tuplas en Python – tuple
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.
Contenido
¿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)
80000040Crear 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] = tSlicing 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étodo | Descripción | Ejemplo |
|---|---|---|
| count | Devuelve el número de ocurrencias de un elemento en la lista | tuple.count('p') |
| index | Devuelve el índice que ocupa un elemento | tuple.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
FalseCó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)
4072Libros 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.
