Cours Python By Niaina Nomenjanahary 2025

Formation Python 2025

Les tuples en Python

Table des matières

1. Introduction

2. Création de tuples

3. Accès aux éléments

4. Méthodes de tuples

5. Tuples vs Listes

6. Cas d'utilisation

7. Immuabilité et performances

8. Déballage de tuples

9. Échange de valeurs

10. Tuples nommés

11. Comparaison avec les listes

12. Exercices pratiques

Introduction
Les tuples sont des collections ordonnées et immuables d'éléments en Python. Contrairement aux
listes, les tuples ne peuvent pas être modifiés après leur création. Ils sont particulièrement utiles
lorsque vous voulez stocker des données qui ne devraient pas changer, comme les coordonnées
d'un point ou les informations d'une personne.

Les tuples offrent plusieurs avantages :

- Performance légèrement meilleure que les listes
- Protection contre la modification accidentelle de données
- Possibilité d'être utilisés comme clés de dictionnaire (si tous leurs éléments sont immuables)
- Clarté syntaxique pour les retours multiples de fonctions

Page 1 sur 13
 Cours Python By Niaina Nomenjanahary 2025

Création de tuples
Il existe plusieurs façons de créer des tuples en Python :

# Tuple vide
tuple_vide = ()

💡 Explication détaillée :
- () crée un tuple vide
- Équivalent à tuple() mais plus concis
- Contient 0 élément
- Immuable par nature

# Tuple avec un seul élément (attention à la virgule)

singleton = (42,) # Sans la virgule, ce serait juste un entier entre paren‐
thèses
singleton_alt = 42, # Cette notation fonctionne aussi

💡 Explication détaillée :
- PIÈGE IMPORTANT : (42) n'est PAS un tuple, c'est juste le nombre 42 entre parenthèses
- La virgule (42,) est OBLIGATOIRE pour créer un tuple à un élément
- 42, sans parenthèses fonctionne aussi (tuple implicite)
- Python reconnaît le tuple grâce à la virgule, pas aux parenthèses

# Tuple avec plusieurs éléments

coordonnees = (10, 20)
personne = ("Jean", 25, "Paris")

💡 Explication détaillée :
- coordonnees : Tuple de 2 entiers (point 2D)
- personne : Tuple hétérogène (str, int, str)
- Les parenthèses sont optionnelles mais recommandées pour la lisibilité
- Ordre des éléments est préservé et significatif

# Création à partir d'autres itérables

liste = [1, 2, 3]
tuple_from_liste = tuple(liste) # (1, 2, 3)
tuple_from_chaine = tuple("Python") # ('P', 'y', 't', 'h', 'o', 'n')

Page 2 sur 13
 Cours Python By Niaina Nomenjanahary 2025

💡 Explication détaillée :
- tuple(liste) convertit une liste en tuple
- tuple("Python") convertit chaque caractère en élément du tuple
- Le constructeur tuple() accepte n'importe quel itérable
- Utile pour "figer" une liste en structure immuable

# Tuple implicite (sans parenthèses)

dimensions = 10, 20, 30

💡 Explication détaillée :
- Python reconnaît automatiquement la séquence comme un tuple
- Équivalent à dimensions = (10, 20, 30)
- Syntaxe plus concise, souvent utilisée pour les retours de fonction
- Les virgules définissent le tuple, pas les parenthèses

Accès aux éléments

L'accès aux éléments d'un tuple fonctionne de la même manière que pour les listes :

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

# Accès par index

x = coordonnees[0] # 10
y = coordonnees[1] # 20
dernier = coordonnees[-1] # 50

💡 Explication détaillée :
- coordonnees[0] : Premier élément (indice 0)
- coordonnees[1] : Deuxième élément (indice 1)
- coordonnees[-1] : Dernier élément (indice négatif)
- Même syntaxe que les listes, accès en O(1)

# Découpage (slicing)
sous_tuple = coordonnees[1:4] # (20, 30, 40)
debut = coordonnees[:2] # (10, 20)
fin = coordonnees[-2:] # (40, 50)

Page 3 sur 13
 Cours Python By Niaina Nomenjanahary 2025

