Les Tuples en Python

🎯 Tout savoir sur les tuples Python

📚 Introduction

Les tuples sont des structures de données immuables en Python. Une fois créés, leurs éléments ne peuvent pas être modifiés. Ils se notent avec des parenthèses () et sont particulièrement utiles pour stocker des données qui ne doivent pas changer.

Pourquoi utiliser des tuples ?

Immuabilité : Protection contre les modifications accidentelles
Performance : Plus rapides que les listes
Mémoire : Consomment moins de ressources
Sécurité : Utilisables comme clés de dictionnaire

1️⃣ Création de tuples

Tuple classique

mon_tuple = (1, 2, 3, 4)
print(mon_tuple)  # (1, 2, 3, 4)

Tuple avec types mixtes

tuple_mixte = (1, "Python", 3.14, True)
print(tuple_mixte)  # (1, 'Python', 3.14, True)

Tuple sans parenthèses (packing)

tuple_sans_parentheses = 10, 20, 30
print(tuple_sans_parentheses)  # (10, 20, 30)

⚠️ Piège : tuple à un élément

pas_un_tuple = (42)  # C'est un int !
print(type(pas_un_tuple))  # <class 'int'>

# Solution : ajouter une virgule
tuple_correct = (42,)
print(type(tuple_correct))  # <class 'tuple'>

Conversion vers tuple

# À partir d'une liste
liste_exemple = [1, 2, 3, 4]
tuple_a_partir_liste = tuple(liste_exemple)
print(tuple_a_partir_liste)  # (1, 2, 3, 4)

# À partir d'une chaîne
chaine = "Riyad"
tuple_a_partir_chaine = tuple(chaine)
print(tuple_a_partir_chaine)  # ('R', 'i', 'y', 'a', 'd')

2️⃣ Accès aux éléments

Indexation

mon_tuple = (10, 20, 30, 40, 50)

# Index positif (commence à 0)
print(mon_tuple[0])   # 10
print(mon_tuple[2])   # 30

# Index négatif (depuis la fin)
print(mon_tuple[-1])  # 50
print(mon_tuple[-3])  # 30

Slicing (découpage)

mon_tuple = (10, 20, 30, 40, 50)

print(mon_tuple[0:3])   # (10, 20, 30) - éléments 0 à 2
print(mon_tuple[1:4])   # (20, 30, 40) - éléments 1 à 3
print(mon_tuple[::2])   # (10, 30, 50) - un élément sur deux

Tuples imbriqués

tuple_imbrique = (1, 2, (3, 4, 5), (6, 7), 8)

print(tuple_imbrique[2][0])  # 3 - premier élément du 3e tuple
print(tuple_imbrique[3][1])  # 7 - deuxième élément du 4e tuple

3️⃣ Opérations sur les tuples

Concaténation et répétition

tuple1 = (1, 2, 3)
tuple2 = (4, 5, 6)

# Concaténation
tuple_concatenation = tuple1 + tuple2
print(tuple_concatenation)  # (1, 2, 3, 4, 5, 6)

# Répétition
tuple_repetition = (1, 2) * 3
print(tuple_repetition)  # (1, 2, 1, 2, 1, 2)

Appartenance

tuple_element = (1, 2, 3, 4, 5)
print(3 in tuple_element)  # True
print(6 in tuple_element)  # False

4️⃣ Fonctions et méthodes

Fonctions intégrées

mon_tuple = (10, 20, 30, 40, 50)

print(len(mon_tuple))  # 5 - nombre d'éléments
print(min(mon_tuple))  # 10 - valeur minimale
print(max(mon_tuple))  # 50 - valeur maximale

Méthodes des tuples

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

print(mon_tuple.count(20))  # 2 - nombre d'occurrences
print(mon_tuple.index(40))  # 4 - index de la première occurrence

Comparaison

tuple1 = (1, 2, 3)
tuple2 = (4, 5, 6)

print(tuple1 == tuple2)  # False
print(tuple1 < tuple2)   # True - comparaison lexicographique

Conversion en liste

mon_tuple = (1, 2, 3, 4)
liste = list(mon_tuple)
print(liste)  # [1, 2, 3, 4]

5️⃣ Tuples nommés (namedtuples)

