Programmation Python — Séance 2 : Structures de données

Une liste est une collection ordonnée et modifiable de valeurs, écrite entre crochets [ ].

Télécharger le notebook Ouvrir dans Colab Les sorties sont celles enregistrées dans le notebook : rien n'est réexécuté.

DMI · FST · UCAD

On sait manipuler des valeurs isolées. Cette séance regroupe plusieurs valeurs dans une même structure : listes, tuples, dictionnaires, ensembles, puis les compréhensions. Exécutez chaque cellule avec Maj + Entrée. Les cellules À vous sont à compléter.

1. Les listes

Une liste est une collection ordonnée et modifiable de valeurs, écrite entre crochets [ ]. On y accède par position, exactement comme pour les chaînes : l’indice commence à 0, et -1 désigne le dernier.

villes = ["Dakar", "Louga", "Mbour", "Kaolack"]
print(villes)
print("nombre :", len(villes))
print("premiere :", villes[0])
print("derniere :", villes[-1])
print("tranche  :", villes[1:3])

['Dakar', 'Louga', 'Mbour', 'Kaolack']
nombre : 4
premiere : Dakar
derniere : Kaolack
tranche  : ['Louga', 'Mbour']

À vous. Créez une liste prenoms contenant trois prénoms, puis affichez le premier et le dernier.

# À vous : créez prenoms (trois prénoms), puis affichez le premier [0] et le dernier [-1]

Contrairement à une chaîne, une liste est modifiable : on peut remplacer un élément, en ajouter à la fin avec .append(), ou en insérer à une position avec .insert().

villes[0] = "Thies"
villes.append("Touba")
villes.insert(1, "Saint-Louis")
print(villes)

['Thies', 'Saint-Louis', 'Louga', 'Mbour', 'Kaolack', 'Touba']

À vous. Ajoutez la ville "Ziguinchor" à la fin de villes avec .append(), puis affichez la liste.

# À vous : ajoutez "Ziguinchor" à la fin de villes avec .append(), puis affichez villes

On retire un élément par sa valeur avec .remove(), ou par sa position avec .pop() (qui renvoie l’élément retiré).

villes.remove("Touba")
dernier = villes.pop()
print("retire :", dernier)
print(villes)

retire : Kaolack
['Thies', 'Saint-Louis', 'Louga', 'Mbour']

Quelques outils fréquents : .sort() trie la liste, len() compte les éléments, et in teste la présence d’une valeur.

nombres = [5, 2, 8, 1]
nombres.sort()
print(nombres)
print("taille :", len(nombres))
print(8 in nombres)

[1, 2, 5, 8]
taille : 4
True

Attention : .sort() modifie la liste en place et ne renvoie rien (None). Il ne faut donc pas écrire nombres = nombres.sort().

valeurs = [3, 1, 2]
resultat = valeurs.sort()
print("renvoye par sort() :", resultat)
print("liste triee        :", valeurs)

renvoye par sort() : None
liste triee        : [1, 2, 3]

À vous. Créez une liste notes de quatre nombres, triez-la avec .sort(), puis affichez-la.

# À vous : créez notes (quatre nombres), triez avec .sort(), puis affichez notes

2. Les tuples

Un tuple est une collection ordonnée mais figée : une fois créé, on ne peut plus le modifier. On l’écrit entre parenthèses ( ). Il sert à représenter un groupe de valeurs qui vont ensemble (des coordonnées, par exemple).

coord = (14.69, -17.44)
print(coord)
print("latitude  :", coord[0])
print("longitude :", coord[1])

(14.69, -17.44)
latitude  : 14.69
longitude : -17.44

On peut déballer un tuple dans plusieurs variables en une seule ligne (c’est le unpacking).

latitude, longitude = coord
print("lat =", latitude)
print("lon =", longitude)

lat = 14.69
lon = -17.44

À vous. Créez un tuple personne contenant un prénom et un âge, puis déballez-le dans deux variables prenom et age que vous afficherez.

# À vous : créez le tuple personne = (prenom, age), déballez-le dans prenom, age puis affichez-les

3. Les dictionnaires

Un dictionnaire associe des clés à des valeurs, entre accolades { }. On n’accède plus par position mais par clé. C’est la structure idéale pour décrire un objet par ses attributs.

patient = {"nom": "Fatou", "age": 30, "ville": "Dakar"}
print(patient)
print("nom   :", patient["nom"])
print("ville :", patient["ville"])

{'nom': 'Fatou', 'age': 30, 'ville': 'Dakar'}
nom   : Fatou
ville : Dakar

À vous. Créez un dictionnaire etudiant avec les clés "nom" et "age", puis affichez la valeur associée à "nom".

