3-02. Structures de données en Python

• Définir et manipuler des p-uplets (tuples).
• Accéder aux éléments par indexation.
• Comprendre le principe d’immuabilité d’un tuple.
• Écrire une fonction renvoyant un p-uplet de valeurs.

Créer un tuple

				point = (4, 7)                # un couple (2-uplet)
				couleur_rgb = (255, 128, 0)   # un triplet (3-uplet)
				vide = ()                     # un tuple vide
				un_seul = (42,)               # attention à la virgule pour un singleton !
			

Indexation : accéder aux éléments

Les éléments d’un tuple sont ordonnés et repérés par un index entier qui démarre toujours à 0.

        perso = ("Gandalf", 2019, True)
        print(len(perso))     # Affiche 3
        print(perso[0])       # Affiche "Gandalf"
        print(perso[2])       # Affiche True
    

La propriété fondamentale : l’immuabilité

Un tuple est immuable (on utilise souvent le terme anglophone immutable) : une fois créé en mémoire, il est strictement impossible de modifier, ajouter ou supprimer un élément.

        point = (10, 25)
        point[0] = 12   # ❌ ERREUR : TypeError: 'tuple' object does not support item assignment
    

L’immuabilité est une sécurité formidable pour le développeur ! Quand vous passez des coordonnées géographiques ou des constantes de configuration à une fonction, vous avez la certitude absolue qu’aucune ligne de code ne pourra corrompre ou altérer ces valeurs par accident.

Déballage et retours multiples de fonctions

Le déballage (unpacking)

Python permet d’extraire d’un seul coup les valeurs d’un tuple dans des variables distinctes :

		coordonnees = (48.85, 2.35)
		latitude, longitude = coordonnees  # Déballage
		print(f"Lat: {latitude}, Long: {longitude}")
		# affiche "Lat: 48.85, Long: 2.35"
    

Renvoyer plusieurs valeurs dans une fonction

Au chapitre 1-01, vous avez vu qu’une fonction termine son exécution avec return. Mais comment renvoyer deux ou trois résultats à la fois ? On renvoie simplement un tuple !

        def division_euclidienne(a, b):
            quotient = a // b
            reste = a % b
            return (quotient, reste)  # Renvoie un 2-uplet

        q, r = division_euclidienne(17, 5)
        print(f"17 = 5 × {q} + {r}")  # Affiche : 17 = 5 × 3 + 2
    

                def geometrie_rectangle(largeur, hauteur):
                    perimetre = 2 * (largeur + hauteur)
                    aire = largeur * hauteur
                    return (perimetre, aire)
            

                p, a = geometrie_rectangle(5, 3)
            

• Lire et modifier les éléments d’une liste grâce à leurs index.
• Itérer sur une liste (par élément ou par indice).
• Construire une liste par répétition et par compréhension.
• Manipuler des tableaux à deux dimensions (matrices) avec la notation a[i][j].

Listes et tableaux en Python

En Python, les termes liste et tableau désignent exactement la même chose. Nous utiliserons donc indifféremment l'un ou l'autre de ces deux mots tout au long de l'année (les nuances théoriques entre ces deux notions seront abordées en classe de terminale).

Une liste (type list) est une suite ordonnée d'éléments délimitée par des crochets [ ], séparés par des virgules :

        notes = [14, 18, 9, 12, 16]  # Une liste d'entiers
        jours = ["Lundi", "Mardi", "Mercredi"] # Une liste de chaînes
        vide = []  # Une liste vide (très utile !)
    

Lecture et modification

Contrairement aux tuples, les tableaux sont mutables : on peut modifier des éléments, en ajouter et en supprimer.

		notes = [14, 18, 9, 12]
		print(notes[2])    # Affiche 9 (l’élément à l’index 2)

		notes[2] = 11      # On remplace 9 par 11
		print(notes)       # Affiche [14, 18, 11, 12]

		notes.append(17)   # Ajout d’un élément à la fin
		print(notes)       # Affiche [14, 18, 11, 12, 17]

		n = notes.pop(1)   # Supprime et renvoie notes[1] (n = 18)
		print(notes)       # Affiche [14, 11, 12, 17]

		d = notes.pop()    # Supprime et renvoie le dernier élément (d = 17)
		print(notes)       # Affiche [14, 11, 12]

		# Si on n’a pas besoin de récupérer l’élément supprimer :
		del notes[1]       # Supprime l’élément notes[1]
		# ou encore :
		notes.pop(1)       # On ne récupère pas l’élément renvoyé
    

