Cours sur Python

Chapitre 1. Les Notions de base

A. Les variables et types
1️. Les Variables en Python

Une variable est un nom donné à un espace mémoire qui stocke une
valeur.

Syntaxe :

nom_variable = valeur
Exemples :

# Variable de type entier

age = 25

# Variable de type flottant

taille = 1.75

# Variable de type chaîne de caractères

nom = "Jean"

# Variable de type booléen

est_etudiant = True

Règles pour nommer une variable :

 Doit commencer par une lettre ou un underscore _

 Peut contenir des lettres, chiffres et underscores

 Ne doit pas être un mot réservé de Python (ex: if, for, while)

 Respecte la casse (Nom ≠ nom)

2️. Les Types de Données en Python

Chaque variable a un type, qui détermine les opérations possibles sur

cette variable.

Types principaux :

Typ
Exemple Description
e
Int age = 25 Entier
 float taille = 1.75 Nombre à virgule

Str nom = "Jean" Chaîne de caractères

bool est_etudiant = True Vrai ou faux

List fruits = ["pomme","banane"] Liste d’éléments

tuple coord = (10, 20) Liste immuable

Set nombres = {1,2,3} Ensemble d’éléments uniques

personne =
dict Dictionnaire (clé → valeur)
{"nom":"Jean","age":25}

Exemples d’utilisation des types :

# int + float
a = 5
b = 2.5
print(a + b) # 7.5

# str
prenom = "Jean"
print("Bonjour " + prenom) # Bonjour Jean

# bool
est_majeur = age >= 18
print(est_majeur) # True

✅ Résumé :

 Variable → espace mémoire pour stocker une valeur

 Type → définit la nature de la donnée et les opérations possibles

Parfait ! Voici un cours complet et structuré sur les conditions et les
boucles en Python, avec des exemples pratiques pour que tu puisses
bien comprendre et appliquer ces notions.

B. Les Conditions en Python

Les conditions permettent d’exécuter certaines instructions seulement si
une condition est vraie.

Syntaxe de base :

if condition:
# instructions si la condition est vraie
elif autre_condition:
# instructions si l'autre condition est vraie
else:
# instructions si aucune condition n'est vraie

Exemples :

age = 20

if age < 18:

print("Tu es mineur")
elif age == 18:
print("Tu viens juste d'être majeur")
else:
print("Tu es majeur")

✅ Explications :

 if vérifie la première condition.

 elif permet de vérifier une deuxième condition si la première est

fausse.

 else exécute le bloc si toutes les conditions précédentes sont

fausses.

Opérateurs logiques et de comparaison

Opérate
Exemple Signification
urs
 == x == y égal à

!= x != y différent de

< x<y inférieur à

> x>y supérieur à

inférieur ou
<= x <= y
égal
supérieur ou
>= x >= y
égal
x > 0 and x
and et
< 10
x < 0 or x >
or ou
10
not not x négation

Exemple avancé :

age = 25
est_etudiant = True

if age >= 18 and est_etudiant:

print("Tu es un étudiant adulte")
else:
print("Tu n'es pas un étudiant adulte")

Vérification d’appartenance avec in

fruits = ["pomme", "banane", "orange"]

if "pomme" in fruits:
print("Pomme est dans la liste")
else:
print("Pomme n'est pas dans la liste")

Conditions ternaires (compactes)

Python permet d’écrire une condition simple sur une seule ligne :

age = 20
message = "Majeur" if age >= 18 else "Mineur"
print(message)

Comparaison entre plusieurs variables

a = 10
b = 5
c = 8

if a > b and a > c:

print("a est le plus grand")
elif b > c:
print("b est le plus grand")
else:
print("c est le plus grand")

C. Les Boucles en Python

Les boucles permettent de répéter des instructions plusieurs fois.

Boucle for
Syntaxe :

for variable in iterable:

# instructions

Exemple avec une liste :

fruits = ["pomme", "banane", "orange"]

for f in Fruits:
print(f)

Exemple avec range() :

for i in range(5):
print(i) # Affiche 0,1,2,3,4

✅ Explications :

 range(n) génère les nombres de 0 à n-1.

 On peut préciser un début, une fin et un pas : range(2, 10, 2) → 2, 4,

6, 8
Boucle while
Syntaxe :

while condition:
# instructions tant que la condition est vraie

Exemple :

compteur = 0
while compteur < 5:
print(compteur)
compteur += 1

✅ Explications :

 while continue tant que la condition est vraie.

 Il faut penser à modifier la variable testée (compteur += 1) pour

éviter une boucle infinie.

Les instructions break et continue

 break : quitte la boucle immédiatement.

 continue : passe directement à l’itération suivante.

Exemple :

for i in range(1, 10):

if i == 5:
break # quitte la boucle
print(i)

for i in range(1, 10):

if i % 2 == 0:
continue # saute les nombres pairs
print(i) # affiche seulement les nombres impairs

Boucle avec else

Python permet un else après une boucle qui s’exécute si la boucle n’a
pas été interrompue par break.
for i in range(1, 5):
print(i)
else:
print("La boucle s'est terminée sans break")

Exemple combiné : conditions + boucles

# Jeu simple : deviner un nombre
import random

nombre_secret = [Link](1, 5)
essais = 0