Les namedtuples permettent d’accéder aux éléments par nom plutôt que par index.

Création

from collections import namedtuple

Point = namedtuple("Point", ["x", "y"])
p = Point(10, 20)

print(p)      # Point(x=10, y=20)
print(p.x)    # 10 - accès par nom
print(p.y)    # 20
print(p[0])   # 10 - accès par index (toujours possible)

Exemple pratique

from collections import namedtuple

Personne = namedtuple("Personne", ["nom", "prenom", "age"])
personne = Personne("Kouadio", "Riyad", 21)

print(personne.nom)     # Kouadio
print(personne.prenom)  # Riyad
print(personne.age)     # 21

Méthodes des namedtuples

# Conversion en dictionnaire
personne_dict = personne._asdict()
print(personne_dict)  # {'nom': 'Kouadio', 'prenom': 'Riyad', 'age': 21}

# Modification (crée un nouveau namedtuple)
personne_modifiee = personne._replace(age=25)
print(personne_modifiee)  # Personne(nom='Kouadio', prenom='Riyad', age=25)
print(personne.age)       # 21 - l'original est inchangé

6️⃣ Retour de multiples valeurs

Les tuples sont parfaits pour retourner plusieurs valeurs depuis une fonction.

def calculs(a, b):
    somme = a + b
    produit = a * b
    return somme, produit  # Retourne un tuple

# Récupération du tuple complet
resultat = calculs(12, 14)
print(resultat)  # (26, 168)

# Décomposition (unpacking)
somme, produit = calculs(12, 14)
print(somme)    # 26
print(produit)  # 168

Cas d’usage pratiques

Coordonnées : return x, y, z
Statistiques : return min, max, moyenne
Succès et résultat : return True, valeur
Swap de variables : a, b = b, a

📋 Évaluation des connaissances

À quoi sert cette évaluation ?

Cette évaluation rapide (3 minutes) va vous permettre de vérifier votre compréhension du sujet traité dans ce guide.

Instructions :

🕒 Temps limité : 3 minutes
🎯 Seuil de réussite : 80%
💡 Les réponses seront expliquées à la fin

À vous de jouer ! 🚀

📝 Exercices pratiques

Exercice 1 : Création et manipulation de base

Énoncé : Créez un tuple contenant les 7 jours de la semaine. Affichez le premier jour, le dernier jour, et les jours du milieu (du mardi au vendredi).

Exemple d’exécution :

jours = ()  # Votre code ici

Voir la solution

# Création du tuple
jours = ("Lundi", "Mardi", "Mercredi", "Jeudi", "Vendredi", "Samedi", "Dimanche")

# Premier jour
print(f"Premier jour : {jours[0]}")

# Dernier jour
print(f"Dernier jour : {jours[-1]}")

# Jours du milieu
print(f"Jours du milieu : {jours[1:5]}")

Résultat attendu :

Premier jour : Lundi
Dernier jour : Dimanche
Jours du milieu : ('Mardi', 'Mercredi', 'Jeudi', 'Vendredi')

Exercice 2 : Coordonnées GPS

Énoncé : Créez un tuple pour stocker les coordonnées GPS de Cotonou (6.3703, 2.3912). Décomposez le tuple en variables latitude et longitude, puis affichez-les de manière formatée.

Exemple d’exécution :

cotonou = ()  # Votre code ici

Voir la solution

# Coordonnées de Cotonou
cotonou = (6.3703, 2.3912)

# Décomposition
lat, lon = cotonou

# Affichage
print(f"📍 Cotonou")
print(f"Latitude  : {lat}°")
print(f"Longitude : {lon}°")

# Déterminer l'hémisphère
hemisphere = "Nord" if lat > 0 else "Sud"
print(f"Hémisphère : {hemisphere}")

Résultat attendu :

📍 Cotonou
Latitude  : 6.3703°
Longitude : 2.3912°
Hémisphère : Nord

Exercice 3 : Statistiques avec namedtuples

Énoncé : Créez un namedtuple Produit avec les champs : nom, prix, stock. Créez 3 produits et calculez la valeur totale du stock.

Exemple d’exécution :

from collections import namedtuple
# Votre code ici

Voir la solution