Parcourir une liste

Il existe plusieurs façons de parcourir une liste avec une boucle for :

		temperatures = [18.5, 21.0, 19.2]

		for temp in temperatures:
			# temp prend successivement les valeurs de temperatures
			print(f"Température : {temp}°C")

		for i in range(len(temperatures)):
			# i varie entre 0 et le plus grand indice de temperatures
			print(f"Jour {i} : {temperatures[i]}°C")
			temperatures[i] += 1.0 # Modifie la valeur

		for i, temp in enumerate(temperatures):
			print(f"Index {i} : {temp}")
	

			"plat n°1 : ..."
			"plat n°2 : ..."
			etc.
		

Construire une liste

Par répétition

Pour créer un tableau d’une taille donnée contenant la même valeur initiale partout :

        zeros = [0] * 8       # [0, 0, 0, 0, 0, 0, 0, 0] (un octet initialisé à 0 !)
        cases = [False] * 5   # [False, False, False, False, False]
    

Construction par compréhension

La compréhension de tableau est une syntaxe très élégante et condensée propre à Python. Elle permet de construire un nouveau tableau en appliquant une formule mathématique ou un filtre en une seule ligne.

        # Méthode classique avec boucle
        carres = []
        for x in range(6):
            carres.append(x**2)

        # Méthode PAR COMPRÉHENSION
        carres = [x**2 for x in range(6)]
        # Résultat : [0, 1, 4, 9, 16, 25]
    

On peut également y ajouter une condition if de filtrage :

        # Ne garder que les nombres pairs :
        nombres = [1, 4, 9, 12, 15, 18, 20]
        pairs = [n for n in nombres if n % 2 == 0]
        # pairs vaut : [4, 12, 18, 20]
    

Appartenance

Lorsqu’on veut vérifier la présence d’un élément dans un liste, on utilise le mot-clé in, comme pour une chaîne de caractère.

		fruits = ["pomme", "banane", "mangue", "pêche"]
		# Tester si un élément est présent (renvoie un booléen) :
		print("banane" in fruits)  # True
		print("kiwi" in fruits)    # False
    

Concaténation (fusion de listes)

L’opérateur + entre deux listes (ou plus) renvoie une liste fusionnée contenant les éléments de toutes les listes concaténées.

		fruits1 = ["pomme", "banane", "mangue", "pêche"]
		fruits2 = ["poire", "cerise"]
		courses = fruits1 + fruits2 + ["abricot", "kiwi"]
		# courses = ["pomme", "banane", "mangue", "pêche", "poire", "cerise", "abricot", "kiwi"]
    

Indices négatifs et les slices

Python autorise les indices négatifs : -1 est le dernier élément, -2 l’avant-dernier, etc.

        fruits = ["pomme", "banane", "mangue", "pêche"]
        print(fruits[-1])  # 'pêche'
        print(fruits[-2])  # 'mangue'
    

Python permet également de prendre seulement des parties de liste (slice = tranche en anglais).

        fruits = ["pomme", "banane", "mangue", "pêche"]
		print(fruits[1:3])   # de 1 inclus à 3 exclus ["banane", "mangue"]
		print(fruits[2:])    # de 2 jusqu’à la fin
		print(fruits[:2])    # du début jusqu’à 2 exclus
		print(fruits[::-1])  # inverse l’ordre des éléments
    

			liste1 = [5, 3, 7, 8]
			liste2 = [11, 14, 16, 19]
    	

Tableaux à deux dimensions (matrices et grilles)

