Cours : Introduction à l'algorithmique et programmation

Pr. Loubna KARBIL

Contenu du cours :
1. Introduction à l'algorithmique
2. Introduction à Python
3. Syntaxe de Base
4. Variables et Types de Données
5. Opérateurs
6. Structures de Contrôle
7. Fonctions
8. Listes
9. Algorithmes de Tri
10. Algorithmes de Recherche
11. Tuples et Dictionnaires
12. Piles et Files
13. Manipulation de Fichiers
14. Programmation Orientée Objet (POO)

1. Introduction à l'algorithmique

Qu'est-ce qu'un Algorithme ? Un algorithme est une suite finie et ordonnée d’instructions
permettant de résoudre un problème ou d’effectuer une tâche. Les algorithmes sont utilisés
dans divers domaines pour traiter des données, automatiser des tâches, ou résoudre des
problèmes complexes.
Pourquoi Utiliser le Pseudocode ? Le pseudocode permet de décrire la logique d’un
algorithme sans la complexité d’un langage de programmation spécifique. Il est utilisé pour
illustrer et planifier les étapes d’un programme.
1.1. Notions de Base et Syntaxe en Pseudocode
Voici les éléments de base de la syntaxe algorithmique en pseudocode, avec des exemples
pour chaque structure.
Déclaration d'un Algorithme
 On commence par le mot-clé Algorithme suivi du nom de l'algorithme.

Algorithme NomDeLAlgorithme

Déclaration des Entrées et Sorties

 Entrée : Les données que l'algorithme prend pour fonctionner.
 Sortie : Le résultat attendu.

Entrée : nom_variable_entrée

2ème année MGSI [Link] 1

2024/2025
Sortie : nom_variable_sortie

Assignation de Valeurs
 L'assignation se fait avec = pour attribuer une valeur à une variable.

x = 10 // x prend la valeur 10

Structures Conditionnelles (Si...Alors...Sinon)

 Utilisées pour exécuter des instructions selon une condition.

Si condition alors
// instructions si la condition est vraie
Sinon
// instructions si la condition est fausse
Fin Si

Boucles (Pour et Tant Que)

 Boucle Pour : Pour répéter un bloc d’instructions un nombre défini de fois.

Pour i allant de valeur_début à valeur_fin

// instructions
Fin Pour

 Boucle Tant Que : Pour répéter tant qu’une condition est vraie.

Tant Que condition

// instructions
Fin Tant Que

Affichage et Entrée Utilisateur

 Afficher : Affiche un message ou un résultat.
 Lire : Demande une entrée de l'utilisateur.

Ecrire( "Message à afficher")

Lire (variable)

1.2. Exemples d’Algorithmes avec Syntaxe en Pseudocode

Exemple 1 : Calcul de la Somme des N Premiers Entiers
Cet algorithme calcule la somme des N premiers entiers, en ajoutant chaque entier de 1 à N.
2ème année MGSI [Link] 2
2024/2025
Algorithme SommeNEntiers
Entrée : N (un entier)
Sortie : somme (la somme des N premiers entiers)
Début
somme = 0 // Initialisation de la somme
Lire(N)
Pour i allant de 1 à N
somme = somme + i // Ajoute chaque entier à la somme
Fin Pour

Ecrire( "La somme des", N, "premiers entiers est :", somme)

Fin

Exemple 2 : Recherche du Maximum dans une Liste

Cet algorithme trouve le plus grand nombre dans une liste d'entiers.