while True:
choix = int(input("Devine un nombre entre 1 et 5 : "))
essais += 1
if choix == nombre_secret:
print(f"Bravo ! Tu as trouvé en {essais} essais")
break
elif choix < nombre_secret:
print("Plus grand !")
else:
print("Plus petit !")

✅ Résumé :

 Conditions (if/elif/else) → prendre des décisions selon des critères.

 Boucles for et while → répéter des instructions.

 break et continue → contrôler le flux d’une boucle.

 else dans une boucle → s’exécute si la boucle se termine

normalement.

[Link] fonctions
Qu’est-ce qu’une fonction ?
Une fonction est un bloc de code réutilisable qui effectue une tâche
spécifique.
Elle permet de :

 Organiser le code

 Éviter les répétitions

  Faciliter la lecture et la maintenance du code

Définir une fonction

Syntaxe de base :

def nom_de_fonction(parametre1, parametre2):

# bloc de code
return resultat # facultatif

 def → mot-clé pour définir une fonction

 nom_de_fonction → nom choisi (doit respecter les règles des

variables)

 parametre1, parametre2 → valeurs que la fonction reçoit (facultatif)

 return → renvoie une valeur (facultatif)

Exemple simple
def saluer():
print("Bonjour !")

# Appeler la fonction
saluer()

Résultat : Bonjour !

Fonctions avec paramètres

def saluer_personne(nom):
print(f"Bonjour {nom} !")

saluer_personne("Jean") # Bonjour Jean !

 Les paramètres permettent de personnaliser la fonction.

 Les arguments sont les valeurs que l’on passe à la fonction.

Fonctions avec valeur de retour

def addition(a, b):
return a + b

resultat = addition(5, 3)
print(resultat) # 8

✅ Explications :

 return renvoie une valeur qui peut être stockée dans une variable.

 Si return n’est pas présent, la fonction renvoie None.

Paramètres par défaut

On peut donner une valeur par défaut à un paramètre si l’utilisateur ne le
fournit pas :

def saluer(nom="ami"):
print(f"Bonjour {nom} !")

saluer() # Bonjour ami !

saluer("Alice") # Bonjour Alice !

Paramètres variables
*args → arguments multiples positionnels

Permet de passer un nombre variable d’arguments :

def somme(*nombres):
total = 0
for n in nombres:
total += n
return total

print(somme(1, 2, 3, 4)) # 10

**kwargs → arguments nommés multiples

Permet de passer un nombre variable d’arguments nommés :

def infos_personne(**infos):
for clé, valeur in [Link]():
print(clé, ":", valeur)
infos_personne(nom="Jean", age=22, ville="Kinshasa")

Fonctions lambda (fonction anonyme)

 Les fonctions lambda sont des fonctions simples sur une seule
ligne :

carre = lambda x: x**2

print(carre(5)) # 25

 Elles sont utiles pour des fonctions courtes utilisées une seule fois,
souvent avec map, filter, ou sorted.

Fonctions imbriquées
On peut définir une fonction à l’intérieur d’une autre fonction :

def fonction_externe(x):
def fonction_interne(y):
return y + 1
return fonction_interne(x) * 2

print(fonction_externe(5)) # 12

Résumé des points clés

 Définition : def nom_fonction(paramètres):

 Appel d’une fonction : nom_fonction(arguments)

 Retourner une valeur : return

 Paramètres :

o Paramètres normaux

o Paramètres par défaut

o *args pour multiples arguments

o **kwargs pour multiples arguments nommés

 Fonctions lambda → fonction courte et anonyme

 Fonctions imbriquées → fonction définie à l’intérieur d’une autre

fonction
 E. La gestion des erreur try/expt, else, finally
e.1. Pourquoi gérer les erreurs ?
En Python, certaines opérations peuvent provoquer des erreurs
(exceptions) :

 Division par zéro

 Accès à un index inexistant

 Ouverture d’un fichier inexistant

 Conversion de type invalide

Sans gestion, l’erreur arrête le programme.

La gestion des erreurs permet de prévenir les plantages et de réagir
intelligemment.

e.2. Structure de base : try/ except

try:
# code qui peut provoquer une erreur
except TypeErreur:
# code exécuté si l'erreur se produit

Exemple :

try:
a = int(input("Entrez un nombre : "))
resultat = 10 / a
except ValueError:
print("Erreur : ce n'est pas un nombre valide !")
except ZeroDivisionError:
print("Erreur : division par zéro !")

e.3. Capturer toutes les exceptions

try:
a = int(input("Entrez un nombre : "))
resultat = 10 / a
except Exception as e:
print("Une erreur est survenue :", e)
✅ Explications :

 Exception capture toutes les exceptions.

 as e permet d’afficher le message exact de l’erreur.

e.4. else : exécuter si aucune erreur

try:
a = int(input("Entrez un nombre : "))
resultat = 10 / a
except ZeroDivisionError:
print("Division par zéro interdite !")
else:
print("Le résultat est :", resultat)

✅ Explications :

 Le bloc else est exécuté uniquement si aucune exception ne se

produit.

e.5. finally : toujours exécuter

try:
fichier = open("[Link]", "r")
contenu = [Link]()
except FileNotFoundError:
print("Fichier non trouvé !")
finally:
print("Fin du programme")

