Métodos de Tupla

Uma tupla em Python é uma sequência ordenada e imutável. Como as tuplas não podem ser alteradas após a criação, elas expõem apenas dois métodos embutidos: count() e index(). Esta página aborda ambos os métodos em profundidade, incluindo seus parâmetros opcionais, armadilhas comuns e as funções embutidas (len(), min(), max(), sum(), sorted()) que funcionam igualmente bem em tuplas.

Se você é novo em tuplas, leia Tuplas em Python primeiro. Para acessar elementos por posição ou fatia, consulte Acessar Tuplas.

Referência Rápida

Por Que Tão Poucos Métodos?

As listas têm mais de uma dúzia de métodos porque são mutáveis — você pode adicionar, remover, ordenar no lugar e assim por diante. As tuplas são imutáveis: uma vez criadas, seus elementos não podem ser adicionados, removidos ou reordenados. Como resultado, as únicas operações que fazem sentido como métodos de instância são as somente de leitura: contar ocorrências e encontrar posições.

O Método count()

tuple.count(value) percorre toda a tupla e retorna o número de vezes que value aparece. Retorna 0 se o valor não for encontrado — nunca levanta um erro.

count() com Tuplas Aninhadas

count() usa igualdade (==) para comparar, portanto funciona com qualquer tipo de elemento, incluindo tuplas aninhadas:

points = ((0, 0), (1, 2), (0, 0), (3, 4))

print(points.count((0, 0)))  # 2
print(points.count((1, 2)))  # 1

Armadilha: True e 1 São Iguais

Python trata True == 1 e False == 0, portanto count() os conta de forma intercambiável:

data = (1, True, 0, False, 1)

print(data.count(1))     # 3  (counts 1, True, 1)
print(data.count(True))  # 3  (same three elements)
print(data.count(0))     # 2  (counts 0 and False)

Este é o comportamento padrão de igualdade do Python, não uma particularidade das tuplas.

O Método index()

tuple.index(value) retorna o índice da primeira ocorrência de value. Se o valor não estiver presente, levanta um ValueError.

Parâmetros Opcionais start e stop

A assinatura completa é tuple.index(value, start, stop). Você pode restringir o intervalo de busca para evitar reencontrar uma ocorrência já conhecida:

numbers = (10, 20, 30, 20, 40, 20)

# Find first occurrence of 20 starting at index 2
print(numbers.index(20, 2))     # 3

# Find 20 only within numbers[2:5]  →  (30, 20, 40)
print(numbers.index(20, 2, 5))  # 3

O índice stop é exclusivo, seguindo as convenções de fatiamento do Python.

Tratando o ValueError

Sempre proteja index() quando o valor puder estar ausente:

animals = ("cat", "dog", "bird")

target = "fish"
if target in animals:
    pos = animals.index(target)
    print(f"Found {target!r} at index {pos}")
else:
    print(f"{target!r} is not in the tuple")
# fish is not in the tuple

Alternativamente, use um bloco try / except:

try:
    pos = animals.index("fish")
except ValueError:
    pos = -1  # sentinel value when not found

print(pos)  # -1

Funções Embutidas que Funcionam em Tuplas

Embora não sejam métodos de tupla, as seguintes funções embutidas aceitam qualquer iterável — incluindo tuplas — e são frequentemente usadas com elas.

len()

Retorna o número total de elementos:

min() e max()

Retornam os menores e maiores elementos. Os elementos devem ser comparáveis (todos números ou todas strings):

scores = (72, 95, 88, 61, 100)

print(min(scores))  # 61
print(max(scores))  # 100

sum()

Retorna a soma aritmética de uma tupla numérica:

prices = (9.99, 4.49, 14.99)
print(sum(prices))   # 29.47
print(sum(prices, 5.00))  # 34.47  — optional start value

sorted()

Retorna uma nova lista (não uma tupla) com os elementos ordenados em ordem crescente. A tupla original permanece inalterada:

letters = ("d", "a", "c", "b")

asc = sorted(letters)          # ascending (default)
desc = sorted(letters, reverse=True)  # descending

print(asc)   # ['a', 'b', 'c', 'd']
print(desc)  # ['d', 'c', 'b', 'a']
print(letters)  # ('d', 'a', 'c', 'b')  — unchanged

Para obter uma tupla ordenada em vez de uma lista, envolva com tuple():

sorted_tuple = tuple(sorted(letters))
print(sorted_tuple)  # ('a', 'b', 'c', 'd')

Operações Comuns com Tuplas (Não São Métodos)

Embora os padrões a seguir não usem .count() ou .index(), eles aparecem frequentemente ao trabalhar com tuplas.

Concatenação

Use + para combinar duas tuplas em uma nova:

Consulte Unir Tuplas para mais técnicas de junção.

Convertendo uma Tupla em Lista (e Vice-versa)

Como as tuplas são imutáveis, converta para uma list quando precisar modificar o conteúdo e, em seguida, converta de volta:

t = (1, 2, 3)
lst = list(t)
lst.append(4)
t2 = tuple(lst)
print(t2)  # (1, 2, 3, 4)

Para um guia completo sobre padrões de mutação, consulte Atualizar Tuplas.

Verificando Pertencimento

Use in e not in em vez de index() quando você precisar apenas de uma resposta sim/não:

fruits = ("apple", "banana", "cherry")

print("banana" in fruits)      # True
print("mango" not in fruits)   # True

Isso é mais legível e evita o ValueError que index() levanta para valores ausentes.

Escolhendo Entre count() e index()

Capítulos Relacionados

• Tuplas em Python — noções básicas de tuplas e sintaxe de criação
• Acessar Tuplas — indexação e fatiamento
• Atualizar Tuplas — soluções alternativas para imutabilidade
• Desempacotar Tuplas — atribuição por desestruturação
• Iterar sobre Tuplas — iteração com for e while
• Métodos de Lista — o equivalente mutável com muito mais métodos

Prática