💡 Explication détaillée :
- coordonnees[1:4] : De l'indice 1 (inclus) à 4 (exclu)
- coordonnees[:2] : Du début jusqu'à l'indice 2 (exclu)
- coordonnees[-2:] : Les 2 derniers éléments
- Le slicing crée un NOUVEAU tuple (pas de modification de l'original)

# Vérification d'appartenance
if 30 in coordonnees:
print("La valeur 30 est présente")

💡 Explication détaillée :
- 30 in coordonnees teste la présence de la valeur 30
- Parcours séquentiel du tuple : O(n)
- Retourne True si trouvé, False sinon
- Même syntaxe que pour les listes

Méthodes de tuples
Les tuples ne disposent que de deux méthodes intégrées, du fait de leur nature immuable :

nombres = (1, 2, 3, 2, 4, 2, 5)

# count() - Compte le nombre d'occurrences d'une valeur

occurrences = [Link](2) # 3 (le nombre 2 apparaît 3 fois)

💡 Explication détaillée :
- count(valeur) parcourt tout le tuple pour compter les occurrences
- Le nombre 2 apparaît aux indices 1, 3, et 5 = 3 fois
- Complexité O(n) - parcours complet
- Retourne 0 si la valeur n'existe pas

# index() - Trouve l'indice de la première occurrence d'une valeur

position = [Link](3) # 2 (l'élément 3 est à l'indice 2)

💡 Explication détaillée :
- index(valeur) retourne l'indice de la PREMIÈRE occurrence
- L'élément 3 est à la position 2 (3ème élément)
- S'arrête dès qu'il trouve la première occurrence
- Lève ValueError si la valeur n'existe pas

Page 4 sur 13
 Cours Python By Niaina Nomenjanahary 2025

# Avec un intervalle de recherche

position_2 = [Link](2, 2) # 3 (cherche le premier 2 à partir de
l'indice 2)

💡 Explication détaillée :
- index(valeur, début) commence la recherche à partir de l'indice début
- Cherche le premier 2 à partir de l'indice 2
- Trouve le 2 à l'indice 3 (ignore celui à l'indice 1)
- Peut aussi spécifier une fin : index(valeur, début, fin)

Tuples vs Listes
Bien que similaires en apparence, les tuples et les listes présentent des différences importantes :

# Les listes sont mutables

ma_liste = [1, 2, 3]
ma_liste[0] = 99 # Valide
ma_liste.append(4) # Valide

💡 Explication détaillée :
- Les listes peuvent être modifiées après création
- ma_liste[0] = 99 : Assignation directe possible
- ma_liste.append(4) : Méthodes de modification disponibles
- Structure dynamique qui peut grandir ou rétrécir

# Les tuples sont immuables

mon_tuple = (1, 2, 3)
# mon_tuple[0] = 99 # TypeError: 'tuple' object does not support item assign‐
ment
# mon_tuple.append(4) # AttributeError: 'tuple' object has no attribute 'ap‐
pend'

💡 Explication détaillée :
- Les tuples NE PEUVENT PAS être modifiés après création
- mon_tuple[0] = 99 lèverait une TypeError
- append() , remove() , etc. n'existent pas pour les tuples
- Structure figée qui garantit l'intégrité des données

Page 5 sur 13
 Cours Python By Niaina Nomenjanahary 2025

Cas d'utilisation
Les tuples sont particulièrement adaptés dans les situations suivantes :

1. Données hétérogènes avec structure fixe :

python personne = ("Jean", "Dupont", 35, "Ingénieur") point_3d = (23.5, 42.1,
10.8)
💡 Explication détaillée :
- personne : Structure fixe (prénom, nom, âge, profession)
- point_3d : Coordonnées 3D qui ne devraient pas changer
- Ordre des éléments est significatif et prévisible
- Immuabilité protège contre les modifications accidentelles

2. Retour de plusieurs valeurs depuis une fonction :