# À vous : créez etudiant = {"nom": ..., "age": ...}, puis affichez etudiant["nom"]

On ajoute ou modifie une valeur en affectant une clé. Si la clé existe, elle est mise à jour ; sinon elle est créée.

patient["tel"] = "77 123 45 67"
patient["age"] = 31
print(patient)

{'nom': 'Fatou', 'age': 31, 'ville': 'Dakar', 'tel': '77 123 45 67'}

Accéder à une clé absente provoque une erreur. La méthode .get(cle, defaut) renvoie une valeur par défaut au lieu de planter, et in teste la présence d’une clé.

print(patient.get("email", "non renseigne"))
print("nom" in patient)
print("email" in patient)

non renseigne
True
False

À vous. Avec .get(), affichez la valeur de la clé "pays" (absente) en renvoyant "inconnu" par défaut.

# À vous : affichez patient.get("pays", "inconnu")

Enfin, .keys(), .values() et .items() donnent respectivement les clés, les valeurs, et les couples clé-valeur.

print(patient.keys())
print(patient.values())
print(patient.items())

dict_keys(['nom', 'age', 'ville', 'tel'])
dict_values(['Fatou', 31, 'Dakar', '77 123 45 67'])
dict_items([('nom', 'Fatou'), ('age', 31), ('ville', 'Dakar'), ('tel', '77 123 45 67')])

4. Les ensembles

Un ensemble (set) est une collection non ordonnée et sans doublons, écrite entre accolades { }. Il sert à éliminer les répétitions et à tester très vite l’appartenance. Comme l’ordre n’est pas garanti, on affiche son contenu trié avec sorted().

liste = ["Dakar", "Louga", "Dakar", "Mbour", "Louga"]
uniques = set(liste)
print("nombre d'uniques :", len(uniques))
print("contenu trie     :", sorted(uniques))
print("Dakar present ?  :", "Dakar" in uniques)

nombre d'uniques : 3
contenu trie     : ['Dakar', 'Louga', 'Mbour']
Dakar present ?  : True

On combine deux ensembles avec | (union : tout) et & (intersection : les communs).

a = {"Dakar", "Thies", "Louga"}
b = {"Louga", "Mbour", "Dakar"}
print("union        :", sorted(a | b))
print("intersection :", sorted(a & b))

union        : ['Dakar', 'Louga', 'Mbour', 'Thies']
intersection : ['Dakar', 'Louga']

À vous. À partir de la liste notes = [12, 15, 12, 18, 15], construisez un ensemble pour retirer les doublons, puis affichez son contenu trié avec sorted().

# À vous : construisez set(notes) pour retirer les doublons, puis affichez sorted(...)

5. Les compréhensions

Une compréhension de liste construit une liste de façon concise, en une ligne, à partir d’une autre collection. La forme est : [ expression for element in collection ]. (La boucle for complète est détaillée en Séance 3 ; ici, on l’utilise seulement dans cette écriture compacte.)

nombres = [1, 2, 3, 4]
doubles = [n * 2 for n in nombres]
print(doubles)

[2, 4, 6, 8]

À vous. Construisez la liste des carrés des nombres [1, 2, 3, 4, 5] avec une compréhension.

# À vous : carres = [ ... for n in [1, 2, 3, 4, 5] ], puis affichez carres

On peut filtrer en ajoutant une condition if à la fin : seuls les éléments qui la vérifient sont gardés.

villes = ["Dakar", "Saint-Louis", "Mbour", "Ziguinchor", "Louga"]
longues = [v for v in villes if len(v) > 5]
print(longues)

['Saint-Louis', 'Ziguinchor']

À vous. À partir de valeurs = [4, 9, 2, 7, 1, 8], gardez avec une compréhension uniquement les nombres supérieurs à 5.

# À vous : grands = [ v for v in [4, 9, 2, 7, 1, 8] if ... ], puis affichez grands

Récapitulatif

Structure	Syntaxe	Accès	Modifiable	Doublons
Liste	`[ ]`	par indice	oui	autorisés
Tuple	`( )`	par indice	non (figé)	autorisés
Dictionnaire	`{cle: valeur}`	par clé	oui	clés uniques
Ensemble	`{ }` / `set()`	sans indice	oui	interdits

Liste : collection ordonnée et modifiable ; .append, .insert, .remove, .pop, .sort (en place, renvoie None).
Tuple : comme une liste mais figé ; pratique pour un groupe de valeurs et le unpacking.
Dictionnaire : clé → valeur ; accès d[cle], .get, in, .keys/.values/.items.
Ensemble : valeurs uniques, non ordonnées ; | union, & intersection.
Compréhension : [expression for element in collection if condition].

Prochaine séance — S3 : le contrôle du flux (if/elif/else, boucles for/while).

Retour au sommet