Algorithme MaximumListe
Entrée : liste (une liste d'entiers)
Sortie : max (le plus grand entier de la liste)
Début
max = liste[0] // Initialiser max avec le premier élément
Pour chaque élément dans liste
Si élément > max alors
max = élément // Met à jour max si élément est plus grand
Fin Si
Fin Pour
Ecrire("Le maximum de la liste est :", max)
Fin

Exemple 3 : Vérification de Parité (Pair ou Impair)

Cet algorithme vérifie si un nombre est pair ou impair.

2ème année MGSI [Link] 3

2024/2025
Algorithme VerifierParite
Entrée : nombre (un entier)
Sortie : "Pair" ou "Impair"
Début
Lire (nombre)
Si nombre mod 2 = 0 alors
Ecrire ( "Le nombre est pair")
Sinon
Ecrire ("Le nombre est impair")
Fin Si
Fin

1.3. Travaux Pratiques

Exercice 1 : Calculer la Factorielle d’un Nombre
Écrivez un algorithme pour calculer la factorielle d’un nombre entier positif N.
Solution :

Algorithme Factorielle
Entrée : N (un entier positif)
Sortie : fact (la factorielle de N)
Début
fact = 1 // Initialiser fact
Pour i allant de 1 à N
fact = fact * i // Multiplie fact par i
Fin Pour
Ecrire("La factorielle de", N, "est :", fact)
Fin

Exercice 2 : Vérification de Divisibilité

Écrivez un algorithme qui prend un nombre et vérifie s’il est divisible par 5 et 3.
Solution :

Algorithme VerifierDivisibilite

2ème année MGSI [Link] 4

2024/2025
Entrée : nombre (un entier)
Début
Sortie : "Divisible par 3 et 5" ou "Non divisible par 3 et 5"
Si nombre mod 3 = 0 ET nombre mod 5 = 0 alors
Ecrire( "Le nombre est divisible par 3 et 5")
Sinon
Ecrire ("Le nombre n'est pas divisible par 3 et 5")
Fin Si
Fin

2. Introduction à Python
2.1. Présentation de Python

Qu'est-ce que Python ? Python est un langage de programmation de haut niveau, interprété et
orienté objet, créé par Guido van Rossum et introduit en 1991. Python est populaire pour sa
simplicité et sa lisibilité, ce qui en fait un excellent choix pour les débutants, tout en restant puissant
pour des applications complexes. On le retrouve dans des domaines variés :

 Développement Web : Utilisé pour créer des sites et applications web (avec Django, Flask,
etc.)

 Analyse de données et Machine Learning : Python est largement utilisé dans la science des
données (avec des bibliothèques comme Pandas, NumPy, Scikit-learn).

 Automatisation : Souvent utilisé pour automatiser des tâches répétitives, comme le

traitement de fichiers ou les tests automatisés.

Installation de Python Pour exécuter du code Python, il faut installer l'interpréteur Python sur votre
ordinateur. Voici comment procéder :

1. Téléchargement : Allez sur [Link] et téléchargez la dernière version de Python pour

votre système d'exploitation.

2. Installation : Suivez les instructions d'installation. Assurez-vous de cocher l'option "Add

Python to PATH" pendant l'installation pour pouvoir utiliser Python dans le terminal.

3. Vérification : Une fois installé, ouvrez votre terminal (ou invite de commande) et tapez
python --version. Cela doit afficher la version de Python installée.

Environnements de Développement (IDE) Pour écrire et exécuter du code, vous pouvez utiliser
différents environnements :

 IDLE : L'éditeur simple fourni avec Python.

 Jupyter Notebook : Outil interactif souvent utilisé pour les données et l’analyse.

 PyCharm ou VS Code : Des éditeurs avancés avec des fonctionnalités de débogage,

autocomplétion, et autres outils de développement.

2ème année MGSI [Link] 5

2024/2025
2.2. Les Bases du Langage Python

Déclaration de Variables

En Python, les variables permettent de stocker des informations que vous pouvez utiliser et
manipuler dans votre code. Contrairement à d'autres langages, vous n'avez pas besoin de spécifier le
type de la variable lors de sa déclaration ; Python le déduit automatiquement à partir de la valeur
que vous lui assignez.

nom = "Alice" # Chaîne de caractères

age = 25 # Entier

taille = 1.75 # Nombre à virgule flottante

est_etudiant = True # Booléen (Vrai ou Faux)

Explications :

 nom = "Alice" : Ici, nom est une variable de type str (chaîne de caractères).

 age = 25 : age est un nombre entier (int).

 taille = 1.75 : taille est un nombre à virgule (float).

 est_etudiant = True : est_etudiant est une variable booléenne (bool), qui peut être soit True
(vrai) soit False (faux).

Types de Données en Python

Les principaux types de données de base en Python sont :

 int : Pour les nombres entiers (ex : 10, -5, 42).

 float : Pour les nombres à virgule flottante (ex : 3.14, 2.0).

 str : Pour les chaînes de caractères (ex : "Bonjour", "Python").

 bool : Pour les booléens, valeurs logiques (ex : True, False).

Les types de données sont importants car ils déterminent quelles opérations peuvent être effectuées
sur chaque variable.

Opérations de Base en Python

Python prend en charge les opérations arithmétiques et logiques. Voici quelques exemples courants :

a = 10

b=5

print(a + b) # Addition : affiche 15

print(a - b) # Soustraction : affiche 5

print(a * b) # Multiplication : affiche 50

print(a / b) # Division : affiche 2.0

2ème année MGSI [Link] 6

2024/2025
print(a % b) # Modulo (reste de la division) : affiche 0

print(a == b) # Comparaison d'égalité : affiche False

print(a > b) # Supérieur : affiche True

Fonctions d'Entrée et de Sortie

 input() : Utilisée pour demander une entrée utilisateur.

 print() : Utilisée pour afficher des informations à l'écran.

nom = input("Entrez votre nom : ")

print("Bonjour,", nom)

Dans cet exemple, input() demande à l'utilisateur de saisir un texte. Ce texte est ensuite stocké dans
la variable nom, qui est affichée avec print().

2.3. Structures de Contrôle en Python

Les structures de contrôle permettent de gérer le flux d'exécution du programme en fonction de

conditions logiques. En Python, il existe principalement deux types de structures de contrôle : les
conditions et les boucles.

2.3.1 Conditions (if, elif, else)

Les conditions permettent d'exécuter un bloc de code en fonction d'une condition donnée. Si la
condition est vraie, le bloc de code est exécuté. Si elle est fausse, le programme passe à la condition
suivante ou ignore le bloc de code.

Syntaxe de base :

if condition:

# Bloc de code exécuté si la condition est vraie

elif autre_condition:

# Bloc de code exécuté si autre_condition est vraie

else:

# Bloc de code exécuté si aucune des conditions précédentes n'est vraie

1. if : Utilisé pour vérifier une première condition.

2. elif (else if) : Permet de vérifier une autre condition si la première est fausse.

3. else : Exécute le code associé si aucune des conditions précédentes n’est vraie.

Exemple : Vérification de l'âge

Supposons que nous voulions écrire un programme qui vérifie si une personne est mineure, majeure,
ou senior en fonction de son âge :

age = int(input("Entrez votre âge : "))

if age < 18:

2ème année MGSI [Link] 7

2024/2025
 print("Vous êtes mineur.")

elif 18 <= age < 65:

print("Vous êtes majeur.")

else:

print("Vous êtes senior.")

Explication détaillée :

 Si age < 18 est vrai, le programme affiche "Vous êtes mineur." et ignore les autres blocs.

 Si age >= 18 et age < 65 sont vrais (grâce à elif), le programme affiche "Vous êtes majeur.".

 Si aucune de ces conditions n'est vraie (c’est-à-dire age >= 65), le programme passe au bloc
else et affiche "Vous êtes senior."

Conditions imbriquées : Il est possible de placer une condition à l'intérieur d'une autre condition
pour vérifier des situations plus complexes.

age = int(input("Entrez votre âge : "))

nationalite = input("Êtes-vous citoyen (oui/non) ? ")

if age >= 18:

if nationalite == "oui":

print("Vous pouvez voter.")

else:

print("Vous ne pouvez pas voter car vous n'êtes pas citoyen.")

else:

print("Vous êtes mineur et ne pouvez pas voter.")

Dans cet exemple, la seconde condition vérifie la nationalité uniquement si l'âge est supérieur ou
égal à 18.

2.3.2 Opérateurs Logiques et Comparatifs

Les opérateurs sont essentiels pour créer des conditions en Python.

Opérateurs de comparaison : Ils comparent des valeurs.

 == : égal à

 != : différent de

 < : inférieur à

 > : supérieur à

 <= : inférieur ou égal à

 >= : supérieur ou égal à

2ème année MGSI [Link] 8

2024/2025
Opérateurs logiques : Ils combinent plusieurs conditions.

 and : Vrai si toutes les conditions sont vraies.

 or : Vrai si au moins une condition est vraie.

 not : Inverse la condition.

Exemple combiné :

age = 25

citoyen = True

if age >= 18 and citoyen:

print("Vous pouvez voter.")

else:

print("Vous ne pouvez pas voter.")

Ici, le message "Vous pouvez voter." s’affiche uniquement si age >= 18 et citoyen sont tous deux
vrais.

2.3.3 Boucles en Python

Les boucles permettent de répéter des instructions plusieurs fois, selon une condition donnée.
Python propose deux types de boucles principales : la boucle for et la boucle while.

2.3.4 La Boucle for

La boucle for est utilisée pour parcourir une séquence, comme une liste, une chaîne de caractères,
ou un intervalle de nombres. Elle est très pratique pour exécuter un code un nombre fixe de fois.

Syntaxe :

for variable in sequence:

# Bloc de code à exécuter

Exemple : Parcourir une liste

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

for fruit in fruits:

print("J'aime les", fruit)

Explication : Dans cet exemple, la variable fruit prend successivement chaque valeur de la liste fruits,
et le programme affiche "J'aime les pomme", puis "J'aime les banane", puis "J'aime les cerise".

Boucle for avec range()

La fonction range() génère une séquence de nombres. Elle est souvent utilisée avec une boucle for
pour itérer un certain nombre de fois.

2ème année MGSI [Link] 9

2024/2025
for i in range(5):

print("Itération numéro", i)

Explication détaillée :

 range(5) crée une séquence de nombres de 0 à 4.

 La boucle s'exécute 5 fois, avec i prenant les valeurs successives de 0 à 4.

Vous pouvez personnaliser range() pour spécifier un début, une fin, et un pas.

for i in range(1, 10, 2):

print(i)

Explication :

 range(1, 10, 2) démarre à 1, s’arrête avant 10, et avance par pas de 2, donc i prendra les
valeurs 1, 3, 5, 7, et 9.

2.3.5 La Boucle while

La boucle while répète un bloc de code tant qu'une condition est vraie. Elle est utile pour des
situations où l'on ne sait pas à l'avance combien de fois il faudra répéter le code.

Syntaxe :

while condition:

# Bloc de code à exécuter

Exemple : Compter jusqu'à 5

compteur = 1

while compteur <= 5:

print("Compteur :", compteur)

compteur += 1

Explication : La boucle continue de s'exécuter tant que compteur est inférieur ou égal à 5. À chaque
itération, compteur est incrémenté de 1.

Boucles infinies : Si la condition d'une boucle while reste toujours vraie, la boucle s'exécutera sans
fin, ce qui peut bloquer le programme. Assurez-vous que la condition deviendra fausse à un moment
donné !

compteur = 0

while True:

print("Ceci est une boucle infinie")

compteur += 1

if compteur == 10:

2ème année MGSI [Link] 10

2024/2025
 break

Explication : Ici, la boucle est infinie (while True:), mais grâce à la condition if compteur == 10, le
break interrompt la boucle après 10 itérations.

2.3.6 Instructions de Contrôle des Boucles

Python offre deux instructions pour contrôler le flux des boucles : break et continue.

 break : Arrête complètement la boucle.

 continue : Saute directement à l'itération suivante.

Exemple d'utilisation de break

for i in range(10):

if i == 5:

break

print(i)

Explication : La boucle s'arrête lorsque i atteint 5. Le programme affiche 0, 1, 2, 3, et 4.

Exemple d'utilisation de continue

for i in range(10):

if i % 2 == 0:

continue

print(i)

Explication : Ici, continue saute l'impression des nombres pairs. Le programme affiche donc
seulement les nombres impairs entre 0 et 9 (1, 3, 5, 7, 9).

Exemples d'Applications Pratiques des Boucles

Exemple 1 : Calculer la somme des nombres de 1 à 100

somme = 0

for i in range(1, 101):

somme += i

print("La somme des nombres de 1 à 100 est :", somme)

Explication : La boucle for additionne chaque nombre de 1 à 100, et le résultat final est stocké dans
somme.

Exemple 2 : Trouver les nombres premiers entre 2 et 20

for num in range(2, 21):

est_premier = True

for i in range(2, num):

2ème année MGSI [Link] 11

2024/2025
 if num % i == 0:

est_premier = False

break

if est_premier:

print(num, "est un nombre premier")

4. Fonctions en Python
Les fonctions permettent de réutiliser du code sans le réécrire. En regroupant des instructions
spécifiques dans une fonction, on peut appeler cette fonction n'importe où dans le programme, ce
qui rend le code plus clair et modulaire.

4.1 Déclaration d’une Fonction

Pour définir une fonction en Python, on utilise le mot-clé def, suivi du nom de la fonction, des
parenthèses, et d’un deux-points :. Le code de la fonction est ensuite indenté sous cette ligne.

Syntaxe de base :

def nom_de_la_fonction(parametre1, parametre2, ...):

# Instructions de la fonction

return valeur_a_retourner

 def : Indique le début de la définition de la fonction.

 nom_de_la_fonction : Nom de la fonction, qui doit être unique et en minuscules avec des
underscores pour séparer les mots.

 paramètres : Ce sont des variables utilisées par la fonction. Elles sont placées entre
parenthèses après le nom.

 return : Cette instruction renvoie une valeur en sortie de la fonction. Elle est optionnelle,
mais essentielle lorsque la fonction doit fournir un résultat.

4.2 Exemple de Fonction Simple

Créons une fonction qui ajoute deux nombres et retourne le résultat.

def addition(a, b):

resultat = a + b

return resultat

Explication :

 La fonction addition prend deux paramètres a et b.

 Elle calcule leur somme et stocke le résultat dans la variable resultat.

 Elle retourne ensuite resultat avec l'instruction return.

Pour utiliser cette fonction, on l’appelle et on lui passe les arguments :

2ème année MGSI [Link] 12

2024/2025
somme = addition(5, 10)

print("La somme est :", somme)

4.3 Paramètres et Arguments

Les paramètres sont les variables définies dans la fonction (comme a et b dans l'exemple ci-dessus),
tandis que les arguments sont les valeurs spécifiques que l'on passe à la fonction lors de l'appel.

 Paramètres obligatoires : Ce sont les paramètres sans valeur par défaut, et ils doivent être
fournis à l'appel de la fonction.

 Paramètres optionnels (avec valeurs par défaut) : Si une valeur par défaut est fournie pour
un paramètre, il devient optionnel lors de l'appel de la fonction.

Exemple avec paramètres par défaut :

def saluer(nom, message="Bonjour"):

return message + ", " + nom

Ici, le paramètre message a une valeur par défaut de "Bonjour". Cela signifie qu'on peut appeler la
fonction avec un seul argument :

print(saluer("Alice")) # Affiche : Bonjour, Alice

print(saluer("Alice", "Salut")) # Affiche : Salut, Alice

4.4 Portée des Variables (Scope)

La portée détermine où une variable est accessible dans le code. Il existe deux types principaux de
portée en Python :

1. Portée locale : Les variables créées à l'intérieur d'une fonction sont locales à cette fonction
et n'existent pas en dehors d'elle.

2. Portée globale : Les variables définies en dehors de toute fonction sont globales et
accessibles dans tout le programme.

Exemple :

def test_portee():

x = 5 # Variable locale

print("Dans la fonction :", x)

x = 10 # Variable globale

test_portee()

print("En dehors de la fonction :", x)

Résultat :

Dans la fonction : 5

2ème année MGSI [Link] 13

2024/2025
En dehors de la fonction : 10

Dans cet exemple, la variable x définie dans la fonction est différente de celle définie en dehors de la
fonction, même si elles portent le même nom.

4.5 Fonctions avec return et Fonctions Sans Valeur de Retour

Une fonction peut soit retourner une valeur avec return, soit ne rien retourner, auquel cas elle
renvoie implicitement None.

Fonction avec return :

def multiplier(a, b):

return a * b

Fonction sans return :

def afficher_bonjour():

print("Bonjour !")

Lorsque afficher_bonjour est appelée, elle affiche simplement "Bonjour !" et ne renvoie pas de
valeur.

4.6 Arguments Variables (*args et **kwargs)

Les arguments variables permettent de créer des fonctions plus flexibles, qui peuvent recevoir un
nombre variable d'arguments.

 *args : Permet de passer un nombre indéfini d'arguments positionnels dans une fonction. Les
arguments sont collectés sous forme de tuple.

Exemple :

def additionner_tout(*args):

total = 0

for nombre in args:

total += nombre

return total

print(additionner_tout(1, 2, 3, 4)) # Affiche : 10

 **kwargs : Permet de passer un nombre indéfini d'arguments nommés sous forme de

dictionnaire.

Exemple :

def afficher_informations(**kwargs):

for cle, valeur in [Link]():

print(f"{cle} : {valeur}")

2ème année MGSI [Link] 14

2024/2025
afficher_informations(nom="Alice", age=25, ville="Paris")

Résultat :

nom : Alice

age : 25

ville : Paris

4.7 Fonctions Lambda (Fonctions Anonymes)

Les fonctions lambda sont des fonctions anonymes, utiles pour des opérations simples. Elles
s'écrivent sur une seule ligne avec la syntaxe lambda paramètres: expression.

Syntaxe :

lambda parametre1, parametre2: expression

Exemple :

addition = lambda x, y: x + y

print(addition(5, 3)) # Affiche : 8

Les fonctions lambda sont souvent utilisées avec des fonctions comme map(), filter(), et sorted().

Exemple avec sorted() :

eleves = [("Alice", 22), ("Bob", 20), ("Clara", 21)]

eleves_tries = sorted(eleves, key=lambda eleve: eleve[1])

print(eleves_tries) # Trie les élèves par âge

4.8 Exemples de Fonctions Pratiques

1. Fonction pour Calculer le Factoriel d'un Nombre

def factorielle(n):

if n == 0 or n == 1:

return 1

else:

return n * factorielle(n - 1)

print(factorielle(5)) # Affiche : 120

Cette fonction utilise la récursivité, c'est-à-dire qu'elle s'appelle elle-même pour calculer le produit
de tous les nombres jusqu'à n.

2. Fonction pour Vérifier si un Nombre est Premier

2ème année MGSI [Link] 15

2024/2025
def est_premier(n):

if n <= 1:

return False

for i in range(2, int(n ** 0.5) + 1):

if n % i == 0:

return False

return True

print(est_premier(7)) # Affiche : True

print(est_premier(8)) # Affiche : False

Cette fonction vérifie si un nombre n est divisible par un autre nombre entre 2 et la racine carrée de
n. Si c'est le cas, n n'est pas premier.

5. Travaux Pratiques
Exercice 1 : Calculer la Somme de Deux Nombres

Demandez à l'utilisateur de saisir deux nombres, puis affichez leur somme.

# Solution

a = float(input("Entrez le premier nombre : "))

b = float(input("Entrez le second nombre : "))

somme = a + b

print("La somme est :", somme)

Exercice 2 : Vérification de la Parité

Écrivez un programme qui demande un nombre et affiche s'il est pair ou impair.

# Solution

nombre = int(input("Entrez un nombre : "))

if nombre % 2 == 0:

print("Le nombre est pair")

else:

print("Le nombre est impair")

Exercice 3 : Calcul de Factorielle

Demandez à l'utilisateur de saisir un nombre entier et affichez sa factorielle (ex : factorielle de 5 est
5! = 5 × 4 × 3 × 2 × 1).

2ème année MGSI [Link] 16

2024/2025
# Solution

nombre = int(input("Entrez un nombre : "))

factorielle = 1

for i in range(1, nombre + 1):

factorielle *= i

print("La factorielle de", nombre, "est :", factorielle)

6. Les Listes en Python

Les listes en Python sont des structures de données flexibles qui permettent de stocker des
collections d'objets. Elles sont définies par des crochets [] et peuvent contenir des éléments
de différents types.
6.1 Création d'une Liste
Pour créer une liste, vous pouvez simplement utiliser des crochets et séparer les éléments
par des virgules.
Exemple :

ma_liste = [1, 2, 3, 4, 5]
print(ma_liste) # Affiche : [1, 2, 3, 4, 5]

6.2 Accès aux Éléments de la Liste

Vous pouvez accéder aux éléments d'une liste en utilisant leur index, qui commence à 0 pour
le premier élément.
Exemple :

ma_liste = [10, 20, 30, 40, 50]

print(ma_liste[0]) # Affiche : 10
print(ma_liste[2]) # Affiche : 30

6.3 Modification des Éléments de la Liste

Les éléments d'une liste peuvent être modifiés en utilisant leur index.
Exemple :

ma_liste = [1, 2, 3]
ma_liste[1] = 20 # Modification de l'élément à l'index 1
print(ma_liste) # Affiche : [1, 20, 3]

6.4 Fonctions Usuelles des Listes

2ème année MGSI [Link] 17

2024/2025
Les listes en Python possèdent plusieurs méthodes intégrées pour manipuler les éléments.
Voici quelques-unes des plus courantes :
6.4.1 append()
La méthode append() ajoute un élément à la fin de la liste.
Exemple :

ma_liste = [1, 2, 3]
ma_liste.append(4)
print(ma_liste) # Affiche : [1, 2, 3, 4]

Explication : Ici, nous avons une liste contenant trois éléments. En utilisant append(4), nous
ajoutons le nombre 4 à la fin de la liste.
6.4.2 extend()
La méthode extend() permet d'ajouter plusieurs éléments à la fin de la liste à partir d'une
autre liste ou d'un itérable.
Exemple :

ma_liste = [1, 2, 3]
ma_liste.extend([4, 5, 6])
print(ma_liste) # Affiche : [1, 2, 3, 4, 5, 6]

Explication : Dans cet exemple, nous avons utilisé extend() pour ajouter les éléments de la
liste [4, 5, 6] à la liste ma_liste.
6.4.3 insert()
La méthode insert() permet d'insérer un élément à une position spécifique de la liste.
Exemple :

ma_liste = [1, 2, 3]
ma_liste.insert(1, 10) # Insérer 10 à l'index 1
print(ma_liste) # Affiche : [1, 10, 2, 3]

Explication : Ici, nous avons inséré le nombre 10 à l'index 1 de la liste, décalant ainsi les
autres éléments.
6.4.4 remove()
La méthode remove() supprime la première occurrence d'un élément de la liste.
Exemple :

ma_liste = [1, 2, 3, 2]
2ème année MGSI [Link] 18
2024/2025
ma_liste.remove(2)
print(ma_liste) # Affiche : [1, 3, 2]

Explication : Dans cet exemple, la méthode remove(2) supprime la première occurrence de

l'élément 2 de la liste.
6.4.5 pop()
La méthode pop() supprime et renvoie l'élément à un index spécifié (ou le dernier élément
par défaut).
Exemple :

