Tupla de Python

Una tupla en Python es similar a una lista. La diferencia entre los dos es que no podemos cambiar los elementos de una tupla una vez asignada, mientras que podemos cambiar los elementos de una lista.

Creando una tupla

Una tupla se crea colocando todos los elementos (elementos) entre paréntesis (), separado por comas. Los paréntesis son opcionales, sin embargo, es una buena práctica usarlos.

Una tupla puede tener cualquier número de elementos y pueden ser de diferentes tipos (entero, flotante, lista, cadena, etc.).

# Different types of tuples

# Empty tuple
my_tuple = ()
print(my_tuple)

# Tuple having integers
my_tuple = (1, 2, 3)
print(my_tuple)

# tuple with mixed datatypes
my_tuple = (1, "Hello", 3.4)
print(my_tuple)

# nested tuple
my_tuple = ("mouse", [8, 4, 6], (1, 2, 3))
print(my_tuple)

Producción

()
(1, 2, 3)
(1, 'Hello', 3.4)
('mouse', [8, 4, 6], (1, 2, 3))

También se puede crear una tupla sin usar paréntesis. Esto se conoce como empaquetamiento de tuplas.

my_tuple = 3, 4.6, "dog"
print(my_tuple)

# tuple unpacking is also possible
a, b, c = my_tuple

print(a)      # 3
print(b)      # 4.6
print(c)      # dog

Producción

(3, 4.6, 'dog')
3
4.6
dog

Crear una tupla con un elemento es un poco complicado.

Tener un elemento entre paréntesis no es suficiente. Necesitaremos una coma final para indicar que es, de hecho, una tupla.

my_tuple = ("hello")
print(type(my_tuple))  # <class 'str'>

# Creating a tuple having one element
my_tuple = ("hello",)
print(type(my_tuple))  # <class 'tuple'>

# Parentheses is optional
my_tuple = "hello",
print(type(my_tuple))  # <class 'tuple'>

Producción

<class 'str'>
<class 'tuple'>
<class 'tuple'>

Acceder a elementos de tupla

Hay varias formas en las que podemos acceder a los elementos de una tupla.

1. Indexación

Podemos usar el operador de índice [] para acceder a un elemento en una tupla, donde el índice comienza desde 0.

Entonces, una tupla que tenga 6 elementos tendrá índices de 0 a 5. Intentar acceder a un índice fuera del rango de índice de tupla (6,7,… en este ejemplo) generará un IndexError.

El índice debe ser un número entero, por lo que no podemos usar float u otros tipos. Esto resultará en TypeError.

Del mismo modo, se accede a las tuplas anidadas mediante la indexación anidada, como se muestra en el siguiente ejemplo.

# Accessing tuple elements using indexing
my_tuple = ('p','e','r','m','i','t')

print(my_tuple[0])   # 'p' 
print(my_tuple[5])   # 't'

# IndexError: list index out of range
# print(my_tuple[6])

# Index must be an integer
# TypeError: list indices must be integers, not float
# my_tuple[2.0]

# nested tuple
n_tuple = ("mouse", [8, 4, 6], (1, 2, 3))

# nested index
print(n_tuple[0][3])       # 's'
print(n_tuple[1][1])       # 4

Producción

p
t
s
4

2. Indexación negativa

Python permite la indexación negativa de sus secuencias.

El índice de -1 se refiere al último elemento, -2 al penúltimo elemento y así sucesivamente.

# Negative indexing for accessing tuple elements
my_tuple = ('p', 'e', 'r', 'm', 'i', 't')

# Output: 't'
print(my_tuple[-1])

# Output: 'p'
print(my_tuple[-6])

Producción

t
p

3. Rebanar

Podemos acceder a un rango de elementos en una tupla usando el operador de corte dos puntos :.

# Accessing tuple elements using slicing
my_tuple = ('p','r','o','g','r','a','m','i','z')

# elements 2nd to 4th
# Output: ('r', 'o', 'g')
print(my_tuple[1:4])

# elements beginning to 2nd
# Output: ('p', 'r')
print(my_tuple[:-7])

# elements 8th to end
# Output: ('i', 'z')
print(my_tuple[7:])

# elements beginning to end
# Output: ('p', 'r', 'o', 'g', 'r', 'a', 'm', 'i', 'z')
print(my_tuple[:])

Producción

('r', 'o', 'g')
('p', 'r')
('i', 'z')
('p', 'r', 'o', 'g', 'r', 'a', 'm', 'i', 'z')