```python
def get_dimensions():
return (1920, 1080) # Tuple implicite

largeur, hauteur = get_dimensions() # Déballage du tuple

`` **💡 Explication détaillée :** - return (1920, 1080) : Retourne un tuple de 2
valeurs - 1920, 1080 sans parenthèses fonctionne aussi (tuple implicite) - largeur,
hauteur = ...` : Déballage automatique du tuple
- Pattern très courant en Python pour retourner plusieurs valeurs

1. Clés de dictionnaires (les listes ne peuvent pas servir de clés) :

python positions = { (0, 0): "Origine", (10, 20): "Position A", (30, 40):
"Position B" }
💡 Explication détaillée :
- Seuls les objets immuables peuvent être clés de dictionnaire
- (0, 0) : Tuple immuable ✅ peut être clé
- [0, 0] : Liste mutable ❌ ne peut pas être clé
- Utile pour indexer par coordonnées, couples de valeurs, etc.

2. Protection des données contre les modifications :

python JOURS = ("Lundi", "Mardi", "Mercredi", "Jeudi", "Vendredi", "Samedi",
"Dimanche") COULEURS_RGB = ((255, 0, 0), (0, 255, 0), (0, 0, 255))
💡 Explication détaillée :
- JOURS : Constante qui ne doit jamais changer
- COULEURS_RGB : Tuple de tuples (rouge, vert, bleu)
- L'immuabilité garantit qu'aucun code ne peut modifier ces valeurs
- Convention : MAJUSCULES pour les constantes

Page 6 sur 13
 Cours Python By Niaina Nomenjanahary 2025

Immuabilité et performances
L'immuabilité des tuples leur confère certains avantages techniques :

import sys

# Les tuples prennent généralement moins de mémoire

ma_liste = [1, 2, 3, 4, 5]
mon_tuple = (1, 2, 3, 4, 5)

print([Link](ma_liste)) # Généralement plus grand

print([Link](mon_tuple)) # Généralement plus petit

💡 Explication détaillée :
- [Link]() mesure la taille en mémoire (en octets)
- Les listes ont besoin d'espace supplémentaire pour la mutabilité
- Les tuples sont plus compacts car structure fixe
- Différence typique : ~10-20% moins de mémoire pour les tuples

# Tester les performances

import timeit

# Création
temps_liste = [Link](stmt="[1, 2, 3, 4, 5]", number=1000000)
temps_tuple = [Link](stmt="(1, 2, 3, 4, 5)", number=1000000)
print(f"Création liste: {temps_liste}, Création tuple: {temps_tuple}")

💡 Explication détaillée :
- [Link]() mesure le temps d'exécution précisément
- number=1000000 : Répète l'opération 1 million de fois
- Les tuples sont généralement ~10-15% plus rapides à créer
- Moins d'allocations mémoire nécessaires

# Accès
temps_acces_liste = [Link](stmt="l[2]", setup="l=[1, 2, 3, 4, 5]", num‐
ber=10000000)
temps_acces_tuple = [Link](stmt="t[2]", setup="t=(1, 2, 3, 4, 5)", num‐
ber=10000000)
print(f"Accès liste: {temps_acces_liste}, Accès tuple: {temps_acces_tuple}")

💡 Explication détaillée :
- setup prépare les variables avant le test
- number=10000000 : 10 millions d'accès pour mesurer la différence
- L'accès par indice est légèrement plus rapide pour les tuples
- Différence minime mais mesurable sur de gros volumes

Page 7 sur 13
 Cours Python By Niaina Nomenjanahary 2025

Déballage de tuples
Le déballage de tuples est une fonctionnalité puissante qui permet d'attribuer les éléments d'un tuple
à des variables individuelles :

# Déballage simple
coordonnees = (10, 20, 30)
x, y, z = coordonnees
print(f"x = {x}, y = {y}, z = {z}") # x = 10, y = 20, z = 30

💡 Explication détaillée :
- x, y, z = coordonnees : Déballage (unpacking) du tuple
- Assigne chaque élément du tuple à une variable correspondante
- Le nombre de variables DOIT égaler le nombre d'éléments
- Très pratique pour récupérer les valeurs de retour de fonction

# Déballage partiel avec *

premiers, *milieu, dernier = (1, 2, 3, 4, 5)
print(premiers) # 1
print(milieu) # [2, 3, 4]
print(dernier) # 5