ma_liste = [1, 2, 3]
element = ma_liste.pop(1) # Supprime et renvoie l'élément à l'index 1
print(element) # Affiche : 2
print(ma_liste) # Affiche : [1, 3]

Explication : Ici, nous avons utilisé pop(1) pour supprimer l'élément à l'index 1 (qui est 2) et
le stocker dans la variable element.
6.4.6 index()
La méthode index() renvoie l'index de la première occurrence d'un élément dans la liste.
Exemple :

ma_liste = [1, 2, 3, 2]
index = ma_liste.index(2)
print(index) # Affiche : 1

Explication : Dans cet exemple, index(2) retourne l'index de la première occurrence de

l'élément 2, qui est 1.
6.4.7 count()
La méthode count() renvoie le nombre d'occurrences d'un élément dans la liste.
Exemple :

ma_liste = [1, 2, 3, 2]
compte = ma_liste.count(2)
print(compte) # Affiche : 2

Explication : Ici, count(2) retourne le nombre d'occurrences de l'élément 2 dans la liste, qui
est 2.

2ème année MGSI [Link] 19

2024/2025
6.4.8 sort()
La méthode sort() trie les éléments de la liste en place.
Exemple :

ma_liste = [3, 1, 2]
ma_liste.sort()
print(ma_liste) # Affiche : [1, 2, 3]

