Types construits : p-uplets, tableaux, dictionnaires

Un entier, un flottant, un booléen, une chaîne : avec les types de base, une variable contient une seule valeur.

Or un programme manipule sans cesse des groupes de valeurs : les coordonnées d'un point, les notes d'une classe, la fiche d'un élève.

Les types construits assemblent plusieurs valeurs en une seule. Python en propose trois, qui répondent à trois besoins différents.

1. Les p-uplets

1.1 Regrouper des valeurs

>>> point = (3, 5)
>>> date = (14, 7, 1789)
>>> point[0]
3
>>> date[2]
1789
>>> len(date)
3

Un couple est un p-uplet de $2$ valeurs, un triplet en contient $3$.

>>> point = (3, 5)
>>> point[0] = 4
Traceback (most recent call last):
  File "<console>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment
>>> point = (4, 5)

1.2 Une fonction qui renvoie plusieurs valeurs

C'est l'usage principal des p-uplets.

L'instruction return a, b renvoie le couple (a, b), que l'on peut déballer dans deux variables d'un seul coup.

def min_max(t):
    """Renvoie le plus petit et le plus grand élément d'un tableau non vide."""
    mini = t[0]
    maxi = t[0]
    for x in t:
        if x < mini:
            mini = x
        if x > maxi:
            maxi = x
    return mini, maxi

petit, grand = min_max([12, 7, 15, 9, 18])
print("plus petite note :", petit)
print("plus grande note :", grand)

Essaie avec d'autres notes, puis affiche directement min_max([4, 4, 4]) : tu verras les parenthèses du couple.

De la même façon, la fonction divmod(17, 5) renvoie (3, 2) : le quotient et le reste de la division de $17$ par $5$.

def extremites(t):
    # à toi : renvoie le premier et le dernier élément
    return

1.3 Quand les positions ne suffisent plus

Dans date = (14, 7, 1789), il faut se souvenir que la position $2$ est l'année.

Avec dix champs, le code devient illisible.

On préfère alors donner un nom à chaque valeur : c'est le rôle du dictionnaire, présenté dans la partie 3.

2. Les tableaux

2.1 Tableau indexé

>>> notes = [12, 7, 15, 9, 18]
>>> notes[0]
12
>>> notes[4]
18
>>> len(notes)
5

Contrairement au p-uplet, un tableau est modifiable : on change une case avec t[i] = valeur.

notes = [12, 7, 15, 9, 18]

i = 2
print("notes[", i, "] =", notes[i])

# on modifie la case i
notes[i] = 20
print(notes)

Remplace i par $4$, puis par $5$ : que se passe-t-il ? Essaie aussi i = -1.

2.2 Parcourir un tableau

Il y a deux façons de parcourir un tableau, et il faut savoir choisir.

# Quand on n'a pas besoin de la position
notes = [12, 7, 15, 9, 18]
total = 0
for note in notes:
    total = total + note

# Quand on modifie le tableau, ou qu'on a besoin de la position
notes = [12, 7, 15, 9, 18]
for i in range(len(notes)):
    if notes[i] < 10:
        notes[i] = notes[i] + 1

Voici un comptage, écrit avec un parcours par les éléments.

def compte_pairs(t):
    n = 0
    for x in t:
        if x % 2 == 0:
            n = n + 1
    return n

print(compte_pairs([12, 7, 15, 8, 18]))

Les algorithmes à savoir écrire avec un parcours : somme, moyenne, maximum, recherche d'un élément, comptage des éléments qui vérifient une condition.

def moyenne(t):
    total = 0
    # à toi : ajoute chaque élément à total
    return total

2.3 Construire un tableau

Il existe quatre façons de construire un tableau.

• Par énumération : t = [1, 2, 3], et t = [] pour un tableau vide.
• Par répétition : [0] * 5 donne [0, 0, 0, 0, 0].
• Par ajouts successifs : t.append(x) ajoute x à la fin.
• Par compréhension, en une seule ligne.

notes = [12, 7, 15, 8, 18]

carres = [i * i for i in range(6)]
pairs = [x for x in notes if x % 2 == 0]
doubles = [2 * x for x in notes]

print(carres)
print(pairs)
print(doubles)

Modifie la condition pour ne garder que les notes supérieures ou égales à $10$.

2.4 Tableaux de tableaux : les matrices

Un tableau dont les éléments sont eux-mêmes des tableaux représente une grille : une matrice, une image, un plateau de jeu.

m[i] est la ligne $i$, et m[i][j] est l'élément de la ligne $i$ et de la colonne $j$.

>>> m = [[3, 8, 1, 6],
...      [5, 2, 9, 4],
...      [7, 0, 3, 8]]
>>> m[1]
[5, 2, 9, 4]
>>> m[1][2]
9
>>> len(m)
3
>>> len(m[0])
4

Retiens l'ordre : la ligne d'abord, la colonne ensuite.

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

