Fiche de révision - Représentation des données : types construits¶

1. Les p-uplets (tuples)¶

Collection ordonnée et immuable (non modifiable)
Syntaxe : (a, b, c) ou a, b, c
Tuple d'un élément : (42,) (avec la virgule)

Opérations :

Opération	Syntaxe
Accès par indice	`t[0]`, `t[-1]`
Longueur	`len(t)`
Déballage	`x, y = (3, 7)`
Appartenance	`x in t`
Concaténation	`t1 + t2`

Usage principal : renvoyer plusieurs valeurs depuis une fonction.

def division(a, b):
    return (a // b, a % b)

q, r = division(17, 5)    # q = 3, r = 2

P-uplet nommé : namedtuple permet un accès par nom (e.prenom) au lieu de l'indice.

2. Les tableaux (listes Python)¶

Collection ordonnée et modifiable (mutable)
En NSI : éléments du même type
Syntaxe : [a, b, c]

Opérations courantes :

Opération	Syntaxe
Accès / modification	`t[i]`, `t[i] = x`
Ajout à la fin	`t.append(x)`
Insertion	`t.insert(i, x)`
Suppression	`t.pop()`, `t.pop(i)`, `t.remove(x)`
Longueur	`len(t)`
Tri	`t.sort()` ou `sorted(t)`
Tranche	`t[1:3]`, `t[:3]`, `t[2:]`

Parcours :

for element in tableau:       # par élément (lecture)
for i in range(len(tableau)): # par indice (modification)
for i, x in enumerate(tableau): # indice + valeur

Compréhension de liste :

[expression for x in iterable]            # construction
[expression for x in iterable if cond]     # avec filtre

Exemples :

[x ** 2 for x in range(5)] → [0, 1, 4, 9, 16]
[x for x in t if x > 0] → les positifs de t

3. Les matrices (tableaux de tableaux)¶

Un tableau de tableaux représente une grille 2D
Accès : matrice[ligne][colonne]

m = [[1, 2], [3, 4], [5, 6]]
m[0][1]    # ligne 0, colonne 1 → 2

Création par compréhension :

zeros = [[0 for j in range(colonnes)] for i in range(lignes)]

Attention

Ne pas écrire [[0] * n] * m : les lignes seraient le même objet en mémoire.

4. Les dictionnaires¶

Collection de paires clé : valeur
Accès par nom (la clé), pas par indice
Syntaxe : {"cle": valeur, ...}

Opérations courantes :

Opération	Syntaxe
Accès	`d["cle"]` ou `d.get("cle", defaut)`
Ajout / modification	`d["cle"] = valeur`
Suppression	`del d["cle"]` ou `d.pop("cle")`
Test d'existence	`"cle" in d`
Nombre d'entrées	`len(d)`

Parcours :

for cle in d:                  # clés
for valeur in d.values():      # valeurs
for cle, valeur in d.items():  # clés + valeurs

Compréhension : {k: v for k, v in ...}

Clés : doivent être immuables (str, int, tuple). Les listes et dictionnaires ne peuvent pas servir de clé.

5. Copie de tableaux¶

Syntaxe	Ce que ça fait
`b = a`	Alias (même objet, pas une copie)
`b = list(a)` ou `b = a[:]`	Copie (nouveau tableau)
`copy.deepcopy(a)`	Copie profonde (pour les matrices)

6. Comparaison des types construits¶

	Tuple	Tableau (`list`)	Dictionnaire (`dict`)
Syntaxe	`()`	`[]`	`{}`
Ordonné	Oui	Oui	Non
Modifiable	Non	Oui	Oui
Accès par	Indice	Indice	Clé
Types mélangés	Oui	Non (en NSI)	Oui
Usage	Données constantes	Collections	Associations clé-valeur

Vocabulaire essentiel¶

Terme	Définition rapide
p-uplet (tuple)	Collection ordonnée et immuable
Tableau (list)	Collection ordonnée et modifiable
Dictionnaire (dict)	Collection de paires clé-valeur
Immuable	Qui ne peut pas être modifié après création
Mutable	Qui peut être modifié (ajout, suppression, modification)
Indice	Position d'un élément (commence à 0)
Clé	Identifiant unique d'une entrée dans un dictionnaire
Compréhension	Syntaxe compacte pour construire un tableau ou dictionnaire
Matrice	Tableau de tableaux (grille 2D)
Déballage	Affectation de chaque élément d'un tuple à une variable
Alias	Deux variables qui pointent vers le même objet
Tranche (slice)	Extraction d'une partie d'un tableau (`t[i:j]`)