✅ Explications :

 Le bloc finally est toujours exécuté, même si une erreur survient.

 Utile pour fermer un fichier ou une ressource.

e.6. Lever une exception avec raise

On peut provoquer une exception volontairement :

def division(a, b):

 if b == 0:
raise ValueError("b ne peut pas être zéro")
return a / b

try:
print(division(10, 0))
except ValueError as e:
print("Erreur :", e)

e.8. Exceptions personnalisées

On peut créer ses propres exceptions :

class ErreurPersonnalisee(Exception):
pass

def verifier_nombre(n):
if n < 0:
raise ErreurPersonnalisee("Le nombre ne peut pas être négatif")

try:
verifier_nombre(-5)
except ErreurPersonnalisee as e:
print("Erreur :", e)

e.9. Liste des exceptions courantes

Exception Description

ZeroDivisionEr
Division par zéro
ror

ValueError Valeur invalide (ex: int("abc"))

TypeError Type incompatible

IndexError Index inexistant dans une liste

Clé inexistante dans un

KeyError
dictionnaire

FileNotFoundE
Fichier introuvable
rror

e.10. Exemple complet pratique

try:
nombre = int(input("Entrez un nombre : "))
resultat = 10 / nombre
except ValueError:
print("Erreur : ce n'est pas un nombre valide !")
except ZeroDivisionError:
print("Erreur : division par zéro !")
else:
print("Résultat :", resultat)
finally:
print("Merci d'avoir utilisé le programme")

e.11. Bonnes pratiques

1. Ne jamais capturer toutes les exceptions sans raison except
(Exception)

2. Spécifier les exceptions pour savoir ce qui peut mal tourner

3. Utiliser finally pour libérer des ressources

4. Créer des exceptions personnalisées pour des situations spécifiques

 F. Les listes [] et les ensembles (sets) {}
 Les LISTES en Python
Définition

Une liste est une collection ordonnée, modifiable et qui peut contenir
différents types de données.

Exemples :

fruits = ["pomme", "banane", "orange"]

nombres = [1, 2, 3, 4, 5]
melange = ["texte", 10, True, 3.14]

Accéder aux éléments

Par index

Les index commencent à 0 :

print(fruits[0]) # pomme
print(fruits[2]) # orange

Index négatif

Permet d’accéder depuis la fin :

print(fruits[-1]) # orange

Modifier une liste

fruits[1] = "mangue"
print(fruits) # ['pomme', 'mangue', 'orange']

Ajouter des éléments

append() → ajoute à la fin :

[Link]("kiwi")

insert() → ajoute à une position spécifique :

[Link](1, "cerise")
extend() → ajoute plusieurs éléments :

[Link](["ananas", "melon"])

Supprimer des éléments

