Méthodes des tuples

Un tuple Python est une séquence ordonnée et immuable. Comme les tuples ne peuvent pas être modifiés après leur création, ils n'exposent que deux méthodes intégrées : count() et index(). Cette page couvre les deux méthodes en profondeur, notamment leurs paramètres optionnels, les pièges courants et les quelques fonctions intégrées (len(), min(), max(), sum(), sorted()) qui fonctionnent tout aussi bien sur les tuples.

Si vous débutez avec les tuples, lisez d'abord Python Tuples. Pour accéder aux éléments par position ou par tranche, consultez Access Tuples.

Référence rapide

Pourquoi si peu de méthodes ?

Les listes disposent d'une douzaine de méthodes car elles sont mutables — on peut y ajouter, supprimer, trier en place, etc. Les tuples sont immuables : une fois créés, leurs éléments ne peuvent être ajoutés, supprimés ni réordonnés. En conséquence, les seules opérations qui ont du sens en tant que méthodes d'instance sont les opérations en lecture seule : compter les occurrences et trouver des positions.

La méthode count()

tuple.count(value) parcourt l'intégralité du tuple et retourne le nombre de fois où value apparaît. Elle retourne 0 si la valeur n'est pas trouvée — elle ne lève jamais d'erreur.

count() avec des tuples imbriqués

count() utilise l'égalité (==) pour comparer, elle fonctionne donc sur tout type d'élément, y compris les tuples imbriqués :

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

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

Piège : True et 1 sont égaux

Python considère que True == 1 et False == 0, donc count() les compte de manière interchangeable :

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)

Il s'agit du comportement d'égalité standard de Python, pas d'une particularité des tuples.

La méthode index()

tuple.index(value) retourne l'index de la première occurrence de value. Si la valeur n'est pas présente, elle lève une ValueError.

Paramètres optionnels start et stop

La signature complète est tuple.index(value, start, stop). Vous pouvez restreindre la plage de recherche pour éviter de retrouver une occurrence déjà connue :

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

L'index stop est exclusif, conformément aux conventions des tranches Python.

Gestion de ValueError

Protégez toujours index() lorsque la valeur est susceptible d'être absente :

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

Vous pouvez également utiliser un bloc try / except :

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

print(pos)  # -1

Fonctions intégrées compatibles avec les tuples

Bien qu'il ne s'agisse pas de méthodes de tuple, les fonctions intégrées suivantes acceptent tout itérable — y compris les tuples — et sont fréquemment utilisées avec eux.

len()

Retourne le nombre total d'éléments :

min() et max()

Retournent le plus petit et le plus grand des éléments. Les éléments doivent être comparables (tous des nombres, ou tous des string) :

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

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

sum()

Retourne la somme arithmétique d'un tuple numérique :

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

sorted()

Retourne une nouvelle liste (pas un tuple) avec les éléments triés par ordre croissant. Le tuple original reste inchangé :

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

Pour obtenir un tuple trié plutôt qu'une liste, enveloppez le résultat dans tuple() :

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

Opérations courantes sur les tuples (sans méthodes)

Même si les modèles suivants n'utilisent pas .count() ni .index(), ils reviennent souvent lors du travail avec les tuples.

Concaténation

Utilisez + pour combiner deux tuples en un nouveau :

Consultez Join Tuples pour d'autres techniques de jonction.

Conversion d'un tuple en liste (et inversement)

Comme les tuples sont immuables, convertissez-les en list lorsque vous devez modifier le contenu, puis reconvertissez :

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

Pour un guide complet sur les modèles de mutation, consultez Update Tuples.

Vérification d'appartenance

Préférez in et not in à index() lorsque vous n'avez besoin que d'une réponse oui/non :

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

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

C'est plus lisible et évite la ValueError que index() lève pour les valeurs absentes.

Choisir entre count() et index()

Chapitres associés

• Python Tuples — bases des tuples et syntaxe de création
• Access Tuples — indexage et tranches
• Update Tuples — contournements pour l'immuabilité
• Unpack Tuples — affectation par déstructuration
• Loop Tuples — itération avec for et while
• List Methods — le pendant mutable avec beaucoup plus de méthodes

Pratique