i = 1      # la ligne
j = 2      # la colonne
print(m[i][j])

Cherche la valeur $0$, puis le dernier $8$. Que se passe-t-il si tu inverses les rôles, avec i = 2 et j = 3, puis i = 3 et j = 2 ?

Pour parcourir toute la grille, il faut deux boucles imbriquées : une pour les lignes, une pour les colonnes.

def somme_matrice(m):
    total = 0
    for i in range(len(m)):
        for j in range(len(m[i])):
            total = total + m[i][j]
    return total

m = [[3, 8, 1, 6],
     [5, 2, 9, 4],
     [7, 0, 3, 8]]
print(somme_matrice(m))

Vérifie-le toi-même : une seule case est modifiée, mais regarde l'affichage.

piege = [[0] * 4] * 3
piege[0][0] = 1
print(piege)

grille = [[0] * 4 for i in range(3)]
grille[0][0] = 1
print(grille)

3. Les dictionnaires

3.1 Clés et valeurs

Un dictionnaire représente naturellement un enregistrement dont les champs portent un nom : c'est le p-uplet nommé annoncé dans la partie 1.

>>> eleve = {"nom": "Diallo", "prenom": "Aïcha", "age": 16}
>>> eleve["age"]
16
>>> eleve["age"] = 17
>>> eleve["ville"] = "Lyon"
>>> eleve
{'nom': 'Diallo', 'prenom': 'Aïcha', 'age': 17, 'ville': 'Lyon'}
>>> "nom" in eleve
True
>>> len(eleve)
4

La même écriture d[cle] = valeur modifie l'entrée si la clé existe, et la crée sinon.

Un dictionnaire vide s'écrit d = {}.

eleve = {"nom": "Diallo", "prenom": "Aïcha", "age": 16}

eleve["ville"] = "Lyon"          # nouvelle clé : l'entrée est créée
eleve["age"] = eleve["age"] + 1  # clé existante : l'entrée est modifiée
print(eleve)

print("taille" in eleve)

Ajoute la ligne print(eleve["taille"]) et relance : tu obtiens la KeyError annoncée.

3.2 Parcourir un dictionnaire

Il y a trois parcours possibles, selon ce dont on a besoin.

for cle in eleve.keys():
    print(cle)

# On peut écrire plus simplement : for cle in eleve

for valeur in eleve.values():
    print(valeur)

for cle, valeur in eleve.items():
    print(cle, ":", valeur)

Les entrées sont parcourues dans l'ordre où elles ont été ajoutées.

eleve = {"nom": "Diallo", "prenom": "Aïcha", "age": 16, "specialite": "NSI"}

for cle, valeur in eleve.items():
    print(cle, ":", valeur)

3.3 Un classique : compter les occurrences

On veut savoir combien de fois chaque lettre apparaît dans un mot.

Le dictionnaire est l'outil idéal : la lettre est la clé, le nombre d'apparitions est la valeur.

def occurrences(texte):
    """Dictionnaire lettre -> nombre d'apparitions."""
    compte = {}
    for c in texte:
        if c in compte:
            compte[c] = compte[c] + 1
        else:
            compte[c] = 1
    return compte

print(occurrences("banane"))

def en_rupture(stock):
    articles = []
    # à toi : parcours les couples (article, quantité)
    return articles

3.4 Combiner les types

Les types construits se combinent librement.

Un tableau de dictionnaires représente une liste d'enregistrements : c'est une table de données, l'objet du chapitre suivant.

classe = [
    {"nom": "Diallo", "note": 15},
    {"nom": "Martin", "note": 12},
    {"nom": "Nguyen", "note": 17},
]

print(classe[1]["note"])

meilleurs = [e["nom"] for e in classe if e["note"] >= 14]
print(meilleurs)

Lis classe[1]["note"] de gauche à droite : l'élève d'index $1$, puis sa note.

4. Exemple résolu pas à pas

Cherche d'abord sur papier, puis déplie chaque correction et exécute-la.

def minimum(t):
    i_min = 0
    for i in range(len(t)):
        if t[i] < t[i_min]:
            i_min = i
    return t[i_min], i_min

jours = ["lun", "mar", "mer", "jeu", "ven", "sam", "dim"]
meteo = {}
for i in range(7):
    meteo[jours[i]] = temp[i]

for jour, t in meteo.items():
    if t > 22:
        print(jour)

Le programme complet, pour vérifier et expérimenter :

temp = [18, 21, 25, 19, 23, 27, 22]

chaudes = [x for x in temp if x > 20]
print(chaudes)

def minimum(t):
    i_min = 0
    for i in range(len(t)):
        if t[i] < t[i_min]:
            i_min = i
    return t[i_min], i_min

print(minimum(temp))

jours = ["lun", "mar", "mer", "jeu", "ven", "sam", "dim"]
meteo = {}
for i in range(7):
    meteo[jours[i]] = temp[i]

for jour, t in meteo.items():
    if t > 22:
        print(jour)

À retenir