Métho
Description Exemple
de
remov [Link]("pom
Supprime par valeur
e() me")
Supprime par index (par défaut le
pop() [Link]()
dernier)
Supprime par index ou toute la
del del fruits[0]
liste

clear() Vide complètement la liste [Link]()

Parcourir une liste

for f in fruits:
print(f)

Tester la présence d’un élément

if "mangue" in fruits:
print("Oui, mangue est dans la liste")

Taille de la liste

print(len(fruits))

Trancher (slicing)

nombres = [0, 1, 2, 3, 4, 5, 6]
print(nombres[1:4]) # [1, 2, 3]
print(nombres[:3]) # [0, 1, 2]
print(nombres[-3:]) # [4, 5, 6]

Fonctions utiles

Fonction Description Exemple

 len(liste) longueur len(fruits)
trie sans modifier la sorted(fruits
sorted(liste)
liste )
[Link]() trie directement [Link]()
[Link]
[Link]() inverse l’ordre
e()
min(liste) / minimum / max(nombr
max(liste) maximum es)
somme des sum(nombr
sum(liste)
éléments es)

Les compréhensions de liste

Permettent de créer des listes en une seule ligne.

carres = [x**2 for x in range(6)]

print(carres) # [0, 1, 4, 9, 16, 25]
Avec condition :
pairs = [x for x in range(10) if x % 2 == 0]

Les ENSEMBLES (set)

Définition

Un set est une collection non ordonnée, non indexée, et qui ne

contient pas de doublons.

Exemples :

fruits = {"pomme", "banane", "orange"}

Propriétés d’un set

 Pas d’ordre (l’ordre d’affichage peut varier)

 Pas d’indexation (on ne peut pas faire fruits[0])

 Pas de doublons

doublons = {"a", "b", "a"}

print(doublons) # {'a', 'b'}
Ajouter des éléments

[Link]("mangue")

Ajouter plusieurs

[Link](["kiwi", "melon"])

Supprimer

[Link]("pomme") # Erreur si absent

[Link]("ananas") # Ne provoque pas d’erreur si absent
[Link]() # Vide tout le set

Opérations ensemblistes

Les set permettent d’utiliser les opérations mathématiques :

Exemp
Opération Symbole / Méthode
le
Union | [Link]() A|B

Intersection & ou .intersection() A&B

Différence - ou .difference() A-B

^
Différence
ou .symmetric_differenc A ^ B
symétrique
e()

Exemple :

A = {1, 2, 3, 4}
B = {3, 4, 5, 6}

print(A | B) # Union → {1, 2, 3, 4, 5, 6}

print(A & B) # Intersection → {3, 4}
print(A - B) # Différence → {1, 2}
print(A ^ B) # Différence symétrique → {1, 2, 5, 6}
Tester l’appartenance

if "pomme" in fruits:
print("Présent !")

Convertir entre types

liste = [1, 2, 2, 3]
ensemble = set(liste) # supprime les doublons
print(ensemble) # {1, 2, 3}

nouvelle_liste = list(ensemble)

Différences entre liste et set

Caractéristique Liste Set

Ordre Oui Non

Doublons Oui Non

Indexation Oui Non

Modifiable Oui Oui

Vitesse de Moyenn Rapid
recherche e e

Exemple pratique

nombres = [1, 2, 2, 3, 4, 4, 5]

# Supprimer les doublons avec set

unique = set(nombres)

# Reconvertir en liste triée

liste_finale = sorted(list(unique))

print(liste_finale) # [1, 2, 3, 4, 5]
 [Link] tuples ()
Qu’est-ce qu’un tuple ?

Un tuple est une structure de données ordonnée et immuable.

C’est comme une liste, mais on ne peut pas modifier son contenu
après création (ajouter, supprimer ou changer un élément).

Les tuples sont très utiles pour :

 Stocker des données constantes

 Protéger des valeurs contre toute modification

 Optimiser les performances (les tuples sont plus rapides que les
listes)

Créer un tuple

nombres = (10, 20, 30)

fruits = ("pomme", "banane", "orange")
melange = ("texte", 42, True, 3.14)

Important : Un tuple à un seul élément doit avoir une virgule, sinon

Python le considère comme une valeur ordinaire.

a = (5) # type int

b = (5,) # type tuple ✅

Accéder aux éléments

Comme les listes, les tuples sont ordonnés et indexés à partir de 0.

fruits = ("pomme", "banane", "orange")

print(fruits[0]) # pomme
print(fruits[-1]) # orange

Parcourir un tuple

Avec une boucle for :

for fruit in fruits:

 print(fruit)

Avec un index :

for i in range(len(fruits)):
print(i, fruits[i])

Les tuples sont immuables

Tu ne peux pas modifier un tuple directement :

fruits = ("pomme", "banane", "orange")

fruits[0] = "mangue" # ❌ Erreur : TypeError

Mais tu peux créer un nouveau tuple à partir d’un autre :

nouveau = fruits + ("kiwi",)

print(nouveau) # ('pomme', 'banane', 'orange', 'kiwi')

Opérations sur les tuples

Concaténation :

a = (1, 2)
b = (3, 4)
c = a + b
print(c) # (1, 2, 3, 4)

Répétition :

d = ("Hello",) * 3
print(d) # ('Hello', 'Hello', 'Hello')

Vérification d’appartenance :

if "banane" in fruits:
print("Oui, banane est là")

Longueur :

print(len(fruits)) # 3

Déballage de tuples (unpacking)

Tu peux extraire les valeurs d’un tuple dans des variables

distinctes :

personne = ("Jean", 22, "Kinshasa")

nom, age, ville = personne

print(nom) # Jean
print(age) # 22
print(ville) # Kinshasa

Avec un nombre variable d’éléments :

nombres = (1, 2, 3, 4, 5)
a, b, *reste = nombres
print(a, b, reste) # 1 2 [3, 4, 5]

Fonctions utiles

Fonction Description Exemple

len(t) longueur du tuple len(t)

min((3, 5, 1))
min(t) plus petit élément
→1
max((3, 5, 1))
max(t) plus grand élément
→5
somme (si valeurs sum((1,2,3))
sum(t)
numériques) →6
tuple(lis conversion d’une liste en
tuple([1,2,3])
te) tuple

Tuple imbriqué

Un tuple peut contenir d’autres tuples :

coordonnees = ((1, 2), (3, 4), (5, 6))

print(coordonnees[1][0]) # 3

Exemple pratique

Stocker les coordonnées GPS d’un lieu :

position = (4.321, 15.267)

print(f"Latitude : {position[0]}, Longitude : {position[1]}")
Retourner plusieurs valeurs depuis une fonction :

def calcul(a, b):

return a + b, a * b

somme, produit = calcul(3, 5)

print(somme, produit) # 8 15

[Link] Dictionnaire {clé : valeur}

Introduction

Un dictionnaire est une structure de données qui permet de stocker des

paires clé–valeur.
C’est un type mutable (modifiable) et non ordonné (jusqu’à Python 3.6,
depuis 3.7, l’ordre d’insertion est conservé).

Syntaxe générale :

mon_dict = {
"clé1": "valeur1",
"clé2": "valeur2"
}

Caractéristiques principales

 Les clés doivent être uniques et immutables (str, int, tuple…).

 Les valeurs peuvent être de n’importe quel type (nombre, liste,

dict, etc.).

 On accède aux valeurs via leur clé, pas par un index comme dans
une liste.

Création d’un dictionnaire

# Méthode 1 : avec des accolades

personne = {"nom": "Jean", "age": 25, "ville": "Kinshasa"}

# Méthode 2 : avec dict()

personne = dict(nom="Jean", age=25, ville="Kinshasa")

# Méthode 3 : dictionnaire vide

personne = {}

Accéder aux éléments

print(personne["nom"]) # → Jean
print([Link]("age")) # → 25

get() renvoie None si la clé n’existe pas, au lieu d’une erreur :

print([Link]("pays")) # → None

Ajouter ou modifier des éléments

personne["age"] = 30 # Modifie la valeur de la clé

"age"
personne["profession"] = "Dev Web" # Ajoute une nouvelle clé

Supprimer des éléments

del personne["ville"] # Supprime la clé "ville"

val = [Link]("age") # Supprime "age" et renvoie sa valeur
[Link]() # Vide tout le dictionnaire

Parcourir un dictionnaire

personne = {"nom": "Jean", "age": 25, "ville": "Kinshasa"}

# Parcourir les clés

for cle in personne:
print(cle)

# Parcourir les valeurs

for valeur in [Link]():
print(valeur)

# Parcourir les clés et valeurs

for cle, valeur in [Link]():
print(f"{cle} → {valeur}")

Fonctions et méthodes utiles

 Méthode /
Description Exemple
Propriété
Retourne toutes les [Link]() →
.keys()
clés du dictionnaire dict_keys(['nom', 'age'])
Retourne toutes les
[Link]() →
.values() valeurs du
dict_values(['Alice', 25])
dictionnaire
Retourne les paires [Link]() → [('nom',
.items()
(clé, valeur) 'Alice'), ('age', 25)]
Accède à une clé
[Link]('ville',
.get(cle, defaut) sans erreur si elle
'Inconnue') → 'Inconnue'
n’existe pas
Met à jour avec un [Link]({'age': 26})
.update(d2)
autre dictionnaire → {'nom': 'Alice', 'age': 26}
Supprime une clé et
.pop(cle, defaut) [Link]('age') → 25
retourne sa valeur
Supprime et
retourne la [Link]() → ('age',
.popitem()
dernière paire 25)
ajoutée
Retourne la valeur
.setdefault(cle, [Link]('ville',
d’une clé, ou la crée
defaut) 'Kinshasa')
si absente
Vide complètement
.clear() [Link]() → {}
le dictionnaire
Crée une copie
.copy() superficielle du copie = [Link]()
dictionnaire
Retourne le
len(dict) nombre len(personne) → 2
d’éléments
Vérifie la présence
in / not in "nom" in personne → True
d’une clé
.fromkeys(iterabl Crée un dict à partir [Link](['a','b'], 0) →
e, defaut) d’une liste de clés {'a': 0, 'b': 0}
dict Crée un dict en {x: x**2 for x in range(3)} →
comprehension compréhension {0: 0, 1: 1, 2: 4}

Imbrication de dictionnaires

Les dictionnaires peuvent contenir d’autres dictionnaires (très utile pour

structurer des données complexes) :

etudiants = {
 "Jean": {"age": 22, "filiere": "Informatique"},
"Alice": {"age": 21, "filiere": "Maths"},
}

print(etudiants["Jean"]["filiere"]) # → Informatique

Dictionnaire par compréhension (dict comprehension)

Une façon rapide de créer un dictionnaire avec une boucle :

cubes = {x: x**3 for x in range(5)}

print(cubes)
# → {0: 0, 1: 1, 2: 8, 3: 27, 4: 64}

Vérification d’existence

if "age" in personne:
print("La clé 'age' existe")

if "Jean" in [Link]():
print("Une valeur correspond à 'Jean'")

Copie et références

Copier un dictionnaire directement avec = ne crée pas une vraie copie :

a = {"x": 1}
b = a
b["x"] = 9
print(a) # → {'x': 9} car a et b pointent vers le même objet

#✅ Utiliser :
b = [Link]()

Utilisation avancée : dictionnaires par défaut

from collections import defaultdict

notes = defaultdict(list)
notes["Jean"].append(15)
notes["Jean"].append(17)
notes["Alice"].append(18)
print(dict(notes))
# → {'Jean': [15, 17], 'Alice': [18]}

Exemple complet

personne = {
"nom": "Jean",
"age": 25,
"ville": "Kinshasa",
"hobbies": ["code", "musique"]
}

# Modifier et afficher
personne["age"] = 26
for cle, valeur in [Link]():
print(f"{cle}: {valeur}")

# Supprimer un élément
del personne["ville"]

# Ajouter une nouvelle clé

personne["metier"] = "Développeur"

print(personne)

À retenir

 Un dictionnaire associe une clé unique à une valeur.

 Les dictionnaires sont dynamiques et mutables.

 Très utiles pour structurer des données ou représenter des objets.

 Les méthodes .items(), .get() et .update() sont essentielles à

maîtriser.

Comparaison entre les structures de données (listes,

tuples, set, dictionnaire)
Dictionnair
Critère List ([]) Tuple (()) Set ({}) e ({clé:
valeur})
Définition Collection Collection Collection non Collection
ordonnée et ordonnée et ordonnée, non
modifiable immuable unique et ordonnée
 modifiable de paires
d’éléments d’éléments
d’éléments clé/valeur
mon_dict =
ma_liste = [1, mon_tuple = (1, {"nom":
Syntaxe mon_set = {1, 2, 3}
2, 3] 2, 3) "Alice", "age":
25}
Non (depuis
Python 3.7, garde
Oui (depuis
un ordre
Python 3.7,
Ordre Oui Oui d’insertion, mais
garde ordre
non garanti pour
d’insertion)
opérations
ensemblistes)
Mutable
✅ Oui ❌ Non ✅ Oui ✅ Oui
(modifiable)
❌ Clés
uniques
Éléments
✅ Autorisés ✅ Autorisés ❌ Interdits (mais valeurs
dupliqués
dupliquées
possibles)
❌ Non (accès
Indexation / ✅ Oui ✅ Oui
❌ Non via clé :
Slicing (liste[0]) (tuple[1:3])
dict["nom"])
Ajout d’un append(x) ou dict["clé"] =
❌ Impossible add(x)
élément insert(i, x) valeur

remove(x), remove(x) ou pop("clé") ou

Suppression ❌ Impossible
pop(i), del discard(x) del dict["clé"]
Clés :
Type Tous types
Tous types immuables,
d’éléments (même Tous types
immutables Valeurs :
autorisés mélangés)
tous types
Modérée Excellente Rapide pour tests Rapide pour
Performance (flexible mais (fixe et d’appartenance recherche
un peu lente) légère) (in) par clé
Stocker des
séquences Stocker des Associer des
Tester des
modifiables données fixes valeurs à des
Utilisation appartenances ou
(liste (coordonnées, clés (profil
typique éliminer les
d’étudiants, constantes, utilisateur,
doublons
de tâches, etc.) config, etc.)
etc.)
list(), set()
Conversion tuple(), set(),
list(), set() list(), tuple() (sur clés ou
possible dict()
valeurs)
Compréhensi ❌ Non (mais ✅ Oui ({k:v for
✅ Oui ([x*2 for ✅ Oui ({x*2 for x in
ons on peut k,v in
x in liste]) set})
possibles convertir) [Link]()})

Itérable ✅ Oui ✅ Oui ✅ Oui ✅ Oui

Exemple [1, 2, 3, 3] (1, 2, 3) {1, 2, 3} {"nom":

 "Alice", "age":
25}

I. Les modules et les packages

i.1. Introduction
En Python, un module ou un package permet de réutiliser du code.
Au lieu d’écrire tout ton programme dans un seul fichier, tu peux
organiser ton code en plusieurs fichiers plus simples à maintenir et à
importer.

i.2. Qu’est-ce qu’un module ?

Définition :

Un module est simplement un fichier Python (.py) contenant des

fonctions, classes ou variables que tu peux réutiliser ailleurs.

Exemple :

# fichier: [Link]

def addition(a, b):

return a + b

def multiplication(a, b):

return a * b

Utilisation :

# fichier: [Link]
import calculs

print([Link](3, 5)) # Résultat : 8

print([Link](2, 4)) # Résultat : 8
 i.3. Différentes façons d’importer un module

Description Syntaxe Exemple

Importe tout le module import module import math

Donne un nom abrégé import module as alias import math as m

Importe une fonction from module import from math import
spécifique fonction sqrt
from math import
Importe tout (⚠️à éviter) from module import *
*

Exemple :

from math import pow

print(pow(2, 3)) # Résultat : 8

Où Python cherche les modules ?

Python cherche les modules dans plusieurs emplacements :

1. Le répertoire courant

2. Le répertoire des bibliothèques standard

3. Les chemins définis dans [Link]

Tu peux vérifier les chemins de recherche avec :

import sys
print([Link])

I.4. Les packages : organisation de plusieurs modules

Définition :

Un package est un dossier contenant plusieurs modules (et souvent

un fichier __init__.py).

Structure :

mon_projet/
│
├── [Link]
└── outils/
 ├── __init__.py
├── [Link]
└── [Link]

Exemple de contenu :

# outils/[Link]
def addition(a, b):
return a + b
# outils/[Link]
def saluer(nom):
return f"Bonjour {nom}!"

Utilisation :

from [Link] import addition

from [Link] import saluer

print(addition(2, 3))
print(saluer("Jean"))

Les packages standards (bibliothèque standard)

Python inclut de nombreux modules intégrés :

 math → calculs mathématiques

 datetime → gestion des dates

 os → gestion du système d’exploitation

 random → génération aléatoire

 json → manipulation de données JSON

 sys → interaction avec l’interpréteur Python

Exemple :

import random
print([Link](1, 10))

Les packages externes (via pip)

Tu peux installer des modules créés par la communauté avec pip :

pip install requests

Exemple d’utilisation :

import requests

reponse = [Link]("[Link]
print(reponse.status_code)

Créer ton propre package installable

Structure typique :

mon_package/
│
├── [Link]
├── [Link]
└── mon_package/
├── __init__.py
└── [Link]

 [Link] contient les informations d’installation.

 On peut ensuite l’installer localement :

 pip install .

i.5. Résumé comparatif

Élément Description Exemple

Fichier Python contenant du code
Module [Link]
réutilisable
Dossier contenant plusieurs
Package outils/
modules
Importation Accès au code d’un module import math
Package os, math,
Déjà inclus avec Python
standard datetime
Package requests, flask,
Installé via pip
externe numpy

🎯 10. Bonnes pratiques

✅ Organise ton code en plusieurs modules pour plus de clarté.

✅ Donne des noms explicites à tes fichiers et fonctions.
✅ Utilise des alias (import numpy as np) pour plus de lisibilité.
✅ Évite from module import * (risque de conflits de noms).
✅ Ajoute un fichier __init__.py pour signaler un package.

J. Les fichiers
J.1. Introduction
En Python, un fichier est un moyen de stocker des données sur le
disque.
On peut :

 Lire un fichier (texte, CSV, JSON, etc.)

 Écrire dans un fichier

 Ajouter du contenu à un fichier existant

Le module intégré pour cela est la fonction open().

J.2. Ouvrir un fichier

Syntaxe :

fichier = open("nom_fichier.txt", mode, encoding="utf-8")

Paramètre Description Exemple

"nom_fichier. Nom ou chemin du
"[Link]"
txt" fichier
"r", "w", "a", "rb",
mode Mode d’ouverture
"wb"
encoding Encodage (texte) "utf-8"
Modes principaux :

Mod
Description
e
Lire (par défaut, erreur si le fichier
R n’existe pas)
W Écrire (écrase le fichier s’il existe)

A Ajouter à la fin du fichier

Rb Lire en binaire

Wb Écrire en binaire
J.3. Lire un fichier
Lire tout le fichier d’un coup

with open("[Link]", "r", encoding="utf-8") as f:

contenu = [Link]()
print(contenu)

Astuce : with ferme automatiquement le fichier, même si une erreur

survient.

Lire ligne par ligne

with open("[Link]", "r", encoding="utf-8") as f:

for ligne in f:
print([Link]()) # supprime le retour à la ligne

Lire toutes les lignes dans une liste

with open("[Link]", "r", encoding="utf-8") as f:

lignes = [Link]()
print(lignes) # ['ligne1\n', 'ligne2\n', ...]

J.4. Écrire dans un fichier

Écrire (écrase le fichier existant)

with open("[Link]", "w", encoding="utf-8") as f:

[Link]("Bonjour le monde\n")
[Link]("Ceci est une nouvelle ligne\n")
Ajouter à un fichier existant

with open("[Link]", "a", encoding="utf-8") as f:

[Link]("Ajout d’une ligne supplémentaire\n")

J.4. Lire et écrire avec read() et write()

 read(size) : lit jusqu’à size caractères ou tout si pas de paramètre

 readline() : lit une seule ligne

 readlines() : lit toutes les lignes et les met dans une liste

 write(string) : écrit une chaîne de caractères dans le fichier

J.5. Manipulations avancées
Compter les lignes dans un fichier

with open("[Link]", "r", encoding="utf-8") as f:

nb_lignes = sum(1 for ligne in f)
print(nb_lignes)

Supprimer le contenu d’un fichier

open("[Link]", "w").close()

J.6. Travailler avec CSV

import csv

# Écrire un CSV
with open("[Link]", "w", newline="", encoding="utf-8") as f:
writer = [Link](f)
[Link](["Nom", "Age"])
[Link](["Alice", 25])

# Lire un CSV
with open("[Link]", "r", encoding="utf-8") as f:
reader = [Link](f)
for ligne in reader:
print(ligne)

J.7. Travailler avec JSON

import json

# Écrire un JSON
data = {"nom": "Alice", "age": 25}
with open("[Link]", "w", encoding="utf-8") as f:
[Link](data, f, indent=4)

# Lire un JSON
with open("[Link]", "r", encoding="utf-8") as f:
data_lue = [Link](f)
print(data_lue)

J.8. Bonnes pratiques

1. Toujours utiliser with pour éviter d’oublier de fermer le fichier
 2. Spécifier l’encodage (utf-8) pour éviter les erreurs de caractères

3. Vérifier l’existence d’un fichier avant de le lire ([Link]())

4. Éviter read() sur de gros fichiers → privilégier readline() ou

lecture ligne par ligne

Résumé rapide

Action Fonction / Méthode

Ouvrir un
open("[Link]", "mode")
fichier
Lire tout read()

Lire ligne readline() / readlines()

Écrire write("texte")

Ajouter open("[Link]", "a")

[Link]() ou with open()
Fermer
automatique
CSV [Link], [Link]

JSON [Link], [Link]

Exemple pratique complet :

import json

# Sauvegarder des données utilisateurs

utilisateurs = [
{"nom": "Alice", "age": 25},
{"nom": "Bob", "age": 30}
]

with open("[Link]", "w", encoding="utf-8") as f:

[Link](utilisateurs, f, indent=4)

# Lire et afficher
with open("[Link]", "r", encoding="utf-8") as f:
data = [Link](f)
for user in data:
print(f"{user['nom']} a {user['age']} ans")
 K. La programmation orienté objet (POO) en python
K.1. Introduction à la POO
La Programmation Orientée Objet (POO) est un paradigme qui consiste à modéliser ton
programme en objets. Chaque objet représente une chose du monde réel : un étudiant, une
voiture, un compte bancaire, etc.

L’idée : regrouper les données (attributs) et les comportements (méthodes) dans une même
entité appelée classe.

K.2. Concepts de base

Concept Description
Classe Modèle ou plan qui décrit les attributs et comportements d’un objet.
Objet Instance concrète d’une classe.
Attribut Variable liée à un objet (ex : nom, âge).
Méthode Fonction liée à une classe, décrivant ses actions.
C’est un paramètre qui représente l’objet lui-même (équivalent de
Self
this en d’autres langages).
Constructeur __init__ Méthode appelée automatiquement à la création de l’objet.

K.3. Créer une classe simple

class Etudiant:
def __init__(self, nom, age):
[Link] = nom # Attribut d’instance
[Link] = age

def saluer(self):
print(f"Bonjour, je m'appelle {[Link]} et j'ai {[Link]}
ans.")

Utilisation :
et1 = Etudiant("Jean", 21)
et2 = Etudiant("Alice", 22)

[Link]()
[Link]()
Résultat :
Bonjour, je m'appelle Jean et j'ai 21 ans.

Bonjour, je m'appelle Alice et j'ai 22 ans.

K.4. Attributs d’instance et attributs de classe

Attribut d’instance : Propre à chaque objet.

class Etudiant:
def __init__(self, nom):
[Link] = nom # Attribut d’instance

Attribut de classe : Commun à tous les objets de la classe.

class Etudiant:
universite = "UCC" # Attribut de classe

def __init__(self, nom):

[Link] = nom # Attribut d’instance

e1 = Etudiant("Jean")
e2 = Etudiant("Alice")

print([Link]) # UCC
print([Link]) # UCC

K.5. Méthodes d’instance, de classe et statiques

Type de
Définition Syntaxe
méthode
 Méthode
Agit sur une instance spécifique def ma_methode(self):
d’instance
Méthode de @classmethod puis def
Agit sur la classe entière
classe ma_methode(cls):
Méthode Ne dépend ni de la classe ni d’une
@staticmethod
statique instance

Exemple :

class Etudiant:
universite = "UCC"

def __init__(self, nom):

[Link] = nom

def afficher_nom(self): # Méthode d’instance

print([Link])

@classmethod
def changer_universite(cls, nom_uni):
[Link] = nom_uni

@staticmethod
def est_majeur(age):
return age >= 18

K.6. L’héritage
L’héritage permet de créer une nouvelle classe (fille) à partir d’une classe existante (mère).

Exemple :

class Personne:
def __init__(self, nom):
[Link] = nom

def parler(self):
print(f"{[Link]} parle.")

class Etudiant(Personne): # Hérite de Personne

def etudier(self):
print(f"{[Link]} étudie.")

Utilisation :
e = Etudiant("Alice")
[Link]() # Hérité
[Link]() # Spécifique à Etudiant

k.7. Surcharge et héritage multiple

Surcharge du constructeur :

Tu peux redéfinir __init__ tout en appelant le constructeur parent :

class Etudiant(Personne):
def __init__(self, nom, matricule):
super().__init__(nom)
[Link] = matricule

Heritage multiple :

class A:
def faire(self): print("A")

class B:
def faire(self): print("B")

class C(A, B):

pass

c = C()
[Link]() # Affiche A (ordre MRO : Method Resolution Order)

K.8. Encapsulation et visibilité

Python n’a pas de vraies variables “privées”, mais on utilise des conventions :

Syntaxe Signification
nom Public
_nom Protégé (usage interne conseillé)
Privé (nom modifié
__nom
automatiquement)

Exemple :

class CompteBancaire:
 def __init__(self, solde):
self.__solde = solde # Privé

def deposer(self, montant):

self.__solde += montant

def afficher_solde(self):
print(f"Solde : {self.__solde} FC")

k.9. Polymorphisme
Le polymorphisme permet d’utiliser une même méthode sur différents types d’objets.

class Animal:
def parler(self):
pass

class Chien(Animal):
def parler(self):
print("Wouf !")

class Chat(Animal):
def parler(self):
print("Miaou !")

animaux = [Chien(), Chat()]

for a in animaux:
[Link]()

K.10. Méthodes spéciales (ou "dunder methods")

Les méthodes magiques commencent et finissent par __.

Méthode Rôle
__init__() Constructeur
__str__() Représentation lisible de l’objet
__len__() Taille de l’objet
__add__() Définir le comportement de +
__eq__() Définir le comportement de ==

Example :

class Point:
 def __init__(self, x, y):
self.x = x
self.y = y

def __str__(self):
return f"Point({self.x}, {self.y})"

def __add__(self, autre):

return Point(self.x + autre.x, self.y + autre.y)

p1 = Point(2, 3)
p2 = Point(4, 1)
print(p1 + p2) # Point(6, 4)

K.11. Résumé global

Concept Description Exemple
Classe Modèle définissant objets class Etudiant:
Objet Instance de classe e = Etudiant()
Attribut Donnée propre à l’objet [Link]
Méthode Fonction de la classe def saluer(self):
Héritage Transmission de propriétés class Fille(Parent)
Encapsulation Protection des données __variable
Comportement commun parler() selon
Polymorphisme
différencié l’objet

K.12. Bonnes pratiques

 Utiliser self et __init__ correctement
 Préférer l’héritage simple et clair
 Ne pas abuser de l’héritage multiple
 Ajouter __str__() pour rendre les objets lisibles
 Utiliser des noms explicites pour classes et méthodes