from collections import namedtuple

# Définir le namedtuple
Produit = namedtuple("Produit", ["nom", "prix", "stock"])

# Créer les produits
produits = [
    Produit("Laptop", 999.99, 10),
    Produit("Souris", 29.99, 50),
    Produit("Clavier", 79.99, 25)
]

# Calcul de la valeur totale
print("🛒 Inventaire :")
print("-" * 40)
valeur_totale = 0

for p in produits:
    valeur = p.prix * p.stock
    valeur_totale += valeur
    print(f"{p.nom:<10} | {p.prix:>8.2f}€ | {valeur:>10.2f}€")

print("-" * 40)
print(f"Total : {valeur_totale:.2f}€")

Résultat attendu :

🛒 Inventaire :
----------------------------------------
Laptop     |   999.99€ |    9999.90€
Souris     |    29.99€ |    1499.50€
Clavier    |    79.99€ |    1999.75€
----------------------------------------
Total : 13499.15€

Exercice 4 : Fonction avec retour multiple

Énoncé : Créez une fonction analyser_nombre(n) qui retourne un tuple contenant : le nombre, son carré, son cube, et s’il est pair (True/False). Testez avec 7.

Exemple d’exécution :

def analyser_nombre(n):
    # Votre code ici
    pass

Voir la solution

def analyser_nombre(n):
    carre = n ** 2
    cube = n ** 3
    est_pair = n % 2 == 0
    return n, carre, cube, est_pair

# Test avec décomposition
nombre, carre, cube, est_pair = analyser_nombre(7)

print(f"Nombre    : {nombre}")
print(f"Carré     : {carre}")
print(f"Cube      : {cube}")
print(f"Est pair  : {est_pair}")

Résultat attendu :

Nombre    : 7
Carré     : 49
Cube      : 343
Est pair  : False

Exercice 5 : Opérations et conversions

Énoncé : Partez d’une liste de températures [22, 25, 28, 26, 24]. Convertissez-la en tuple, puis :

Affichez la température min, max et moyenne
Créez un nouveau tuple avec uniquement les températures > 24
Vérifiez si 26 est dans le tuple

Exemple d’exécution :

temperatures_liste = [22, 25, 28, 26, 24]
# Votre code ici

Voir la solution

# Liste de départ
temperatures_liste = [22, 25, 28, 26, 24]

# Conversion en tuple
temperatures = tuple(temperatures_liste)
print(f"Températures : {temperatures}")

# Statistiques
temp_min = min(temperatures)
temp_max = max(temperatures)
temp_moyenne = sum(temperatures) / len(temperatures)

print(f"\n📊 Statistiques :")
print(f"Min     : {temp_min}°C")
print(f"Max     : {temp_max}°C")
print(f"Moyenne : {temp_moyenne:.1f}°C")

# Filtrage (conversion en tuple après)
temp_hautes = tuple(t for t in temperatures if t > 24)
print(f"\nTempératures > 24°C : {temp_hautes}")

# Vérification d'appartenance
print(f"26 dans le tuple : {26 in temperatures}")

Résultat attendu :

Températures : (22, 25, 28, 26, 24)

📊 Statistiques :
Min     : 22°C
Max     : 28°C
Moyenne : 25.0°C

Températures > 24°C : (25, 28, 26)
26 dans le tuple : True

🎯 Conclusion

Les tuples sont des structures immuables essentielles en Python. Leur principale force réside dans leur capacité à protéger les données contre les modifications accidentelles tout en offrant de meilleures performances que les listes. Les namedtuples ajoutent une couche de lisibilité en permettant l’accès par nom.

Utilisez les tuples pour stocker des données qui ne doivent pas changer : coordonnées, configurations, valeurs de retour multiples. Leur immuabilité et leur efficacité en font un choix judicieux pour écrire du code Python robuste et performant.

Bon codage ! 🐍✨

📢 Partagez cet article

LinkedIn Twitter Facebook WhatsApp

À propos de l'auteur

Riyad ODJOUADEExpert en cybersécurité & infrastructure

Je partage des guides techniques pratiques sur la cybersécurité, l'administration système et le développement web. Tous les contenus sont basés sur des expérimentations réelles.

LinkedIn GitHub Email