Obtendo subtuplas

12.1 Faixa de Índices

O código para obter uma subtupla é igual ao de uma sublista. Nesse sentido, tuplas são bem semelhantes a listas. Não gostaria de repetir material, mas a repetição é a mãe da aprendizagem...

Obter subtuplas, ou slicing, permite extrair partes de uma tupla para criar novas tuplas. Esse processo é especialmente útil quando é necessário trabalhar com determinados segmentos de dados armazenados em uma tupla.

Sintaxe de slices

Slices são criados usando colchetes, onde os índices inicial e final são separados por dois pontos. Se o índice inicial não for especificado, o slice começa do primeiro elemento; se o índice final não for especificado, o slice vai até o fim da tupla.

Um slice de uma tupla pode ser obtido usando a sintaxe tuple[start:stop:step], onde:

• start — índice inicial do elemento (inclusivo);
• stop — índice final do elemento (não inclusivo);
• step — passo usado para selecionar os elementos.

Exemplos:

my_tuple = (0, 1, 2, 3, 4, 5)
sub_tuple = my_tuple[1:4]  # Obtém subtupla com elementos do índice 1 ao 3
print(sub_tuple) # Exibe (1, 2, 3)
            
sub_tuple_with_step = my_tuple[0:6:2]  # Obtém cada segundo elemento de 0 a 5
print(sub_tuple_with_step) # Exibe (0, 2, 4) 
        

Se start não for especificado, ele será 0 por padrão, e se stop não for especificado, ele será len(tuple). O parâmetro step é 1 por padrão.

Exemplos:

# Cria uma tupla com elementos de 0 a 5
my_tuple = (0, 1, 2, 3, 4, 5)

# Cria uma nova tupla, começando pelo segundo elemento da tupla original
sub_tuple = my_tuple[1:] 
print(sub_tuple)  # Saída: (1, 2, 3, 4, 5)

# Cria uma nova tupla, incluindo elementos do início ao quarto elemento 
# (índice 4) da tupla original, com passo 1 (padrão)
sub_tuple_with_step = my_tuple[:5] 
print(sub_tuple_with_step)  # Saída: (0, 1, 2, 3, 4)

12.2 Índices Negativos

Índices negativos em Python começam com -1, que corresponde ao último elemento da lista (ou tupla). -2 indica o penúltimo elemento e assim por diante. Usar índices negativos torna mais fácil acessar elementos a partir do final da tupla sem precisar calcular sua posição a partir do início.

Exemplos de uso

Vamos ver como usar índices negativos para formar um slice. Suponha que temos uma tupla com os valores:

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

Para obter uma subtupla contendo elementos do final até o meio da tupla, podemos usar índices negativos.

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

Assim, my_tuple[-3:-1] seleciona os elementos com índices -3 (terceiro a partir do fim) até -1 (excluindo o último), o que nos dá a tupla (60, 70).

Obtendo o último elemento da tupla:

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

Aqui, my_tuple[-1] sempre retornará o último elemento da tupla, o que é muito conveniente quando não se sabe o número exato de elementos na tupla.

Inverter elementos da tupla:

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

Usar o slice [::-1] permite inverter facilmente a ordem dos elementos em uma tupla, criando uma nova tupla com elementos na ordem inversa.

12.3 Existe um elemento na tupla

Verificar a presença de um elemento na tupla é uma operação padrão que permite saber se um elemento está na tupla. Isso é feito com o operador in, que retorna True se o elemento estiver presente na tupla e False caso contrário.

Usando o operador in

O operador in é uma forma simples e intuitiva de verificar a presença de um elemento:

my_tuple = (1, 2, 3, 4, 5)
element = 3
if element in my_tuple:
    print(f"{element} está na tupla.")
else:
    print(f"{element} não está na tupla.")
    

Verificando se um elemento está ausente:

Se você quer garantir que um elemento está ausente na tupla, apenas use a construção not in:

names = ('Alice', 'Bob', 'Charlie')
search_name = 'Alice'
if search_name not in names:
    print(f"{search_name} não está na tupla.")
else:
    print(f"{search_name} está na tupla.")
    

Quase não difere do trabalho com lista — essa é a universalidade e simplicidade do Python.