Explication : Dans cet exemple, sort() trie les éléments de ma_liste en ordre croissant.
6.4.9 reverse()
La méthode reverse() inverse l'ordre des éléments dans la liste.
Exemple :

ma_liste = [1, 2, 3]
ma_liste.reverse()
print(ma_liste) # Affiche : [3, 2, 1]

Explication : Ici, reverse() inverse l'ordre des éléments de ma_liste.

6.4.10 clear()
La méthode clear() supprime tous les éléments de la liste.
Exemple :

ma_liste = [1, 2, 3]
ma_liste.clear()
print(ma_liste) # Affiche : []

Explication : Dans cet exemple, clear() supprime tous les éléments de ma_liste, laissant une
liste vide.
6.5 Slicing des Listes
Le slicing vous permet d'accéder à une sous-partie de la liste. Vous pouvez spécifier un
début, une fin et un pas.
Exemple :

ma_liste = [0, 1, 2, 3, 4, 5]
sous_liste = ma_liste[1:4] # Prend les éléments à l'index 1, 2 et 3
print(sous_liste) # Affiche : [1, 2, 3]

2ème année MGSI [Link] 20

2024/2025
Explication : Ici, ma_liste[1:4] extrait les éléments de l'index 1 à l'index 3 (le dernier index est
exclusif).
6.6 Liste de Compréhension
La compréhension de liste est une façon concise de créer des listes.
Exemple :

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

print(carres) # Affiche : [0, 1, 4, 9, 16]

Explication : Ici, nous avons créé une liste de carrés des nombres de 0 à 4 à l'aide de la
compréhension de liste.
8. Algorithmes de tri
8.1 Tri à Bulles (Bubble Sort)
Le tri à bulles est un algorithme de tri simple, mais souvent inefficace pour des listes de
grande taille. Voici un aperçu de son fonctionnement :
Fonctionnement :
1. Comparaison : L'algorithme parcourt la liste à plusieurs reprises. Pour chaque paire
d'éléments adjacents, il compare les deux éléments.
2. Échange : Si l'élément de gauche est plus grand que celui de droite, ils sont échangés.
3. Répétition : Ce processus est répété jusqu'à ce que la liste soit complètement triée.
L'algorithme continue jusqu'à ce qu'aucun échange ne soit nécessaire lors d'un
passage.
Complexité :
 Meilleur cas : O(n) (lorsque la liste est déjà triée).
 Moyen et pire cas : O(n²).
Illustration :
Supposons que nous avons la liste suivante : [5, 1, 4, 2, 8].
 Première passe :
o Compare 5 et 1 → Échange (1, 5, 4, 2, 8)
o Compare 5 et 4 → Échange (1, 4, 5, 2, 8)
o Compare 5 et 2 → Échange (1, 4, 2, 5, 8)
o Compare 5 et 8 → Pas d'échange (1, 4, 2, 5, 8)
 Deuxième passe :

2ème année MGSI [Link] 21

2024/2025
 o Compare 1 et 4 → Pas d'échange (1, 4, 2, 5, 8)
o Compare 4 et 2 → Échange (1, 2, 4, 5, 8)
o Compare 4 et 5 → Pas d'échange (1, 2, 4, 5, 8)
o Compare 5 et 8 → Pas d'échange (1, 2, 4, 5, 8)
Ce processus continue jusqu'à ce que la liste soit triée.
Exemple de code :

def bubble_sort(arr):
n = len(arr)
for i in range(n):
swapped = False
for j in range(0, n - i - 1):
if arr[j] > arr[j + 1]:
arr[j], arr[j + 1] = arr[j + 1], arr[j] # Échange
swapped = True
if not swapped: # Si aucune paire n'a été échangée, la liste est triée
break
# Exemple d'utilisation
ma_liste = [64, 34, 25, 12, 22, 11, 90]
bubble_sort(ma_liste)
print("Liste triée : ", ma_liste) # Affiche : Liste triée : [11, 12, 22, 25, 34, 64, 90]

8.2 Tri par Sélection (Selection Sort)

Le tri par sélection est également un algorithme simple et fonctionne comme suit :
Fonctionnement :
1. Recherche du minimum : L'algorithme divise la liste en deux parties : triée et non
triée. Il recherche l'élément le plus petit dans la partie non triée.
2. Échange : Une fois le plus petit élément trouvé, il est échangé avec le premier
élément de la partie non triée.
3. Répétition : Ce processus est répété, en déplaçant la frontière entre les parties triée
et non triée jusqu'à ce que toute la liste soit triée.

2ème année MGSI [Link] 22

2024/2025
Complexité :
 Meilleur, moyen et pire cas : O(n²).
Illustration :
Pour la liste [29, 10, 14, 37, 13]:
1. Trouver le minimum (10) et échanger avec le premier élément (29) → [10, 29, 14, 37,
13]
2. Trouver le minimum (13) et échanger avec 29 → [10, 13, 14, 37, 29]
3. Continuer jusqu'à ce que la liste soit triée → [10, 13, 14, 29, 37].
Exemple de code :