💡 Explication détaillée :
- *milieu capture tous les éléments du "milieu"
- premiers = premier élément (1)
- *milieu = éléments restants sauf le dernier [2, 3, 4]
- dernier = dernier élément (5)
- Utile quand on ne connaît pas le nombre exact d'éléments

# Ignorer certaines valeurs avec _

nom, _, age = ("Alice", "Paris", 30)
print(f"Nom: {nom}, Âge: {age}") # Nom: Alice, Âge: 30

💡 Explication détaillée :
- _ est une convention pour les valeurs qu'on veut ignorer
- "Paris" est assigné à _ mais n'est pas utilisé
- Plus lisible que nom, ville, age = ... si on n'utilise pas ville
- _ n'est qu'une variable comme les autres, c'est juste une convention

Page 8 sur 13
 Cours Python By Niaina Nomenjanahary 2025

Échange de valeurs
Les tuples sont souvent utilisés pour échanger des valeurs entre variables de manière élégante :

a = 5
b = 10

# Échange traditionnel (utilisant une variable temporaire)

temp = a
a = b
b = temp

💡 Explication détaillée :
- Méthode classique en 3 étapes
- temp stocke temporairement la valeur de a
- Puis a prend la valeur de b
- Enfin b prend la valeur stockée dans temp

# Échange pythonique (utilisant un tuple implicite)

a, b = b, a
print(f"a = {a}, b = {b}") # a = 5, b = 10

💡 Explication détaillée :
- a, b = b, a : Une seule ligne pour échanger
- Python crée temporairement un tuple (b, a) à droite
- Puis déballe ce tuple dans a, b à gauche
- Plus élégant et lisible que la méthode traditionnelle
- Fonctionne avec plus de 2 variables : a, b, c = c, a, b

Tuples nommés
Les tuples nommés sont des sous-classes de tuple qui permettent d'accéder aux éléments par des
noms en plus des indices :

from collections import namedtuple

# Définition d'un tuple nommé

Point = namedtuple('Point', ['x', 'y', 'z'])

Page 9 sur 13
 Cours Python By Niaina Nomenjanahary 2025

💡 Explication détaillée :
- namedtuple crée une nouvelle classe de tuple avec des noms de champs
- 'Point' : Nom de la classe créée
- ['x', 'y', 'z'] : Liste des noms de champs
- Alternative : 'x y z' (chaîne avec espaces) ou 'x,y,z' (virgules)

# Création d'une instance

p = Point(10, 20, 30)

💡 Explication détaillée :
- Point(10, 20, 30) crée une instance avec x=10, y=20, z=30
- Fonctionne comme un constructeur de classe
- Les arguments peuvent être positionnels ou nommés

# Accès aux valeurs

print(p.x) # 10 (accès par nom)
print(p[0]) # 10 (accès par indice)
print(p._asdict()) # {'x': 10, 'y': 20, 'z': 30} (conversion en dictionnaire)

💡 Explication détaillée :
- p.x : Accès par nom de champ (plus lisible)
- p[0] : Accès par indice (comme un tuple normal)
- p._asdict() : Convertit en dictionnaire ordonné
- Double avantage : lisibilité des noms + efficacité des tuples

# Création avec des paramètres nommés

p2 = Point(z=30, y=20, x=10) # Ordre des paramètres flexible
print(p == p2) # True, les valeurs sont les mêmes

💡 Explication détaillée :
- Arguments nommés permettent de changer l'ordre
- p2 a les mêmes valeurs que p malgré l'ordre différent
- p == p2 compare les valeurs, pas l'ordre de création
- Plus sûr que les arguments positionnels

# Les tuples nommés sont également immuables

try:
p.x = 100 # AttributeError: can't set attribute
except AttributeError as e:
print(f"Erreur: {e}")

Page 10 sur 13
 Cours Python By Niaina Nomenjanahary 2025

💡 Explication détaillée :
- Tentative de modification lève une AttributeError
- Immuabilité préservée comme pour les tuples normaux
- Protection contre les modifications accidentelles
- Cohérence avec la philosophie des tuples

# Mais on peut créer une copie modifiée