El corte se puede visualizar mejor si se considera que el índice está entre los elementos, como se muestra a continuación. Entonces, si queremos acceder a un rango, necesitamos el índice que dividirá la porción de la tupla.

Cambiar una tupla

A diferencia de las listas, las tuplas son inmutables.

Esto significa que los elementos de una tupla no se pueden cambiar una vez que se han asignado. Pero, si el elemento en sí mismo es un tipo de datos mutable como una lista, sus elementos anidados se pueden cambiar.

También podemos asignar una tupla a diferentes valores (reasignación).

# Changing tuple values
my_tuple = (4, 2, 3, [6, 5])


# TypeError: 'tuple' object does not support item assignment
# my_tuple[1] = 9

# However, item of mutable element can be changed
my_tuple[3][0] = 9    # Output: (4, 2, 3, [9, 5])
print(my_tuple)

# Tuples can be reassigned
my_tuple = ('p', 'r', 'o', 'g', 'r', 'a', 'm', 'i', 'z')

# Output: ('p', 'r', 'o', 'g', 'r', 'a', 'm', 'i', 'z')
print(my_tuple)

Producción

(4, 2, 3, [9, 5])
('p', 'r', 'o', 'g', 'r', 'a', 'm', 'i', 'z')

Nosotros podemos usar + operador para combinar dos tuplas. Se llama concatenación.

También podemos repetir los elementos en una tupla por un número dado de veces usando el * operador.

Ambas cosas + y * las operaciones dan como resultado una nueva tupla.

# Concatenation
# Output: (1, 2, 3, 4, 5, 6)
print((1, 2, 3) + (4, 5, 6))

# Repeat
# Output: ('Repeat', 'Repeat', 'Repeat')
print(("Repeat",) * 3)

Producción

(1, 2, 3, 4, 5, 6)
('Repeat', 'Repeat', 'Repeat')

Eliminación de una tupla

Como se discutió anteriormente, no podemos cambiar los elementos en una tupla. Significa que no podemos eliminar o eliminar elementos de una tupla.

Sin embargo, es posible borrar una tupla por completo usando la palabra clave del.

# Deleting tuples
my_tuple = ('p', 'r', 'o', 'g', 'r', 'a', 'm', 'i', 'z')

# can't delete items
# TypeError: 'tuple' object doesn't support item deletion
# del my_tuple[3]

# Can delete an entire tuple
del my_tuple

# NameError: name 'my_tuple' is not defined
print(my_tuple)

Producción

Traceback (most recent call last):
  File "<string>", line 12, in <module>
NameError: name 'my_tuple' is not defined

Métodos de tupla

Los métodos que agregan elementos o eliminan elementos no están disponibles con tupla. Solo están disponibles los dos métodos siguientes.

Algunos ejemplos de métodos de tupla de Python:

my_tuple = ('a', 'p', 'p', 'l', 'e',)

print(my_tuple.count('p'))  # Output: 2
print(my_tuple.index('l'))  # Output: 3

Producción

2
3

Otras operaciones de tupla

1. Prueba de membresía de tupla

Podemos probar si un elemento existe en una tupla o no, usando la palabra clave in.

# Membership test in tuple
my_tuple = ('a', 'p', 'p', 'l', 'e',)

# In operation
print('a' in my_tuple)
print('b' in my_tuple)

# Not in operation
print('g' not in my_tuple)

Producción

True
False
True

2. Iterando a través de una tupla

Podemos usar un for bucle para iterar a través de cada elemento en una tupla.

# Using a for loop to iterate through a tuple
for name in ('John', 'Kate'):
    print("Hello", name)

Producción

Hello John
Hello Kate

Ventajas de Tuple sobre Lista

Dado que las tuplas son bastante similares a las listas, ambas se usan en situaciones similares. Sin embargo, existen ciertas ventajas de implementar una tupla sobre una lista. A continuación se enumeran algunas de las principales ventajas:

• Generalmente usamos tuplas para tipos de datos heterogéneos (diferentes) y listas para tipos de datos homogéneos (similares).
• Dado que las tuplas son inmutables, iterar a través de una tupla es más rápido que con una lista. Así que hay un ligero aumento de rendimiento.
• Las tuplas que contienen elementos inmutables se pueden usar como clave para un diccionario. Con las listas, esto no es posible.
• Si tiene datos que no cambian, implementarlos como tupla garantizará que permanezcan protegidos contra escritura.