def selection_sort(arr):
n = len(arr)
for i in range(n):
min_index = i # On suppose que l'élément à la position i est le minimum
for j in range(i + 1, n):
if arr[j] < arr[min_index]:
min_index = j # Met à jour l'index du minimum
arr[i], arr[min_index] = arr[min_index], arr[i] # Échange
# Exemple d'utilisation
ma_liste = [64, 25, 12, 22, 11]
selection_sort(ma_liste)
print("Liste triée : ", ma_liste) # Affiche : Liste triée : [11, 12, 22, 25, 64]

8.3 Tri par Insertion (Insertion Sort)

Le tri par insertion construit progressivement une liste triée. Voici comment cela fonctionne :
Fonctionnement :
1. Début : Commence avec la première carte (ou élément) considérée comme triée.
2. Insertion : Pour chaque nouvel élément, le compare aux éléments de la partie triée
et l'insère à la bonne position.
3. Répétition : Cela se poursuit jusqu'à ce que tous les éléments soient triés.
Complexité :
 Meilleur cas : O(n) (lorsque la liste est déjà triée).

2ème année MGSI [Link] 23

2024/2025
  Moyen et pire cas : O(n²).
Illustration :
Pour la liste [5, 2, 9, 1, 5]:
 Démarrer avec 5. Liste triée : [5]
 Insérer 2 : [2, 5]
 Insérer 9 : [2, 5, 9]
 Insérer 1 : [1, 2, 5, 9]
 Insérer 5 : [1, 2, 5, 5, 9]
Exemple de code :

def insertion_sort(arr):
for i in range(1, len(arr)):
key = arr[i]
j=i-1
# Déplacer les éléments de arr[0..i-1] qui sont supérieurs à key vers une position en
avant de leur position actuelle
while j >= 0 and arr[j] > key:
arr[j + 1] = arr[j]
j -= 1
arr[j + 1] = key # Insérer l'élément à sa place
# Exemple d'utilisation
ma_liste = [12, 11, 13, 5, 6]
insertion_sort(ma_liste)
print("Liste triée : ", ma_liste) # Affiche : Liste triée : [5, 6, 11, 12, 13]

8.4 Tri Rapide (Quick Sort)

Le tri rapide est un algorithme efficace basé sur le principe de diviser pour régner.
Fonctionnement :
1. Choix du pivot : Un élément est sélectionné comme pivot (souvent le dernier
élément).

2ème année MGSI [Link] 24

2024/2025
 2. Partitionnement : La liste est réorganisée de sorte que les éléments inférieurs au
pivot soient à gauche et ceux supérieurs à droite.
3. Récursion : Le processus est récursivement appliqué aux sous-listes gauche et droite.
Complexité :
 Meilleur et moyen cas : O(n log n).
 Pire cas : O(n²) (lorsque la liste est déjà triée ou inversement triée, et que le pivot est
mal choisi).
Illustration :
Pour la liste [3, 6, 8, 10, 1, 2, 1]:
1. Choisir 1 comme pivot → Réorganiser → [0, 1, 1, 10, 8, 6, 3]
2. Appliquer récursivement sur les sous-listes.
Exemple de code :

def quick_sort(arr):
if len(arr) <= 1:
return arr
pivot = arr[len(arr) // 2]
left = [x for x in arr if x < pivot] # Éléments inférieurs
middle = [x for x in arr if x == pivot] # Éléments égaux
right = [x for x in arr if x > pivot] # Éléments supérieurs
return quick_sort(left) + middle + quick_sort(right) # Combinaison
# Exemple d'utilisation
ma_liste = [3, 6, 8, 10, 1, 2, 1]
sorted_list = quick_sort(ma_liste)
print("Liste triée : ", sorted_list) # Affiche : Liste triée : [1, 1, 2, 3, 6, 8, 10]

8.5 Tri par Fusion (Merge Sort)

Le tri par fusion est un autre algorithme de tri basé sur le principe de diviser pour régner.
Fonctionnement :
1. Diviser : La liste est divisée en deux moitiés jusqu'à ce que chaque sous-liste ait un
seul élément.
2. Fusionner : Les sous-listes sont ensuite fusionnées pour produire des listes triées.

2ème année MGSI [Link] 25

2024/2025
Complexité :
 Meilleur, moyen et pire cas : O(n log n).
Illustration :
Pour la liste [38, 27, 43, 3, 9, 82, 10]:
1. Diviser : [38, 27, 43], [3, 9, 82, 10]
2. Continuer jusqu'à avoir des listes de taille 1 : [38], [27], [43], [3], [9], [82], [10].
3. Fusionner en triant à chaque étape.
Exemple de code :

def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr) // 2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
return merge(left, right)
def merge(left, right):
result = []
i=j=0
# Fusionner les deux listes
while i < len(left) and j < len(right):
if left[i] < right[j]:
[Link](left[i])
i += 1
else:
[Link](right[j])
j += 1
[Link](left[i:])
[Link](right[j:])
return result

2ème année MGSI [Link] 26

2024/2025
# Exemple d'utilisation
ma_liste = [38, 27, 43, 3, 9, 82, 10]
sorted_list = merge_sort(ma_liste)
print("Liste triée : ", sorted_list) # Affiche : Liste triée : [3, 9, 10, 27, 38, 43, 82]

9. Algorithmes de Recherche

9.1 Recherche Séquentielle (ou Recherche Linéaire)

La recherche séquentielle est un algorithme de recherche simple qui consiste à parcourir une liste
d'éléments un par un pour trouver un élément cible. Cette méthode est généralement utilisée
lorsque les éléments de la liste ne sont pas triés.

Fonctionnement :

1. Initialisation : Commencez par le premier élément de la liste.

2. Comparaison : Comparez l'élément actuel avec l'élément cible.

3. Résultat :

o Si l'élément actuel correspond à l'élément cible, l'algorithme retourne l'index de cet

élément.

o Si l'élément actuel ne correspond pas, passez à l'élément suivant.

4. Fin : Répétez le processus jusqu'à ce que l'élément soit trouvé ou que la fin de la liste soit
atteinte.

