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.

Qu’est-ce qu’un p-uplet ?

En mathématiques, un couple $(x, y)$ regroupe 2 éléments, un triplet $(x, y, z)$ en regroupe 3. Plus généralement, un ensemble ordonné de $p$ éléments s’appelle un p-uplet. En informatique et en Python, on utilise le terme anglais tuple.

En Python, on déclare un tuple en séparant ses éléments par des virgules, le plus souvent délimités par des parenthèses ( ) :

        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

Comme pour les chaînes de caractères (vues au chapitre 3-01), les éléments d’un tuple sont ordonnés et repérés par un index entier qui démarre toujours à 0.

On utilise la fonction len() pour connaître le nombre d’éléments dans un tuple :

        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 (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

A. Le déballage (unpacking)

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

        coordonnees = (48.8566, 2.3522)
        latitude, longitude = coordonnees  # Déballage
        print(f"Lat: {latitude}, Long: {longitude}")
    

B. 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)
                print(f"Périmètre = {p}, Aire = {a}")  # Périmètre = 16, Aire = 15
            

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

Tableaux vs Listes en Python

En informatique théorique, un tableau est une suite ordonnée de cases de taille déterminée dont tous les éléments ont le même type (ex : un tableau d’entiers ou un tableau de flottants). En Python, ce concept est implémenté par le type list, délimité par des crochets [ ].

        notes = [14, 18, 9, 12, 16]
        jours = ["Lundi", "Mardi", "Mercredi", "Jeudi", "Vendredi"]
    

Lecture et modification en place (mutabilité)

Contrairement aux tuples, les tableaux sont mutables : on peut modifier n’importe quel élément directement grâce à son index !

        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]
    

Les deux manières de parcourir un tableau

C’est un savoir-faire incontournable en NSI. Il existe deux façons de parcourir un tableau avec une boucle for :

                temperatures = [18.5, 21.0, 19.2]

                for temp in temperatures:
                    print(f"Température : {temp}°C")
            

                temperatures = [18.5, 21.0, 19.2]

                for i in range(len(temperatures)):
                    print(f"Jour {i} : {temperatures[i]}°C")
                    temperatures[i] += 1.0 # Modifie la valeur !
            

Construire un tableau

A. Par répétition (tableau de taille fixe)

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]
    

B. 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 moderne 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]
    

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 for col in range(3)] for ligne in range(3)]
        

                t = [5, 10, 15, 20]
                for i in range(len(t)):
                    t[i] = t[i] * 2
                print(t)  # [10, 20, 30, 40]
            

                # Puissances de 2 de 2^0 à 2^7 :
                puissances = [2**i for i in range(8)]
                # Résultat : [1, 2, 4, 8, 16, 32, 64, 128]

                # Multiples de 5 entre 0 et 50 :
                multiples = [n for n in range(51) if n % 5 == 0]
            

                # a. Création propre par compréhension
                plateau = [[" " for j in range(3)] for i in range(3)]

                # b. Centre (ligne 1, colonne 1)
                plateau[1][1] = "X"

                # c. Coin inférieur droit (ligne 2, colonne 2)
                plateau[2][2] = "O"
            

• Construire et modifier un dictionnaire (clés et valeurs).
• Modéliser un enregistrement (p-uplet nommé).
• 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 un tableau, on accède aux cases par un numéro (0, 1, 2…). Mais dans la vraie vie, 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"]
    

            if "vitesse" in joueur:
                print(joueur["vitesse"])
            else:
                print("Ce joueur n’a pas de caractéristique de vitesse.")
        

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}")
    

                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"))