p3 = p._replace(x=100)
print(p3) # Point(x=100, y=20, z=30)

💡 Explication détaillée :
- _replace() crée un NOUVEAU tuple nommé avec des valeurs modifiées
- L'original p reste inchangé
- Seuls les champs spécifiés sont modifiés
- Pattern fonctionnel : pas de mutation, mais création d'une nouvelle version

Comparaison entre listes et tuples

Caractéristique Tuples Listes

Mutabilité Immuables Mutables

Syntaxe (1, 2, 3) ou 1, 2, 3 [1, 2, 3]

Performances Généralement plus rapides Légèrement plus lents

Utilisable comme clé de Oui (s'il ne contient pas d'objets

Non
dictionnaire mutables)

Moins nombreuses (seulement Nombreuses ( append ,

Méthodes disponibles
count , index ) remove , etc.)

Données qui ne devraient pas

Cas d'utilisation typique Collections dynamiques
changer

💡 Explication détaillée du tableau :

• Mutabilité : Différence fondamentale - tuples figés, listes modifiables

• Syntaxe : Parenthèses vs crochets, virgules optionnelles pour tuples

• Performances : Tuples ~10-15% plus rapides (création et accès)

Page 11 sur 13
 Cours Python By Niaina Nomenjanahary 2025

• Clés de dictionnaire : Seuls les objets hashables (immuables) peuvent être clés

• Méthodes : Tuples ont moins de méthodes car pas de modification possible

• Cas d'usage : Tuples pour structure fixe, listes pour collections dynamiques

Quand utiliser des tuples plutôt que des listes ?

💡 Guide de décision détaillé :

• Pour représenter une collection de valeurs hétérogènes dont la structure est fixe (comme
des coordonnées, des informations personnelles)

• Exemple : (nom, prénom, âge) - structure qui ne changera jamais

• La position a un sens : premier élément = nom, deuxième = prénom, etc.

• Pour retourner plusieurs valeurs depuis une fonction

• Plus clair que retourner une liste de 2-3 éléments

• Le déballage x, y = fonction() est naturel

• Pour garantir que des données ne seront pas modifiées accidentellement

• Constantes, configurations, paramètres immuables

• Protection contre les bugs de modification

• Comme clés de dictionnaires (si le tuple ne contient que des objets immuables)

• {(x, y): valeur} pour des coordonnées

• Impossible avec des listes car non-hashables

• Pour des raisons de performance quand la mutabilité n'est pas nécessaire

• Économie mémoire et vitesse légèrement supérieure

• Important dans les boucles ou gros volumes de données

Page 12 sur 13
 Cours Python By Niaina Nomenjanahary 2025

Exercices pratiques
💡 Exercices pour maîtriser les tuples :

1. Statistiques de tuple : Écrivez une fonction qui prend un tuple de nombres et retourne le
minimum, le maximum et la moyenne dans un nouveau tuple.
python # Exemple : stats((1, 5, 3, 9, 2)) → (1, 9, 4.0)

2. Répertoire avec tuples nommés : Créez un répertoire téléphonique en utilisant des tuples
nommés pour représenter les contacts (nom, téléphone, email). Implémentez des fonctions pour
ajouter, rechercher et afficher les contacts.
python # Utilisez namedtuple pour créer Contact(nom, telephone, email)

3. Tri par note : Écrivez une fonction qui prend une liste de tuples (nom, note) et renvoie une
liste triée par note (de la plus élevée à la plus basse).
python # Exemple : [("Alice", 15), ("Bob", 18), ("Charlie", 12)] → [("Bob",
18), ("Alice", 15), ("Charlie", 12)]

4. Séparation de coordonnées : Transformez une liste de coordonnées [(x1, y1), (x2,

y2), ...] en deux listes séparées de coordonnées x et y. Indice : utilisez la fonction zip()
et le déballage de tuples.
python # Exemple : [(1, 2), (3, 4), (5, 6)] → [1, 3, 5], [2, 4, 6]

Prochaine étape
Dans la section suivante, nous explorerons les dictionnaires, une structure de données associative
qui permet de stocker des paires clé-valeur.

Page 13 sur 13