Complexité :

 Meilleur cas : O(1) (lorsque l'élément cible est le premier de la liste).

 Moyen et pire cas : O(n) (lorsque l'élément est à la fin ou n'est pas présent).

Exemple de code :

def recherche_sequentielle(liste, cible):

for index, valeur in enumerate(liste): # Parcours de la liste avec index

if valeur == cible:

return index # Retourne l'index de l'élément trouvé

return -1 # Retourne -1 si l'élément n'est pas trouvé

# Exemple d'utilisation

ma_liste = [4, 2, 7, 1, 3]

resultat = recherche_sequentielle(ma_liste, 1)

print("Élément trouvé à l'index :", resultat) # Affiche : Élément trouvé à l'index : 3

Explication du Code :

2ème année MGSI [Link] 27

2024/2025
  enumerate(liste) : Cette fonction permet de parcourir la liste tout en récupérant à la fois
l'index et la valeur de chaque élément.

 Condition : Si la valeur actuelle correspond à la cible, l'index est retourné.

 Retourne -1 : Si l'élément n'est pas trouvé après avoir parcouru toute la liste.

9.2 Recherche par Dichotomie (ou Recherche Binaire)

La recherche par dichotomie est un algorithme de recherche efficace qui nécessite que la liste soit
triée. Elle fonctionne en divisant la liste en deux moitiés à chaque étape.

Fonctionnement :

1. Initialisation : Définissez les indices de début et de fin de la liste.

2. Calcul du milieu : Calculez l'index du milieu de la liste.

3. Comparaison :

o Si l'élément au milieu correspond à l'élément cible, l'algorithme retourne l'index du

milieu.

o Si l'élément au milieu est supérieur à la cible, répétez la recherche dans la moitié

gauche de la liste.

o Si l'élément au milieu est inférieur à la cible, répétez la recherche dans la moitié

droite de la liste.

4. Fin : Continuez ce processus jusqu'à ce que l'élément soit trouvé ou que les indices de début
et de fin se croisent.

Complexité :

 Meilleur cas : O(1) (lorsque l'élément cible est au milieu).

 Moyen et pire cas : O(log n).

Exemple de code :

def recherche_dichotomique(liste, cible):

[Link]() # Tri de la liste avant la recherche

bas = 0

haut = len(liste) - 1

while bas <= haut: # Tant que l'intervalle est valide

milieu = (bas + haut) // 2 # Calcul de l'index du milieu

if liste[milieu] == cible:

return milieu # Retourne l'index de l'élément trouvé

elif liste[milieu] < cible:

bas = milieu + 1 # Recherche dans la moitié droite

2ème année MGSI [Link] 28

2024/2025
 else:

haut = milieu - 1 # Recherche dans la moitié gauche

return -1 # Retourne -1 si l'élément n'est pas trouvé

# Exemple d'utilisation

ma_liste = [3, 1, 4, 2, 7] # Liste non triée

resultat = recherche_dichotomique(ma_liste, 4)

print("Élément trouvé à l'index :", resultat) # Affiche : Élément trouvé à l'index : 2

Explication du Code :

 Tri de la liste : Avant d'effectuer la recherche, la liste est triée avec [Link]().

 Indices bas et haut : Ces indices définissent la portion de la liste dans laquelle nous
effectuons la recherche.

 Calcul du milieu : L'index du milieu est calculé pour déterminer quelle moitié de la liste doit
être explorée.

 Conditions : En fonction de la comparaison entre l'élément au milieu et la cible, l'algorithme

ajuste les indices pour réduire l'intervalle de recherche.

10. Tuples et Dictionnaires en Python

10.1 Tuples

Définition :

Un tuple est une structure de données en Python qui permet de stocker une collection d'éléments.
Les tuples sont similaires aux listes, mais ils sont immuables, ce qui signifie que leurs éléments ne
peuvent pas être modifiés après leur création.

Caractéristiques :

 Immutabilité : Une fois créés, les tuples ne peuvent pas être modifiés.

 Ordre : Les éléments d'un tuple sont ordonnés.

 Accès aux éléments : Vous pouvez accéder aux éléments d'un tuple en utilisant des indices.

 Hétérogénéité : Un tuple peut contenir des éléments de différents types de données.

Syntaxe :

mon_tuple = (élément1, élément2, élément3)

Exemple de code :

# Création d'un tuple

mon_tuple = (1, "Python", 3.14)

2ème année MGSI [Link] 29

2024/2025
# Accès aux éléments

print("Premier élément :", mon_tuple[0]) # Affiche : Premier élément : 1

print("Deuxième élément :", mon_tuple[1]) # Affiche : Deuxième élément : Python

# Tentative de modification d'un élément (provoquera une erreur)

# mon_tuple[0] = 5 # Erreur : 'tuple' object does not support item assignment

# Longueur d'un tuple

print("Longueur du tuple :", len(mon_tuple)) # Affiche : Longueur du tuple : 3

10.2 Utilisation des Tuples :

Les tuples sont souvent utilisés pour :

 Retourner plusieurs valeurs à partir d'une fonction.

 Stocker des données qui ne doivent pas être modifiées, comme des coordonnées (latitude,
longitude).

 Utiliser comme clés dans les dictionnaires, car ils sont immuables.

10.3 Dictionnaires

Définition :

Un dictionnaire est une structure de données qui stocke des paires clé-valeur. Les clés doivent être
uniques et immuables, tandis que les valeurs peuvent être de n'importe quel type et peuvent être
dupliquées.

Caractéristiques :

 Mutable : Vous pouvez ajouter, modifier ou supprimer des éléments dans un dictionnaire.

 Accès par clé : Les valeurs sont accessibles via leurs clés, ce qui permet un accès rapide.

 Ordre : Depuis Python 3.7, les dictionnaires conservent l'ordre d'insertion des éléments.

Syntaxe :

mon_dictionnaire = {

"clé1": valeur1,

"clé2": valeur2,

"clé3": valeur3

Exemple de code :

# Création d'un dictionnaire

mon_dictionnaire = {

2ème année MGSI [Link] 30

2024/2025
 "nom": "Alice",

"âge": 25,

"ville": "Dakar"

# Accès aux valeurs

print("Nom :", mon_dictionnaire["nom"]) # Affiche : Nom : Alice

print("Âge :", mon_dictionnaire["âge"]) # Affiche : Âge : 25

# Ajout d'un nouvel élément

mon_dictionnaire["profession"] = "Ingénieur"

print("Dictionnaire après ajout :", mon_dictionnaire)

# Modification d'une valeur

mon_dictionnaire["âge"] = 26

print("Dictionnaire après modification :", mon_dictionnaire)

# Suppression d'un élément

del mon_dictionnaire["ville"]

print("Dictionnaire après suppression :", mon_dictionnaire)

# Longueur du dictionnaire

print("Nombre d'éléments dans le dictionnaire :", len(mon_dictionnaire)) # Affiche : Nombre

d'éléments dans le dictionnaire : 3

10.4 Utilisation des Dictionnaires :

Les dictionnaires sont souvent utilisés pour :

 Stocker des données associatives, où chaque valeur est liée à une clé.

 Modéliser des objets dans des programmes, par exemple, un étudiant avec des attributs
comme le nom, l'âge et la ville.

 Accéder rapidement aux valeurs en utilisant des clés, ce qui est plus efficace que d'utiliser
des listes pour des recherches.

Comparaison entre Tuples et Dictionnaires

Caractéristique Tuples Dictionnaires

2ème année MGSI [Link] 31

2024/2025
 Type de données Collection ordonnée d'éléments Paires clé-valeur

Immutabilité Immutables Mutables

Accès Par indice Par clé

Ordre Ordonné Ordonné (Python 3.7+)

11. Piles et Files

11.1 Piles (Stack)

Définition :

Une pile est une structure de données qui fonctionne selon le principe "dernier entré, premier sorti"
(Last In, First Out - LIFO). Cela signifie que l'élément ajouté en dernier sera le premier à être retiré.

Opérations Principales :

1. Empiler (Push) : Ajouter un élément au sommet de la pile.

2. Dépiler (Pop) : Retirer l'élément du sommet de la pile.

3. Regarder (Peek) : Obtenir l'élément au sommet de la pile sans le retirer.

4. Vérifier si vide : Savoir si la pile contient des éléments.

Exemple de code :

# Initialisation de la pile

pile = []

# Fonction pour empiler un élément

def empiler(element):

[Link](element) # Ajoute l'élément au sommet

# Fonction pour dépiler un élément

def depiler():

if not est_vide():

return [Link]() # Retire et retourne l'élément du sommet

return None # Renvoie None si la pile est vide

# Fonction pour voir le sommet de la pile

def sommet():

2ème année MGSI [Link] 32

2024/2025
 if not est_vide():

return pile[-1] # Retourne l'élément au sommet

return None # Renvoie None si la pile est vide

# Fonction pour vérifier si la pile est vide

def est_vide():

return len(pile) == 0 # Vérifie si la pile est vide

# Exemple d'utilisation

empiler(10)

empiler(20)

print("Sommet de la pile :", sommet()) # Affiche : Sommet de la pile : 20

print("Dépile :", depiler()) # Affiche : Dépile : 20

print("Sommet de la pile après dépile :", sommet()) # Affiche : Sommet de la pile après dépile : 10

11.2 Utilisation des Piles :

Les piles sont souvent utilisées dans :

 Les algorithmes de backtracking (retour en arrière).

 La gestion de l'historique des opérations, comme dans les navigateurs web.

 La vérification de la validité des parenthèses dans les expressions.

11.3 Files (Queue)

Définition :

Une file est une structure de données qui fonctionne selon le principe "premier entré, premier sorti"
(First In, First Out - FIFO). Cela signifie que l'élément ajouté en premier sera le premier à être retiré.

Opérations Principales :

1. Enfiler (Enqueue) : Ajouter un élément à la fin de la file.

2. Defiler (Dequeue) : Retirer l'élément du début de la file.

3. Regarder (Peek) : Obtenir l'élément au début de la file sans le retirer.

4. Vérifier si vide : Savoir si la file contient des éléments.

Exemple de code :

# Initialisation de la file

2ème année MGSI [Link] 33

2024/2025
file = []

# Fonction pour enfiler un élément

def enfiler(element):

[Link](element) # Ajoute l'élément à la fin de la file

# Fonction pour défiler un élément

def defiler():

if not est_vide():

return [Link](0) # Retire et retourne l'élément du début

return None # Renvoie None si la file est vide

# Fonction pour voir le premier élément de la file

def premier():

if not est_vide():

return file[0] # Retourne l'élément au début

return None # Renvoie None si la file est vide

# Fonction pour vérifier si la file est vide

def est_vide():

return len(file) == 0 # Vérifie si la file est vide

# Exemple d'utilisation

enfiler(10)

enfiler(20)

print("Premier élément de la file :", premier()) # Affiche : Premier élément de la file : 10

print("Défile :", defiler()) # Affiche : Défile : 10

print("Premier élément de la file après défile :", premier()) # Affiche : Premier élément de la file
après défile : 20

11.4 Utilisation des Files :

Les files sont souvent utilisées dans :

2ème année MGSI [Link] 34

2024/2025
  La gestion des tâches dans les systèmes d'exploitation.

 Le traitement des requêtes dans les serveurs.

 La simulation de files d'attente, comme les clients dans un magasin.

12. Date d’aujourd’hui

Pour obtenir la date actuelle en Python, vous pouvez utiliser le module datetime, qui fournit des
classes pour manipuler les dates et les heures. Voici un exemple de code pour obtenir la date
d'aujourd'hui :

from datetime import datetime

# Obtenir la date actuelle

date_aujourdhui = [Link]()

# Afficher la date

print("Date d'aujourd'hui :", date_aujourdhui.date())

Explication du code :

1. Importation du module : from datetime import datetime importe la classe datetime du

module datetime.

2. Obtenir la date actuelle : [Link]() renvoie la date et l'heure actuelles.

3. Afficher la date : date_aujourdhui.date() extrait uniquement la date (sans l'heure) de l'objet

datetime et l'affiche.

Exemple de sortie :

Si vous exécutez ce code, vous obtiendrez une sortie comme :

Date d'aujourd'hui : 2024-11-04

Cette sortie représente la date du jour au format YYYY-MM-DD.

13. Manipulation de Fichiers en Python

13.1 Introduction à la Manipulation de Fichiers

Manipuler des fichiers en Python permet de :

 Lire des données depuis un fichier existant.

 Écrire des données dans un nouveau fichier ou un fichier existant.

 Mettre à jour un fichier en ajoutant ou en modifiant son contenu.

 Gérer et organiser des fichiers pour des applications qui nécessitent un stockage persistant
de données.

13.2 Ouverture d’un Fichier

En Python, l’ouverture d’un fichier se fait avec la fonction open(). Cette fonction prend deux
paramètres principaux :

2ème année MGSI [Link] 35

2024/2025
  Nom du fichier : Le nom du fichier à ouvrir, avec ou sans chemin.

 Mode d’ouverture : Indique si le fichier doit être ouvert en lecture, écriture, ajout, etc.

Les modes d’ouverture de fichier :

Mode Description
'r' Lecture seule. Le fichier doit exister.
'w' Écriture seule. Crée un nouveau fichier ou écrase l'existant.
'a' Ajout. Écrit à la fin du fichier, sans écraser.
'r+' Lecture et écriture. Le fichier doit exister.
'w+' Lecture et écriture. Écrase le fichier existant ou en crée un nouveau.
'a+' Lecture et écriture en mode ajout. Le fichier est créé s’il n’existe pas.
Exemple de code : Ouverture d’un fichier en lecture

# Ouvrir un fichier en mode lecture

fichier = open("mon_fichier.txt", "r")

13.3 Lecture de Fichiers

Une fois le fichier ouvert en lecture, plusieurs méthodes permettent de lire son contenu.

1. Lire tout le contenu d’un fichier avec read().

2. Lire une seule ligne avec readline().

3. Lire toutes les lignes et obtenir une liste de lignes avec readlines().

Exemples de Lecture :

# Lire tout le contenu du fichier

with open("mon_fichier.txt", "r") as fichier:

contenu = [Link]()

print(contenu)

# Lire le fichier ligne par ligne

with open("mon_fichier.txt", "r") as fichier:

for ligne in fichier:

print([Link]()) # .strip() pour enlever les espaces ou sauts de ligne

Explication :

 with open(...) as fichier ouvre le fichier et garantit qu’il sera fermé automatiquement à la fin
du bloc.

 [Link]() lit tout le contenu comme une chaîne de caractères.

 for ligne in fichier permet de lire le fichier ligne par ligne.

13.4 Écriture dans un Fichier

Pour écrire dans un fichier, ouvrez-le avec un mode d’écriture ('w', 'a', ou 'w+').

2ème année MGSI [Link] 36

2024/2025
Exemples d'Écriture :

# Écrire du contenu dans un fichier (le fichier sera écrasé s’il existe déjà)

with open("mon_fichier.txt", "w") as fichier:

[Link]("Ceci est la première ligne.\n")

[Link]("Ceci est la seconde ligne.\n")

# Ajouter du contenu à la fin du fichier sans écraser l'existant

with open("mon_fichier.txt", "a") as fichier:

[Link]("Nouvelle ligne ajoutée.\n")

Explication :

 En mode 'w', le fichier est écrasé, tandis qu'en mode 'a', le contenu est ajouté à la fin.

 [Link]() écrit la chaîne donnée dans le fichier.

13.5 Fermeture d’un Fichier

Il est essentiel de fermer un fichier après utilisation pour libérer les ressources. Avec with open(...),
Python gère la fermeture automatiquement. Sinon, on peut utiliser [Link]() :

fichier = open("mon_fichier.txt", "r")

contenu = [Link]()

[Link]() # Fermer le fichier

12.6 Manipulations Avancées : Lecture et Écriture de Fichiers Texte

Lecture et écriture de chaque ligne avec des manipulations

# Lecture et écriture d'un fichier ligne par ligne

with open("mon_fichier.txt", "r") as fichier:

lignes = [Link]()

# Traitement de chaque ligne et écriture dans un nouveau fichier

with open("nouveau_fichier.txt", "w") as nouveau_fichier:

for ligne in lignes:

ligne_modifiee = [Link]() # Exemple : tout mettre en majuscule

nouveau_fichier.write(ligne_modifiee)

13.7 Fichiers Binaires

Les fichiers binaires sont manipulés différemment. Par exemple, pour lire ou écrire une image, un
fichier audio, etc., utilisez les modes 'rb' et 'wb' pour lire et écrire en binaire.

2ème année MGSI [Link] 37

2024/2025
# Lecture d'un fichier binaire (par exemple une image)

with open("[Link]", "rb") as fichier_binaire:

contenu = fichier_binaire.read()

# Écriture d'un fichier binaire

with open("copie_image.jpg", "wb") as fichier_binaire:

fichier_binaire.write(contenu)

13.8 Manipulation de Fichiers JSON

Python permet aussi de manipuler des fichiers JSON, souvent utilisés pour stocker des données
structurées.

import json

# Lecture d'un fichier JSON

with open("[Link]", "r") as fichier_json:

donnees = [Link](fichier_json)

print(donnees)

# Écriture dans un fichier JSON

donnees = {"nom": "Alice", "age": 25, "ville": "Paris"}

with open("[Link]", "w") as fichier_json:

[Link](donnees, fichier_json)

Explication :

 [Link]() lit un fichier JSON et convertit son contenu en dictionnaire.

 [Link]() prend un dictionnaire et écrit son contenu en format JSON dans un fichier.

13.9 Gestion des Exceptions lors de la Manipulation de Fichiers

Lorsqu’on manipule des fichiers, il est possible de rencontrer des erreurs, comme un fichier
inexistant. Pour les gérer, utilisez try...except.

try:

with open("fichier_inexistant.txt", "r") as fichier:

contenu = [Link]()

except FileNotFoundError:

print("Erreur : Le fichier n'existe pas.")

except IOError:

2ème année MGSI [Link] 38

2024/2025
 print("Erreur d'entrée/sortie.")

Explication :

 FileNotFoundError est levé si le fichier n’est pas trouvé.

 IOError gère d'autres erreurs d'entrée/sortie.

14. Programmation Orientée Objet (POO) en Python

La Programmation Orientée Objet (POO) est une méthode de structuration du code en organisant les
données et les comportements associés au sein de blocs logiques appelés "objets". En Python, la
POO simplifie la conception de programmes modulaires, réutilisables et extensibles.

14.1 Concepts Clés de la POO

Les principaux concepts de la POO sont :

1. Classe : C’est le modèle ou le plan de création d’objets. Elle définit les attributs (données) et
les méthodes (fonctions) que posséderont ses instances. Une classe ne fait rien toute seule ;
elle sert de "moule" pour créer des objets.

2. Objet : Une instance d’une classe. C’est une "copie" de la classe avec ses propres données.
Par exemple, si la classe est Voiture, chaque objet pourrait être une voiture spécifique
comme une "Toyota".

3. Attributs : Les données ou caractéristiques d'un objet. Par exemple, une voiture peut avoir
des attributs comme la couleur, la marque, le modèle, etc.

4. Méthodes : Fonctions qui définissent les actions possibles d’un objet. Par exemple, une
voiture peut avoir des méthodes comme demarrer, freiner, etc.

14.2 Définir une Classe

En Python, on définit une classe avec le mot-clé class, suivi du nom de la classe avec une majuscule
(par convention).

Exemple :

class Personne:

pass # Mot-clé `pass` signifie que la classe est vide pour l'instant.

Cette classe Personne ne contient rien pour l'instant. Elle sera complétée par des attributs et des
méthodes pour lui donner une utilité.

Pourquoi définir une classe ?

Définir une classe nous permet de créer un "plan" pour un type d’entité que l’on souhaite modéliser.
Dans notre exemple, Personne est un modèle de personne qui pourra avoir des caractéristiques
comme le nom, l'âge, etc., et des comportements spécifiques.

14.3 Créer un Objet

2ème année MGSI [Link] 39

2024/2025
Pour créer un objet, on appelle la classe comme une fonction. Cela génère une instance unique de la
classe, avec ses propres attributs et méthodes.

# Création d'un objet `personne1` basé sur la classe `Personne`

personne1 = Personne()

print(personne1) # Affiche l'adresse en mémoire de l'objet `personne1`

Explication

 personne1 est une instance de la classe Personne.

 Chaque instance est indépendante. Si on crée personne2 = Personne(), cela créera un nouvel
objet distinct de personne1.

14.4 Attributs d'Instance

Les attributs d'instance sont des variables propres à chaque objet. Ils se définissent dans une
méthode spéciale, appelée __init__, qui initialise les attributs dès la création d’un objet.

Exemple avec des attributs :

class Personne:

def __init__(self, nom, age):

[Link] = nom # Attribut d'instance `nom`

[Link] = age # Attribut d'instance `age`

# Création d'un objet avec des attributs spécifiques

personne1 = Personne("Alice", 30)

print([Link]) # Affiche "Alice"

print([Link]) # Affiche 30

Explication détaillée

 __init__ est une méthode spéciale appelée automatiquement lors de la création d’un objet.
C’est le "constructeur" en Python.

 self est une référence à l’objet en cours de création. Il est toujours le premier paramètre des
méthodes d’une classe et permet d’accéder aux attributs et aux méthodes de l’objet.

 [Link] et [Link] définissent des attributs propres à chaque instance de Personne.

14.5 Méthodes

Les méthodes sont des fonctions associées à une classe. Elles décrivent les actions que peuvent
réaliser les objets de cette classe.

Exemple d'une méthode dans la classe Personne :

2ème année MGSI [Link] 40

2024/2025
class Personne:

def __init__(self, nom, age):

[Link] = nom

[Link] = age

def se_presenter(self):

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

# Utilisation de la méthode `se_presenter`

personne1 = Personne("Alice", 30)

personne1.se_presenter() # Affiche "Bonjour, je m'appelle Alice et j'ai 30 ans."

Explication

 se_presenter est une méthode de la classe Personne.

 [Link] et [Link] sont des attributs d'instance, accessibles dans se_presenter.

 On appelle se_presenter avec personne1.se_presenter(), ce qui déclenche l'affichage du

message de présentation.

14.6 Attributs de Classe et Méthodes de Classe

Les attributs de classe sont partagés entre toutes les instances. Ils se définissent en dehors de
__init__.

Exemple :

class Personne:

espece = "Homo sapiens" # Attribut de classe, commun à toutes les instances

def __init__(self, nom):

[Link] = nom

personne1 = Personne("Alice")

personne2 = Personne("Bob")

print([Link]) # Affiche "Homo sapiens"

print([Link]) # Affiche "Homo sapiens"

Explication

2ème année MGSI [Link] 41

2024/2025
  espece est un attribut de classe ; toutes les instances partagent cette valeur.

 Si on change la valeur de espece, cela impactera toutes les instances.

14.7 Encapsulation

L’encapsulation est une manière de restreindre l’accès direct aux attributs et méthodes internes de
l’objet. En Python, un attribut précédé de deux underscores __ est considéré comme privé et n'est
pas accessible directement.

Exemple :

class CompteBancaire:

def __init__(self, solde):

self.__solde = solde # Attribut privé

def deposer(self, montant):

if montant > 0:

self.__solde += montant

def obtenir_solde(self):

return self.__solde

compte = CompteBancaire(100)

[Link](50)

print(compte.obtenir_solde()) # Affiche 150

Explication

 __solde est un attribut privé, accessible seulement via des méthodes comme obtenir_solde.

 [Link](50) ajoute 50 au solde sans exposer __solde directement.

14.8 Héritage

L'héritage permet de créer des classes dérivées d'une classe existante.

Exemple :

class Animal:

def __init__(self, nom):

[Link] = nom

class Chien(Animal):

2ème année MGSI [Link] 42

2024/2025
 def aboyer(self):

print("Woof!")

class Chat(Animal):

def miauler(self):

print("Meow!")

chien = Chien("Max")

[Link]() # Affiche "Woof!"

Explication

 Chien et Chat héritent d’Animal et disposent donc de nom.

14.9 Polymorphisme

Le polymorphisme permet d'utiliser une interface commune pour des classes différentes.

animaux = [Chien("Max"), Chat("Luna")]

for animal in animaux:

print(f"{[Link]} fait du bruit.")

# Appelle automatiquement aboyer() pour `Chien` et miauler() pour `Chat`

Explication

 animaux contient différents types d’objets (Chien et Chat).

 [Link]() ou [Link]() s’exécute selon le type d’instance.

Explication Détailée du Polymorphisme

1. Définition

Le polymorphisme peut être défini comme la capacité d'un langage de programmation à traiter des
objets de différents types via une interface commune. En Python, cela se traduit souvent par
l'utilisation de méthodes ayant le même nom dans différentes classes.

2. Types de Polymorphisme

Il existe principalement deux types de polymorphisme :

 Polymorphisme à la compilation (ou ad-hoc) : C'est la capacité de définir plusieurs fonctions

avec le même nom mais des signatures différentes. En Python, cela est moins courant, car il
ne prend pas en charge la surcharge de méthodes comme d'autres langages (par exemple,
C++ ou Java).

2ème année MGSI [Link] 43

2024/2025
  Polymorphisme à l'exécution (ou dynamique) : Cela se produit lorsqu'une méthode d'une
classe est remplacée par une méthode de la classe dérivée. C'est le type de polymorphisme
que nous utilisons généralement en Python.

3. Exemple de Polymorphisme

Prenons un exemple simple impliquant des formes géométriques.

class Forme:

def dessiner(self):

pass # Méthode vide, elle sera remplacée par les sous-classes

class Cercle(Forme):

def dessiner(self):

return "Dessin d'un cercle"

class Carre(Forme):

def dessiner(self):

return "Dessin d'un carré"

# Fonction qui utilise le polymorphisme

def dessiner_forme(forme):

print([Link]())

# Utilisation

forme1 = Cercle()

forme2 = Carre()

dessiner_forme(forme1) # Affiche "Dessin d'un cercle"

dessiner_forme(forme2) # Affiche "Dessin d'un carré"

Explication du Code

1. Classe de Base :

o Forme est une classe de base avec une méthode dessiner qui est vide. Cette
méthode sera redéfinie dans les classes dérivées.

2. Classes Dérivées :

o Cercle et Carre héritent de Forme et chacune redéfinit la méthode dessiner. Cela

signifie qu'elles fournissent leur propre implémentation de la méthode.

3. Fonction Générique :

2ème année MGSI [Link] 44

2024/2025
 o La fonction dessiner_forme accepte un objet de type Forme et appelle sa méthode
dessiner. Grâce au polymorphisme, que vous passiez un Cercle ou un Carre, la
méthode appropriée sera appelée.

4. Utilisation :

o Lorsque nous appelons dessiner_forme(forme1) ou dessiner_forme(forme2), Python

détermine dynamiquement quelle méthode dessiner utiliser en fonction du type de
l'objet passé.

Avantages du Polymorphisme

 Flexibilité : Vous pouvez écrire des fonctions ou des méthodes qui fonctionnent avec des
objets de classes différentes.

 Extensibilité : Il est facile d'ajouter de nouvelles classes sans modifier le code existant qui
utilise le polymorphisme.

 Réutilisabilité : Vous pouvez réutiliser du code commun pour des comportements similaires,
réduisant ainsi la duplication.

2ème année MGSI [Link] 45

2024/2025