Métodos de Tupla

Una tupla de Python es una secuencia ordenada e inmutable. Como las tuplas no pueden modificarse después de su creación, solo exponen dos métodos integrados: count() e index(). Esta página cubre ambos métodos en profundidad, incluyendo sus parámetros opcionales, errores comunes y las funciones integradas (len(), min(), max(), sum(), sorted()) que funcionan igual de bien con tuplas.

Si eres nuevo en las tuplas, lee primero Tuplas en Python. Para acceder a elementos por posición o mediante slices, consulta Acceder a tuplas.

Referencia rápida

¿Por qué tan pocos métodos?

Las listas tienen más de una docena de métodos porque son mutables — puedes agregar elementos, eliminarlos, ordenarlos en su lugar, entre otras operaciones. Las tuplas son inmutables: una vez creadas, sus elementos no pueden añadirse, eliminarse ni reordenarse. Por ello, las únicas operaciones que tienen sentido como métodos de instancia son las de solo lectura: contar ocurrencias y encontrar posiciones.

El método count()

tuple.count(value) recorre toda la tupla y devuelve el número de veces que aparece value. Devuelve 0 si el valor no se encuentra — nunca lanza un error.

count() con tuplas anidadas

count() utiliza la igualdad (==) para comparar, por lo que funciona con cualquier tipo de elemento, incluyendo tuplas anidadas:

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

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

Caso especial: True y 1 son iguales

Python trata True == 1 y False == 0, por lo que count() los cuenta de forma intercambiable:

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 es el comportamiento de igualdad estándar de Python, no una particularidad de las tuplas.

El método index()

tuple.index(value) devuelve el índice de la primera ocurrencia de value. Si el valor no está presente, lanza un ValueError.

Parámetros opcionales start y stop

La firma completa es tuple.index(value, start, stop). Puedes reducir el rango de búsqueda para evitar encontrar de nuevo una ocurrencia ya conocida:

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

El índice stop es exclusivo, siguiendo las convenciones de slices de Python.

Manejo de ValueError

Siempre protege index() cuando el valor podría no estar presente:

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, utiliza un bloque try / except:

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

print(pos)  # -1

Funciones integradas que funcionan con tuplas

Aunque no son métodos de tupla, las siguientes funciones integradas aceptan cualquier iterable — incluidas las tuplas — y se usan con frecuencia con ellas.

len()

Devuelve el número total de elementos:

min() y max()

Devuelven el elemento más pequeño y el más grande. Los elementos deben ser comparables (todos números o todos strings):

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

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

sum()

Devuelve la suma aritmética de una 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()

Devuelve una nueva lista (no una tupla) con los elementos ordenados de forma ascendente. La tupla original no cambia:

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 obtener una tupla ordenada en lugar de una lista, envuélvela en tuple():

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

Operaciones comunes con tuplas (que no son métodos)

Aunque los siguientes patrones no usan .count() ni .index(), aparecen con frecuencia al trabajar con tuplas.

Concatenación

Usa + para combinar dos tuplas en una nueva:

Consulta Unir tuplas para conocer más técnicas de unión.

Convertir una tupla en lista (y viceversa)

Como las tuplas son inmutables, conviértelas a list cuando necesites modificar el contenido y luego vuelve a convertirlas:

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

Para una guía completa sobre patrones de mutación, consulta Actualizar tuplas.

Comprobar pertenencia

Usa in y not in en lugar de index() cuando solo necesitas una respuesta sí/no:

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

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

Esto es más legible y evita el ValueError que index() lanza para valores ausentes.

Elegir entre count() e index()

Capítulos relacionados

• Tuplas en Python — conceptos básicos y sintaxis de creación de tuplas
• Acceder a tuplas — indexación y slicing
• Actualizar tuplas — soluciones alternativas para la inmutabilidad
• Desempaquetar tuplas — asignación por destructuración
• Iterar sobre tuplas — iteración con for y while
• Métodos de lista — el equivalente mutable con muchos más métodos

Práctica