Obteniendo subtuplas

12.1 Rango de índices

El código para obtener una subtupla se ve igual que para obtener una sublista. En ese sentido, las tuplas son muy similares a ellas. No quisiéramos duplicar el material, pero la repetición es la madre del aprendizaje...

Obtener subtuplas, o slicing, te permite extraer partes de una tupla para crear nuevas tuplas. Este proceso es especialmente útil cuando necesitas trabajar con segmentos específicos de datos almacenados en una tupla.

Sintaxis de los slices

Los slices se crean utilizando corchetes, dentro de los cuales se indican los índices de inicio y fin, separados por dos puntos. Si no se especifica el índice inicial, el slice comienza desde el primer elemento; si no se especifica el índice final, el slice va hasta el final de la tupla.

Puedes obtener un slice de una tupla usando la sintaxis tuple[start:stop:step], donde:

• start — índice del elemento inicial (inclusive);
• stop — índice del elemento final (no inclusive);
• step — paso con el que se seleccionan los elementos.

Ejemplos:

my_tuple = (0, 1, 2, 3, 4, 5)
sub_tuple = my_tuple[1:4]  # Obtenemos la subtupla con elementos desde el índice 1 hasta el 3
print(sub_tuple) # Mostrará (1, 2, 3)
            
sub_tuple_with_step = my_tuple[0:6:2]  # Obtenemos cada segundo elemento desde 0 hasta 5
print(sub_tuple_with_step) # Mostrará (0, 2, 4) 
        

Si start no está especificado, por defecto es 0, y si stop no está especificado, es len(tuple). El parámetro step por defecto es 1.

Ejemplos:

# Creamos una tupla con elementos del 0 al 5
my_tuple = (0, 1, 2, 3, 4, 5)

# Creamos una nueva tupla comenzando desde el segundo elemento de la tupla original
sub_tuple = my_tuple[1:] 
print(sub_tuple)  # Salida: (1, 2, 3, 4, 5)

# Creamos una nueva tupla incluyendo elementos desde el inicio hasta el cuarto elemento 
# (índice 4) de la tupla original, con paso 1 (por defecto)
sub_tuple_with_step = my_tuple[:5] 
print(sub_tuple_with_step)  # Salida: (0, 1, 2, 3, 4)

12.2 Índices negativos

Los índices negativos en Python comienzan con -1, lo que corresponde al último elemento de la lista (o tupla). -2 señalará el penúltimo elemento, y así sucesivamente. El uso de índices negativos facilita el acceso a los elementos desde el final de la tupla sin la necesidad de calcular su posición desde el inicio.

Ejemplos de uso

Vamos a ver cómo usar índices negativos para crear un slice. Supongamos que tenemos una tupla con valores:

my_tuple = (10, 20, 30, 40, 50, 60, 70, 80)

Para obtener una subtupla que contenga elementos desde el final hasta la mitad de la tupla, podemos usar índices negativos.

sub_tuple = my_tuple[-3:-1]
print(sub_tuple) # Mostrará (60, 70)

Así, my_tuple[-3:-1] seleccionará los elementos con índices -3 (tercero desde el final) hasta -1 (no incluyendo el último), lo que nos dará la tupla (60, 70).

Obteniendo el último elemento de la tupla:

my_tuple = (10, 20, 30, 40, 50)
last_element = my_tuple[-1]
print(last_element) # Mostrará 50 
    

Aquí, my_tuple[-1] siempre devolverá el último elemento de la tupla, lo cual es muy conveniente cuando no se conoce el número exacto de elementos en la tupla.

Invertir el orden de los elementos de la tupla:

my_tuple = (10, 20, 30, 40, 50)
reversed_tuple = my_tuple[::-1]
print(reversed_tuple) # Mostrará (50, 40, 30, 20, 10) 
    

Usar el slice [::-1] permite invertir fácil y eficientemente el orden de los elementos en la tupla, obteniendo una nueva tupla con los elementos en orden inverso.

12.3 ¿Está el elemento en la tupla?

Verificar la presencia de un elemento en una tupla es una operación estándar que te permite saber si un elemento está en la tupla. Esto se hace con el operador in, que devuelve True si el elemento está presente en la tupla, y False en caso contrario.

Uso del operador in

El operador in es una forma sencilla e intuitiva de comprobar la existencia de un elemento:

my_tuple = (1, 2, 3, 4, 5)
element = 3
if element in my_tuple:
    print(f"{element} está en la tupla.")
else:
    print(f"{element} no está en la tupla.")
    

Verificar que un elemento está ausente:

Si quieres asegurarte de que un elemento no está en la tupla, simplemente usa la construcción not in:

names = ('Alice', 'Bob', 'Charlie')
search_name = 'Alice'
if search_name not in names:
    print(f"{search_name} no está en la tupla.")
else:
    print(f"{search_name} está en la tupla.")
    

No difiere casi nada de trabajar con listas, y ahí está la universalidad y sencillez de Python.