Pour représenter une grille de jeu, un plateau d’échecs ou une image bitmap en nuances de gris, on utilise un tableau de tableaux.

        grille = [
            [1, 2, 3],
            [4, 5, 6],
            [7, 8, 9]
        ]

        print(grille[1][2])   # Ligne index 1, Colonne index 2 ⟶ Affiche 6
        grille[0][0] = 99     # On modifie le coin haut gauche
    

            # ✅ Grille indépendante de 3 lignes et 3 colonnes :
            grille = [[0]*3 for ligne in range(3)]
        

• Construire et modifier un dictionnaire.
• Modéliser un enregistrement.
• Itérer sur un dictionnaire avec keys(), values() et items().
• Tester l’appartenance d’une clé avec l’opérateur in.

Associer une étiquette à une valeur

Dans une liste, on accède aux éléments par leur index (0, 1, 2…). Mais on préfère souvent retrouver une information par son nom (par exemple « taille », « prix », « score »).

Un dictionnaire (type dict en Python) stocke des associations clé : valeur. Il se déclare avec des accolades { } :

        # Dictionnaire modélisant un joueur
        joueur = {
            "pseudo": "PixelKnight",
            "niveau": 12,
            "classe": "Guerrier",
            "pv": 85
        }
    

Lire, modifier et ajouter des éléments

L’accès se fait en spécifiant la clé entre crochets : dico[cle].

        # 1. Lecture
        print(joueur["pseudo"]) # Affiche "PixelKnight"

        # 2. Modification d’une valeur existante
        joueur["pv"] = 100

        # 3. Ajout d'une NOUVELLE clé
        joueur["mana"] = 50  La clé n’existait pas, Python la crée automatiquement !

        # 4. Suppression
        del joueur["classe"]
    

Sécuriser l'accès et supprimer : in, get() et pop()

Tenter d’accéder à une clé inexistante (ex : joueur["vitesse"]) provoque une erreur bloquante KeyError. Il existe trois manières de gérer cela proprement :

		# 1. Vérifier la présence avec 'in' :
		if "vitesse" in joueur:
			print(joueur["vitesse"])

		# 2. Utiliser .get() avec valeur par défaut :
		# Renvoie None si la clé n'existe pas, ou la valeur de secours précisée
		vit = joueur.get("vitesse", 10)  # Renvoie 10 si "vitesse" n'est pas définie

		# 3. Supprimer et récupérer une valeur avec .pop() :
		niveau = joueur.pop("niveau") # Supprime "niveau" et stocke sa valeur
		# (on peut aussi utiliser 'del joueur["niveau"]'
		# si on ne veut pas récupérer la valeur)
    

Les 3 méthodes de parcours d’un dictionnaire

Pour parcourir un dictionnaire avec une boucle for, Python dispose de 3 méthodes fondamentales :

        inventaire = {"épée": 1, "potions": 5, "pièces": 120}

        # Afficher l'inventaire complet :
        for objet, quantite in inventaire.items():
            print(f"- {objet} : {quantite}")
    

Dictionnaires imbriqués (données structurées)

La valeur associée à une clé peut elle-même être un dictionnaire ! C'est la manière standard de représenter des bases de données complexes ou des fichiers de configuration.

        eleves = {
            "Alice": {"maths": 15, "nsi": 18},
            "Bob": {"maths": 12, "nsi": 14}
        }

        # Accès par clés successives :
        print(eleves["Alice"]["nsi"])  # Affiche 18

        # Modifier une note :
        eleves["Bob"]["maths"] = 13
    

			repertoire = {
				"Alice": {"classe": "1G1", "options": ["NSI", "Maths"]},
				"Bob": {"classe": "1G2", "options": ["NSI", "Physique"]}
			}
		

                scores["Bob"] += 10
                scores["Diane"] = 60
            

                def total_points(dico_scores):
                    total = 0
                    for s in dico_scores.values():
                        total += s
                    return total
            

                def compter_caracteres(texte):
                    occ = {}
                    for c in texte:
                        if c in occ:
                            occ[c] += 1
                        else:
                            occ[c] = 1
                    return occ

                print(compter_caracteres("bonne chance"))