Syllabus : Programmation Structurée en Python

Objectifs du Cours
 Comprendre les principes fondamentaux de la programmation structurée.
 Acquérir des compétences en programmation avec Python.
 Développer des algorithmes et résoudre des problèmes de manière efficace.

Prérequis
 Connaissances de base en informatique.
 Familiarité avec l'utilisation d'un ordinateur.

Durée
 10 leçons (2 heures par leçon)

Plan du Cours
Leçon 1 : Introduction à Python
 Présentation de Python et de ses caractéristiques.
 Installation de Python et des outils nécessaires (IDE, interpréteur).
 Première exécution d'un programme Python.

Leçon 2 : Syntaxe de Base

 Variables et types de données (int, float, string, bool).
 Opérateurs (arithmétiques, relationnels, logiques).
 Gestion des commentaires et des chaînes de documentation.

Leçon 3 : Structures de Contrôle

 Instructions conditionnelles (if, elif, else).
 Introduction aux boucles (for, while).
 Utilisation de break et continue.

Leçon 4 : Fonctions
 Définition et appel de fonctions.
 Paramètres et valeurs de retour.
 Portée des variables (locale vs globale).
 Documentation des fonctions.

Leçon 5 : Structures de Données de Base

 Listes et opérations sur les listes.
 Tuples et ensembles.
 Dictionnaires et leurs méthodes.
Leçon 6 : Gestion des Erreurs
 Introduction à la gestion des exceptions.
 Utilisation des blocs try, except, et finally.
 Création d'exceptions personnalisées.

Leçon 7 : Fichiers et Entrée/Sortie

 Lecture et écriture de fichiers texte.
 Gestion des fichiers avec le contexte (with).
 Introduction à la manipulation de fichiers CSV.

Leçon 8 : Modules et Packages

 Importation de modules standard.
 Création de modules personnalisés.
 Introduction aux packages et gestion des dépendances.

Leçon 9 : Programmation Orientée Objet (Introduction)

 Concepts de base de la POO (classes, objets, héritage).
 Différence entre la programmation structurée et la POO.
 Création de classes simples.

Leçon 10 : Projet Final

 Développement d'un projet de programmation structuré.
 Présentation des projets par les étudiants.
 Évaluation et retours.

Méthodes d'Évaluation
 Devoirs hebdomadaires.
 Quiz en ligne.
 Projet final.

Ressources Recommandées
 Livres :
 "Automate the Boring Stuff with Python" par Al Sweigart
 "Python Crash Course" par Eric Matthes
 Sites Web :
 [Link]
 W3Schools Python Tutorial

Leçon 1 : Introduction à Python

I-Présentation de Python

Qu'est-ce que Python ?

Python est un langage de programmation de haut niveau, interprété, et orienté objet. Il a été créé par
Guido van Rossum et a été publié pour la première fois en 1991. Python est conçu pour être simple
et facile à lire, ce qui en fait un excellent choix pour les débutants tout en étant puissant pour les
experts.

Caractéristiques de Python
1. Lisibilité du Code
 La syntaxe de Python est claire et concise, ce qui facilite la lecture et la
compréhension du code.
 L'utilisation de l'indentation pour définir les blocs de code aide à structurer le code de
manière logique.
2. Langage Interprété
 Python est un langage interprété, ce qui signifie que le code est exécuté ligne par
ligne par l'interpréteur Python. Ceci facilite le débogage et permet une exécution
interactive.
3. Typage Dynamique
 Les variables en Python n'ont pas besoin d'être déclarées avec un type spécifique. Le
type est déterminé automatiquement lors de l'exécution, ce qui rend le langage
flexible.
4. Large Bibliothèque Standard
 Python dispose d'une vaste bibliothèque standard qui inclut des modules pour la
manipulation de fichiers, la gestion des dates et heures, le traitement de données, et
bien plus encore.
5. Support pour la Programmation Orientée Objet
 Python prend en charge la programmation orientée objet, permettant l'utilisation de
classes et d'objets pour structurer le code.
 Ceci favorise la réutilisation du code et la modularité.
6. Multi-paradigme
 Python supporte plusieurs paradigmes de programmation, y compris la
programmation procédurale, orientée objet, et fonctionnelle.
7. Portabilité
 Python est un langage multiplateforme, ce qui signifie que le code écrit sur un
système d'exploitation peut être exécuté sur un autre sans modifications majeures.
8. Communauté Active
 Python a une communauté large et active, offrant de nombreuses ressources,
bibliothèques tierces et frameworks pour étendre ses fonctionnalités.
9. Applications Diverses
 Python est utilisé dans divers domaines, notamment le développement web, l'analyse
de données, l'intelligence artificielle, le machine learning, l'automatisation, et bien
d'autres.
II-Installation de Python et des Outils Nécessaires

1. Télécharger Python
 Site Officiel : Allez sur [Link].
 Choisir la Version : Téléchargez la dernière version stable de Python. Pour la plupart des
utilisateurs, la version recommandée (généralement marquée comme "Latest Release") est la
meilleure option.

2. Installer Python

Windows
1. Exécuter le Programme d’Installation :
 Double-cliquez sur le fichier .exe téléchargé.
2. Options d’Installation :
 Cochez la case "Add Python to PATH" pour faciliter l'utilisation de Python depuis
la ligne de commande.
 Cliquez sur "Install Now".
3. Vérification de l'Installation :
 Ouvrez l'invite de commandes (cmd) et tapez :
 python --version

 Vous devriez voir s'afficher la version de Python installée.

macOS
1. Exécuter le Programme d’Installation :
 Ouvrez le fichier .pkg téléchargé.
2. Suivre les Instructions :
 Cliquez sur "Continuer" à travers les étapes de l'assistant d'installation.
3. Vérification de l'Installation :
 Ouvrez le terminal et tapez :
 python3 --version

 Vous devriez voir la version de Python installée.

Linux
 Python est souvent préinstallé sur de nombreuses distributions Linux. Pour vérifier, ouvrez
un terminal et tapez :
 python3 --version

 Si Python n'est pas installé, utilisez le gestionnaire de paquets de votre distribution. Par
exemple, pour Ubuntu :
bash
  sudo apt update
sudo apt install python3

3. Installer un IDE (Environnement de Développement Intégré)

Un IDE facilite l'écriture, le débogage et l'exécution de votre code Python. Voici quelques IDE
populaires :

1. PyCharm
 Téléchargement : Rendez-vous sur JetBrains PyCharm.
 Installation : Suivez les instructions pour votre système d'exploitation.
 Configuration : Lancez PyCharm et configurez un nouveau projet en sélectionnant
l'interpréteur Python installé.

2. Visual Studio Code (VS Code)

 Téléchargement : Allez sur Visual Studio Code.
 Installation : Suivez les instructions pour votre système d'exploitation.
 Extensions : Installez l'extension Python depuis le Marketplace de VS Code pour bénéficier
d'une meilleure prise en charge de Python.

3. Jupyter Notebook
 Installation via pip : Si vous avez installé Python, vous pouvez installer Jupyter Notebook
en utilisant pip. Ouvrez un terminal ou une invite de commandes et tapez :
bash
 pip install notebook

 Lancer Jupyter Notebook : Dans le terminal, tapez :

bash
 jupyter notebook

 Cela ouvrira une interface web où vous pourrez créer et exécuter des notebooks Python.

4. Vérification de l'Installation des Outils

 Lancer l'IDE : Ouvrez l'IDE que vous avez installé (PyCharm, VS Code, etc.).
 Créer un Nouveau Fichier : Créez un nouveau fichier Python (par exemple, [Link]).
 Écrire du Code : Écrivez un simple programme :
python
 print("Hello, World!")

 Exécuter le Fichier : Exécutez le programme depuis l'IDE pour vérifier que tout fonctionne
correctement.
III-Première Exécution d'un Programme Python

1. Ouvrir votre IDE

Commencez par ouvrir l'IDE que vous avez installé (par exemple, PyCharm, Visual Studio Code,
ou Jupyter Notebook).

2. Créer un Nouveau Fichier Python

Dans PyCharm :
1. Créer un Nouveau Projet :
 Cliquez sur "File" > "New Project".
 Donnez un nom à votre projet et choisissez l'interpréteur Python.
2. Créer un Nouveau Fichier :
 Cliquez avec le bouton droit sur le dossier du projet dans l'arborescence.
 Sélectionnez "New" > "Python File".
 Nommez le fichier (par exemple, [Link]).

Dans Visual Studio Code :

1. Ouvrir le Dossier :
 Cliquez sur "File" > "Open Folder" et choisissez un dossier pour votre projet.
2. Créer un Nouveau Fichier :
 Cliquez sur "File" > "New File".
 Nommez le fichier [Link].

Dans Jupyter Notebook :

1. Créer un Nouveau Notebook :
 Ouvrez Jupyter Notebook dans votre navigateur.
 Cliquez sur "New" > "Python 3" pour créer un nouveau notebook.

3. Écrire le Code
Dans le fichier ou le notebook que vous avez créé, tapez le code suivant :
python
print("Hello, World!")

4. Exécuter le Code

Dans PyCharm :
 Cliquez sur le bouton de lecture (Run) en haut à droite, ou faites un clic droit sur le fichier
dans l'arborescence et sélectionnez "Run 'hello'".

Dans Visual Studio Code :

 Vous pouvez exécuter le code en utilisant le terminal intégré. Ouvrez le terminal via "View"
> "Terminal" et tapez :
 bash
 python [Link]

 Alternativement, si vous avez l'extension Python installée, vous pouvez également cliquer
sur "Run Python File" dans le coin supérieur droit.

Dans Jupyter Notebook :

 Cliquez sur la cellule contenant le code et appuyez sur Shift + Enter pour exécuter la
cellule.

5. Vérifier le Résultat
Après avoir exécuté le code, vous devriez voir le texte suivant affiché dans la console ou le terminal
:
Hello, World!

Leçon 2 : Syntaxe de Base

I-Variables et Types de Données en Python

1. Qu'est-ce qu'une Variable ?

Une variable est un espace de stockage qui possède un nom et qui peut contenir des données. En
Python, vous n'avez pas besoin de déclarer le type d'une variable avant de l'utiliser. Vous pouvez
simplement l'assigner à une valeur.

Exemples de Déclaration de Variables :

python
nom = "Alice" # Chaîne de caractères
age = 25 # Entier
taille = 1.75 # Flottant
est_etudiant = True # Booléen

2. Types de Données
Python prend en charge plusieurs types de données, dont les plus courants sont :

a. int (Entier)
 Représente des nombres entiers, positifs ou négatifs, sans décimales.
 Exemples :
python
 age = 30
annee = 2024
b. float (Flottant)
 Représente des nombres à virgule flottante, c'est-à-dire des nombres réels, y compris les
décimales.
 Exemples :
python
 temperature = 36.6
prix = 19.99

c. string (Chaîne de Caractères)

 Représente une séquence de caractères. Les chaînes de caractères peuvent être définies par
des guillemets simples (') ou doubles (").
 Exemples :
python
 nom = "Bob"
ville = 'Paris'
message = "Bonjour, comment ça va ?"

 Concaténation de chaînes :
python
 nom_complet = nom + " Dupont" # "Bob Dupont"

d. bool (Booléen)
 Représente une valeur de vérité : soit True (vrai) soit False (faux). Utilisé pour les
conditions et les comparaisons.
 Exemples :
python
 est_majeur = age >= 18 # True si age est supérieur ou égal à
18
a_des_animaux = False

3. Vérification du Type de Données

Vous pouvez utiliser la fonction type() pour vérifier le type d'une variable :

python
print(type(nom)) # <class 'str'>
print(type(age)) # <class 'int'>
print(type(temperature)) # <class 'float'>
print(type(est_etudiant)) # <class 'bool'>

4. Conversion de Types
Il est souvent nécessaire de convertir une variable d'un type à un autre. Voici quelques conversions
courantes :
 Convertir en entier :
 python
 age_str = "25"
age_int = int(age_str) # Convertit une chaîne en entier

 Convertir en flottant :
python
 prix_str = "19.99"
prix_float = float(prix_str) # Convertit une chaîne en flottant

 Convertir en chaîne :
python
 nombre = 100
nombre_str = str(nombre) # Convertit un entier en chaîne

5. Opérations avec les Types de Données

 Entiers et Flottants :
Vous pouvez effectuer des opérations arithmétiques sur les entiers et les flottants.
python
 somme = age + 5 # Addition
division = 10 / 3 # Division (renvoie un float)

 Chaînes :
Vous pouvez utiliser des opérations telles que la concaténation et la multiplication.
python
 nom = "Alice"
message = nom * 3 # "AliceAliceAlice"

II-Opérateurs en Python

1. Opérateurs Arithmétiques
Les opérateurs arithmétiques sont utilisés pour effectuer des opérations mathématiques sur des
nombres. Voici les principaux opérateurs arithmétiques en Python :
Exemples :
python
a = 10
b = 3

somme = a + b # 13
difference = a - b # 7
produit = a * b # 30
division = a / b # 3.333...
division_entiere = a // b # 3
reste = a % b # 1
puissance = a ** b # 1000

2. Opérateurs Relationnels
Les opérateurs relationnels sont utilisés pour comparer deux valeurs. Ils renvoient toujours un
booléen (True ou False).

Exemples :
python
a = 10
b = 5

est_egal = a == b # False
est_different = a != b # True
est_superieur = a > b # True
est_inferieur = a < b # False
superieur_ou_egal = a >= b # True
inferieur_ou_egal = a <= b # False

3. Opérateurs Logiques
Les opérateurs logiques sont utilisés pour combiner des expressions booléennes. Ils renvoient
également un booléen.
Exemples :
python
a = True
b = False

et_logique = a and b # False

ou_logique = a or b # True
negation = not a # False

4. Priorité des Opérateurs

La priorité des opérateurs détermine l'ordre dans lequel les opérations sont effectuées dans une
expression. Voici l'ordre de priorité du plus élevé au plus bas :
1. Parenthèses ()
2. Puissance **
3. Multiplication, Division, Division entière, Modulo *, /, //, %
4. Addition, Soustraction +, -
5. Comparaisons ==, !=, <, >, <=, >=
6. Logiques not, and, or

Exemple de Priorité :
python
resultat = 5 + 3 * 2 # 11 (3*2 est calculé en premier)

III-Gestion des Commentaires et des Chaînes de Documentation en Python

1. Commentaires
Les commentaires sont des parties du code qui ne sont pas exécutées. Ils sont utilisés pour expliquer
le code, rendre celui-ci plus lisible et aider les autres (ou vous-même) à comprendre le
fonctionnement du programme. En Python, il existe deux types de commentaires :

a. Commentaires sur une seule ligne

Ces commentaires commencent par le symbole #. Tout ce qui suit ce symbole sur la même ligne est
ignoré par l'interpréteur Python.
Exemple :
python
# Ceci est un commentaire
a = 10 # Déclaration d'une variable entière

b. Commentaires sur plusieurs lignes

Pour les commentaires qui s'étendent sur plusieurs lignes, vous pouvez utiliser plusieurs # ou des
chaînes de caractères multilignes (triple guillemet). Bien que trois guillemets ne soient pas des
commentaires au sens strict, ils peuvent être utilisés comme tels.
Exemple avec plusieurs # :

python
# Ceci est un commentaire
# qui s'étend sur plusieurs lignes

Exemple avec des chaînes de caractères multilignes :

python
"""
Ceci est une chaîne de caractères
multilignes utilisée comme commentaire.
"""

2. Chaînes de Documentation (Docstrings)

Les chaînes de documentation, ou docstrings, sont des chaînes de caractères utilisées pour
documenter des modules, des classes, ou des fonctions. Elles permettent de fournir des informations
sur le comportement et l'utilisation d'un élément de code. En Python, les docstrings sont définies en
utilisant des triples guillemets (""" ou ''').

a. Syntaxe d'une Docstring

Les docstrings doivent être placées immédiatement après la définition d'une fonction, d'une classe
ou d'un module.
Exemple :
python
def somme(a, b):
"""
Calcule la somme de deux nombres.

Parameters:
a (int, float): Le premier nombre.
b (int, float): Le second nombre.

Returns:
int, float: La somme de a et b.
 """
return a + b

b. Accéder aux Docstrings

Vous pouvez accéder à la docstring d'une fonction ou d'une classe en utilisant l'attribut __doc__.

Exemple :
python
print(somme.__doc__)

3. Importance des Commentaires et des Docstrings

 Lisibilité : Les commentaires et les docstrings améliorent la lisibilité du code, ce qui est
essentiel pour le travail en équipe et la maintenance du code.
 Documentation : Les docstrings offrent une documentation intégrée qui peut être utilisée
par des outils de documentation automatique comme Sphinx.
 Clarté : Ils aident à clarifier l'intention du code, ce qui facilite la compréhension des
algorithmes et des fonctions.

4. Bonnes Pratiques
 Commenter le Pourquoi, Pas le Quoi : Évitez de commenter des choses évidentes.
Concentrez-vous sur le pourquoi du code plutôt que sur le quoi.
 Mettre à Jour : Assurez-vous que les commentaires et les docstrings sont à jour avec le
code. Des commentaires obsolètes peuvent être plus nuisibles qu'utile.
 Utiliser des Docstrings : Utilisez des docstrings pour toutes vos fonctions et classes afin de
fournir des informations utiles sur leur utilisation.
Leçon 3 : Structures de Contrôle
I-Instructions conditionnelles (if, elif, else).
Les instructions conditionnelles permettent d'exécuter différentes sections de code en fonction de
certaines conditions. Cela vous permet de contrôler le flux de votre programme en prenant des
décisions basées sur des expressions booléennes.

1. Structure de base d'une instruction if

La structure de base d'une instruction if est la suivante :

python
if condition:
# Code à exécuter si la condition est vraie

Exemple :
python
age = 18

if age >= 18:

 print("Vous êtes majeur.")

2. Instructions elif
L'instruction elif (qui signifie "else if") permet de vérifier plusieurs conditions. Si la première
condition if est fausse, Python teste la condition elif. Vous pouvez avoir plusieurs instructions
elif.

Exemple :
python
age = 16

if age >= 18:

print("Vous êtes majeur.")
elif age >= 13:
print("Vous êtes un adolescent.")
else:
print("Vous êtes un enfant.")

3. Instruction else
L'instruction else est utilisée pour exécuter un bloc de code si toutes les conditions précédentes
(if et elif) sont fausses. Il n'accepte pas de condition.

Exemple :
python
age = 10

if age >= 18:

print("Vous êtes majeur.")
elif age >= 13:
print("Vous êtes un adolescent.")
else:
print("Vous êtes un enfant.")

4. Combinaison des Instructions

Vous pouvez combiner plusieurs conditions en utilisant des opérateurs logiques (and, or, not)
pour créer des conditions plus complexes.

Exemple :
python
age = 20
scolarise = True

if age >= 18 and scolarise:

print("Vous êtes un étudiant majeur.")
elif age >= 18:
 print("Vous êtes un majeur.")
else:
print("Vous êtes un mineur.")

5. Indentation
L'indentation est cruciale en Python. Elle détermine le bloc de code qui appartient à chaque
instruction conditionnelle. Assurez-vous d'utiliser le même niveau d'indentation pour toutes les
lignes d'un même bloc.

Exemple :
python
if True:
print("Ceci est vrai.")
print("Ceci fait partie du même bloc.")
print("Ceci n'est pas indenté, donc hors du bloc.")

6. Exemple Complet
Voici un exemple complet d'utilisation des instructions conditionnelles :
python
note = 85

if note >= 90:

print("A")
elif note >= 80:
print("B")
elif note >= 70:
print("C")
elif note >= 60:
print("D")
else:
print("F")

II-Introduction aux boucles (for, while).

Les boucles sont des structures de contrôle qui permettent de répéter un bloc de code plusieurs fois.
Elles sont essentielles pour automatiser les tâches et gérer des collections de données.

1. Boucle for
La boucle for est utilisée pour itérer sur les éléments d'une séquence (comme une liste, un tuple,
une chaîne de caractères, ou un dictionnaire). Elle est particulièrement utile lorsque vous connaissez
le nombre d'itérations à l'avance.

Syntaxe :
python
for variable in séquence:
# Code à exécuter pour chaque élément
Exemples :
Itération sur une liste :
python
fruits = ["pomme", "banane", "cerise"]

for fruit in fruits:

print(fruit)

Itération sur une chaîne de caractères :

python
mot = "Python"

for lettre in mot:

print(lettre)

Utilisation de range() :

La fonction range() génère une séquence de nombres. Elle est souvent utilisée avec for pour
répéter un bloc de code un certain nombre de fois.
python
for i in range(5): # De 0 à 4
print(i)

2. Boucle while
La boucle while continue d'exécuter un bloc de code tant qu'une condition est vraie. Elle est utile
lorsque le nombre d'itérations n'est pas connu à l'avance.

Syntaxe :
python
while condition:
# Code à exécuter tant que la condition est vraie

Exemples :
python
compteur = 0

while compteur < 5:

print(compteur)
compteur += 1 # Incrémente le compteur

3. Instructions break et continue

 break : Utilisé pour sortir immédiatement de la boucle, quel que soit l'état de la condition.
 Exemple :
python
 for i in range(10):
if i == 5:
break # Sort de la boucle lorsque i est égal à 5
print(i)

 continue : Utilisé pour sauter l'itération en cours et passer à la suivante.

Exemple :
python
 for i in range(5):
if i == 2:
continue # Sauter l'itération lorsque i est égal à 2
print(i)

4. Boucles Imbriquées
Vous pouvez avoir des boucles à l'intérieur d'autres boucles. Cela peut être utile pour traiter des
structures de données plus complexes.
Exemple :
python
for i in range(3): # Boucle externe
for j in range(2): # Boucle interne
print(f"i: {i}, j: {j}")

III-Utilisation de break et continue.

Les instructions break et continue sont des outils puissants pour contrôler le flux d'exécution
des boucles. Elles vous permettent de modifier le comportement par défaut des boucles for et
while.

1. Instruction break
L'instruction break est utilisée pour sortir immédiatement d'une boucle, quel que soit l'état de la
condition. Cela peut être utile lorsque vous souhaitez interrompre une boucle en fonction d'une
condition spécifique.

Exemple d'utilisation de break

Exemple 1 : Arrêter une boucle lorsque la condition est remplie
python
for i in range(10):
if i == 5:
break # Sortir de la boucle lorsque i est égal à 5
print(i)
Sortie :
0
1
2
3
4

Dans cet exemple, la boucle for s'arrête dès que la variable i atteint la valeur 5. Les valeurs 5, 6,
7, 8, et 9 ne seront pas imprimées.
Exemple 2 : Utiliser break dans une boucle while

python
compteur = 0

while True: # Boucle infinie

if compteur >= 3:
break # Sortir de la boucle lorsque le compteur atteint 3
print(compteur)
compteur += 1

Sortie :
0
1
2

2. Instruction continue
L'instruction continue est utilisée pour sauter l'itération en cours de la boucle et passer à
l'itération suivante. Lorsque continue est rencontré, le reste du code dans la boucle pour cette
itération n'est pas exécuté.

Exemple d'utilisation de continue

Exemple 1 : Sauter une valeur spécifique
python
for i in range(5):
if i == 2:
continue # Sauter l'itération lorsque i est égal à 2
print(i)

Sortie :
0
1
3
4

Dans cet exemple, lorsque i vaut 2, l'instruction continue est exécutée, et l'itération est sautée.
La valeur 2 n'est donc pas imprimée.
Exemple 2 : Utiliser continue dans une boucle while

python
compteur = 0

while compteur < 5:

compteur += 1
if compteur == 3:
continue # Sauter l'itération lorsque le compteur est
égal à 3
print(compteur)

Sortie :
1
2
4
5

3. Combinaison de break et continue

Il est possible d'utiliser break et continue dans la même boucle. Cela vous permet de gérer des
conditions complexes.
python
for i in range(6):
if i == 4:
break # Sortir de la boucle lorsque i est égal à 4
if i % 2 == 0:
continue # Sauter les nombres pairs
print(i)

Sortie :
1
3

Leçon 4 : Fonctions
A. Définition d'une fonction
Une fonction en Python est un bloc de code réutilisable qui effectue une tâche spécifique. Elle peut
prendre des arguments en entrée et peut renvoyer une valeur.

1. Syntaxe de définition d'une fonction

La syntaxe pour définir une fonction est la suivante :
def nom_de_fonction(paramètres):
# Corps de la fonction
instructions
return valeur # Optionnel
2. Exemples de définition
 Fonction sans paramètres :
 def saluer():
print("Bonjour !")

 Fonction avec paramètres :

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

 Fonction avec paramètres par défaut :

 def saluer(nom="Invité"):
print(f"Bonjour, {nom} !")

B. Appel de fonctions
Pour exécuter une fonction, vous devez l'appeler en utilisant son nom et en fournissant les
arguments nécessaires.

1. Syntaxe d'appel
nom_de_fonction(argument1, argument2)

2. Exemples d'appel
 Appel d'une fonction sans paramètres :
 saluer() # Affiche "Bonjour !"

 Appel d'une fonction avec paramètres :

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

 Appel d'une fonction avec paramètres par défaut :

 saluer("Alice") # Affiche "Bonjour, Alice !"
saluer() # Affiche "Bonjour, Invité !"

C. Valeurs de retour
Les fonctions peuvent renvoyer des valeurs à l'aide de l'instruction return. Si aucune valeur n'est
renvoyée, la fonction renvoie None.

Exemple :
python
def carre(x):
return x * x

resultat = carre(4)
print(resultat) # Affiche 16
D. Importance des fonctions
 Réutilisabilité : Les fonctions permettent de réutiliser le code sans duplication.
 Lisibilité : Elles aident à organiser le code et à le rendre plus lisible.
 Modularité : Les fonctions favorisent une approche modulaire dans le développement de
logiciels.
II-Paramètres et valeurs de retour.
A. Paramètres de fonction
Les paramètres permettent de passer des valeurs à une fonction lors de son appel. Ils agissent
comme des variables locales à l'intérieur de la fonction.

1. Types de paramètres
 Paramètres positionnels : Les valeurs doivent être fournies dans le même ordre que les
paramètres définis.
 def multiplier(a, b):
return a * b

resultat = multiplier(3, 4) # a=3, b=4

 Paramètres par défaut : Vous pouvez définir des valeurs par défaut pour les paramètres. Si
l'argument n'est pas fourni, la valeur par défaut sera utilisée.
 def saluer(nom="Invité"):
print(f"Bonjour, {nom} !")

saluer() # Affiche "Bonjour, Invité !"

saluer("Alice") # Affiche "Bonjour, Alice !"

 Paramètres nommés : Lors de l'appel d'une fonction, vous pouvez spécifier les noms des
paramètres pour plus de clarté.
 def afficher_info(nom, age):
print(f"{nom} a {age} ans.")

afficher_info(age=25, nom="Bob") # Les arguments sont fournis par nom

 Paramètres variables : Utilisez *args pour passer un nombre variable d'arguments

positionnels et **kwargs pour un nombre variable d'arguments nommés.
 def somme(*args):
return sum(args)

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

def afficher_kwargs(**kwargs):
for clé, valeur in [Link]():
print(f"{clé}: {valeur}")

afficher_kwargs(nom="Alice", age=30) # Affiche les paires clé-valeur

B. Valeurs de retour
Les valeurs de retour permettent à une fonction de renvoyer des résultats à l'endroit où elle a été
appelée.
1. Utilisation de return
L'instruction return termine l'exécution de la fonction et renvoie une valeur.
def carre(x):
return x * x

resultat = carre(5)
print(resultat) # Affiche 25

2. Retourner plusieurs valeurs

Une fonction peut renvoyer plusieurs valeurs sous forme de tuple.
def calculs(x, y):
somme = x + y
difference = x - y
return somme, difference

s, d = calculs(10, 5)
print(s) # Affiche 15
print(d) # Affiche 5

3. Valeur de retour implicite

Si aucune instruction return n'est fournie, la fonction renvoie None par défaut.
def fonction_sans_retour():
print("Ceci est une fonction sans valeur de retour.")

resultat = fonction_sans_retour()
print(resultat) # Affiche None

C. Importance des paramètres et des valeurs de retour

 Flexibilité : Les paramètres permettent de rendre les fonctions dynamiques et adaptables.
 Clarté : Les valeurs de retour clarifient le résultat d'une opération, rendant le code plus
compréhensible.
 Modularité : La séparation des calculs dans des fonctions distinctes facilite la maintenance
et les tests.
III-Portée des variables (locale vs globale).
A. Définition de la portée des variables
La portée d'une variable fait référence à la région du programme où la variable est accessible. En
Python, les variables peuvent être classées en deux catégories principales : locales et globales.

B. Variables locales
Les variables locales sont définies à l'intérieur d'une fonction et ne sont accessibles qu'à l'intérieur
de cette fonction. Elles sont créées lorsqu'une fonction est appelée et détruites lorsque la fonction se
termine.

1. Exemple de variable locale

def ma_fonction():
x = 10 # Variable locale
print(f"À l'intérieur de la fonction : x = {x}")
ma_fonction() # Affiche : À l'intérieur de la fonction : x = 10
# print(x) # Cela provoquerait une erreur, car x n'est pas accessible ici

C. Variables globales
Les variables globales sont définies en dehors de toutes les fonctions et peuvent être accessibles
depuis n'importe quelle fonction du même module. Elles conservent leur valeur tant que le
programme est en cours d'exécution.

1. Exemple de variable globale

y = 20 # Variable globale

def autre_fonction():
print(f"À l'intérieur de la fonction : y = {y}")

autre_fonction() # Affiche : À l'intérieur de la fonction : y = 20

D. Modifications des variables globales

Pour modifier une variable globale à l'intérieur d'une fonction, vous devez utiliser le mot-clé
global. Cela indique à Python que vous souhaitez utiliser la variable globale, et non créer une
nouvelle variable locale.

1. Exemple de modification d'une variable globale

z = 30 # Variable globale

def modifier_z():
global z # Indique que nous voulons utiliser la variable globale z
z += 10 # Modifie la variable globale
print(f"À l'intérieur de la fonction : z = {z}")

modifier_z() # Affiche : À l'intérieur de la fonction : z = 40

print(z) # Affiche : 40

E. Portée et bonnes pratiques

 Utiliser des variables locales : Il est recommandé d'utiliser des variables locales chaque fois
que cela est possible pour éviter des effets secondaires non souhaités.
 Éviter les variables globales : L'utilisation excessive de variables globales peut rendre le
code difficile à comprendre et à maintenir. Il est préférable de passer des arguments aux
fonctions et de renvoyer des valeurs.
 Clarté du code : Maintenir une portée claire aide à rendre le code plus lisible et facilite le
débogage.
IV-Documentation des fonctions.
A. Importance de la documentation
La documentation des fonctions est essentielle pour :
 Clarté : Expliquer le fonctionnement d'une fonction.
 Utilisabilité : Aider les autres développeurs (ou vous-même) à comprendre comment utiliser
une fonction.
  Maintenance : Faciliter la mise à jour et la modification du code.

B. Comment documenter une fonction

En Python, la documentation d'une fonction se fait principalement à l'aide de docstrings (chaînes de
documentation). Une docstring est une chaîne de caractères qui décrit la fonction et est placée
immédiatement après la déclaration de la fonction.

1. Syntaxe d'une docstring

La docstring est entourée de triples guillemets (''' ou """) et peut s'étendre sur plusieurs lignes.
def nom_de_fonction(paramètres):
"""
Description de la fonction.

Args:
paramètre1 (type): Description du paramètre1.
paramètre2 (type): Description du paramètre2.

Returns:
type: Description de la valeur de retour.
"""
# Corps de la fonction
pass

C. Exemples de documentation de fonction

1. Exemple simple
def addition(a, b):
"""
Calcule la somme de deux nombres.

Args:
a (int ou float): Le premier nombre.
b (int ou float): Le deuxième nombre.

Returns:
int ou float: La somme de a et b.
"""
return a + b

2. Exemple avec des exceptions

def division(numerateur, denominateur):
"""
Effectue la division de deux nombres.

Args:
numerateur (float): Le numérateur.
denominateur (float): Le dénominateur.

Returns:
float: Le résultat de la division.

Raises:
ValueError: Si le dénominateur est zéro.
"""
if denominateur == 0:
 raise ValueError("Le dénominateur ne peut pas être zéro.")
return numerateur / denominateur

D. Accéder à la documentation d'une fonction

En Python, vous pouvez accéder à la docstring d'une fonction en utilisant la fonction help() ou en
accédant à l'attribut __doc__.

1. Utilisation de help()
help(addition)

2. Accès à __doc__
python
print(addition.__doc__)

E. Bonnes pratiques de documentation

 Soyez concis : La description doit être claire et aller droit au but.
 Utilisez un format cohérent : Suivez un format similaire pour toutes vos docstrings.
 Mettez à jour la documentation : Assurez-vous que la documentation est à jour avec le
code.
Leçon 5 : Structures de Données de Base
I-Listes et opérations sur les listes.

A. Définition des listes

Une liste en Python est une collection ordonnée, mutable (modifiable) et pouvant contenir des
éléments de différents types. Les listes sont définies en utilisant des crochets [].

1. Création d'une liste

# Liste vide
ma_liste = []

# Liste avec des éléments

nombres = [1, 2, 3, 4, 5]
fruits = ["pomme", "banane", "cerise"]
melange = [1, "deux", 3.0, True]

B. Accès aux éléments d'une liste

Les éléments d'une liste peuvent être accédés par leur index, qui commence à 0.
# Accéder au premier élément
premier_fruit = fruits[0] # "pomme"

# Accéder au dernier élément

dernier_fruit = fruits[-1] # "cerise"
C. Opérations sur les listes
1. Ajouter des éléments
 append() : Ajoute un élément à la fin de la liste.
 [Link]("orange") # fruits devient ["pomme", "banane", "cerise",
"orange"]

 insert() : Insère un élément à un index spécifique.

 [Link](1, "kiwi") # fruits devient ["pomme", "kiwi", "banane",
"cerise", "orange"]

2. Supprimer des éléments

 remove() : Supprime la première occurrence d'un élément.
 [Link]("banane") # fruits devient ["pomme", "kiwi", "cerise",
"orange"]

 pop() : Supprime et renvoie un élément à un index spécifique (par défaut, le dernier

élément).
 dernier_fruit = [Link]() # "orange", fruits devient ["pomme", "kiwi",
"cerise"]

 clear() : Supprime tous les éléments de la liste.

 [Link]() # fruits devient []

3. Modifier des éléments

Les éléments d'une liste peuvent être modifiés en utilisant leur index.
fruits[0] = "fraise" # fruits devient ["fraise", "kiwi", "cerise"]

4. Trier des listes

 sort() : Trie la liste en place.
 nombres = [5, 2, 9, 1]
[Link]() # nombres devient [1, 2, 5, 9]

 sorted() : Renvoie une nouvelle liste triée sans modifier l'originale.

 nouveaux_nombres = sorted(nombres) # [1, 2, 5, 9]

5. Longueur d'une liste

Pour obtenir le nombre d'éléments dans une liste, utilisez len().
taille = len(fruits) # Nombre d'éléments dans fruits

D. Itérer sur une liste

Vous pouvez parcourir une liste à l'aide d'une boucle for.
for fruit in fruits:
print(fruit)

E. Listes imbriquées
Les listes peuvent contenir d'autres listes, ce qui permet de créer des listes imbriquées.
matrice = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
print(matrice[1][2]) # Affiche 6

II-Tuples et ensembles.
A. Tuples
1. Définition
Un tuple est une collection ordonnée d'éléments qui est immuable (non modifiable). Les tuples sont
définis en utilisant des parenthèses ().

2. Création d'un tuple

# Tuple vide
mon_tuple_vide = ()

# Tuple avec des éléments

mon_tuple = (1, 2, 3)
fruits = ("pomme", "banane", "cerise")
melange = (1, "deux", 3.0, True)

3. Accès aux éléments

Les éléments d'un tuple peuvent être accédés par leur index, tout comme les listes.
premier_fruit = fruits[0] # "pomme"
dernier_fruit = fruits[-1] # "cerise"

4. Caractéristiques des tuples

 Immutabilité : Une fois créés, les éléments d'un tuple ne peuvent pas être modifiés ou
supprimés.
 # fruits[0] = "kiwi" # Provoquerait une erreur

 Utilisation : Les tuples sont souvent utilisés pour des données qui ne doivent pas changer,
comme les coordonnées, les dates, etc.

5. Opérations sur les tuples

 Concaténation : Vous pouvez combiner des tuples à l'aide de l'opérateur +.
 tuple1 = (1, 2)
tuple2 = (3, 4)
tuple_combined = tuple1 + tuple2 # (1, 2, 3, 4)

 Répétition : Vous pouvez répéter un tuple avec l'opérateur *.

 tuple_repe = (1, 2) * 3 # (1, 2, 1, 2, 1, 2)

 Longueur : Utilisez len() pour obtenir le nombre d'éléments dans un tuple.

  longueur = len(fruits) # 3

B. Ensembles
1. Définition
Un ensemble est une collection non ordonnée d'éléments uniques. Les ensembles sont définis en
utilisant des accolades {} ou la fonction set().

2. Création d'un ensemble

# Ensemble vide
mon_ensemble_vide = set()

# Ensemble avec des éléments

mon_ensemble = {1, 2, 3, 4, 5}
fruits = {"pomme", "banane", "cerise"}

3. Caractéristiques des ensembles

 Unicité : Les ensembles ne contiennent pas de doublons. Si vous ajoutez un élément déjà
présent, il ne sera pas ajouté.
 mon_ensemble = {1, 2, 2, 3} # mon_ensemble devient {1, 2, 3}

 Non ordonné : Les éléments d'un ensemble n'ont pas d'ordre défini, ce qui signifie que vous
ne pouvez pas accéder à un élément par son index.

4. Opérations sur les ensembles

 Ajouter un élément : Utilisez add() pour ajouter un élément à l'ensemble.
 [Link]("orange") # fruits devient {"pomme", "banane", "cerise",
"orange"}

 Supprimer un élément : Utilisez remove() pour supprimer un élément. Si l'élément

n'existe pas, cela provoquera une erreur. Vous pouvez utiliser discard() qui ne provoque
pas d'erreur si l'élément n’existe pas.
 [Link]("banane") # fruits devient {"pomme", "cerise", "orange"}

 Opérations d'ensemble : Vous pouvez effectuer des opérations comme l'union,

l'intersection et la différence.
 ensemble1 = {1, 2, 3}
ensemble2 = {3, 4, 5}

union = ensemble1 | ensemble2 # {1, 2, 3, 4, 5}

intersection = ensemble1 & ensemble2 # {3}
difference = ensemble1 - ensemble2 # {1, 2}

5. Longueur
Pour obtenir le nombre d'éléments dans un ensemble, utilisez len().
taille = len(fruits) # Nombre d'éléments dans fruits
III-Dictionnaires et leurs méthodes.

A. Définition des dictionnaires

Un dictionnaire en Python est une collection non ordonnée de paires clé-valeur. Chaque clé dans un
dictionnaire est unique, et elle est utilisée pour accéder à la valeur correspondante. Les dictionnaires
sont définis en utilisant des accolades {}.

1. Création d'un dictionnaire

# Dictionnaire vide
mon_dictionnaire = {}

# Dictionnaire avec des éléments

etudiant = {
"nom": "Alice",
"age": 21,
"ville": "Paris"
}

B. Accès aux valeurs

Pour accéder à une valeur dans un dictionnaire, utilisez la clé correspondante.
nom_etudiant = etudiant["nom"] # "Alice"
age_etudiant = etudiant["age"] # 21

C. Méthodes des dictionnaires

Les dictionnaires en Python possèdent plusieurs méthodes utiles pour la manipulation de données.
Voici quelques-unes des méthodes les plus courantes :

1. get()
Permet d'accéder à la valeur associée à une clé. Si la clé n'existe pas, vous pouvez spécifier une
valeur par défaut.
ville_etudiant = [Link]("ville") # "Paris"
pays_etudiant = [Link]("pays", "Inconnu") # "Inconnu" (car "pays"
n'existe pas)

2. keys()
Renvoie une vue des clés du dictionnaire.
cles = [Link]() # dict_keys(['nom', 'age', 'ville'])

3. values()
Renvoie une vue des valeurs du dictionnaire.
valeurs = [Link]() # dict_values(['Alice', 21, 'Paris'])

4. items()
Renvoie une vue des paires clé-valeur sous forme de tuples.
paires = [Link]() # dict_items([('nom', 'Alice'), ('age', 21),
('ville', 'Paris')])

5. update()
Met à jour le dictionnaire avec des paires clé-valeur à partir d'un autre dictionnaire ou d'un itérable.
[Link]({"age": 22, "pays": "France"})
# etudiant devient {'nom': 'Alice', 'age': 22, 'ville': 'Paris', 'pays':
'France'}

6. pop()
Supprime une clé et renvoie sa valeur. Si la clé n'existe pas, cela provoque une erreur.
age = [Link]("age") # 22, etudiant devient {'nom': 'Alice', 'ville':
'Paris', 'pays': 'France'}

7. popitem()
Supprime et renvoie la dernière paire clé-valeur ajoutée au dictionnaire.
dernier_element = [Link]() # Exemple de sortie : ('pays', 'France')

8. clear()
Supprime tous les éléments du dictionnaire.
[Link]() # etudiant devient {}

D. Ajout et modification d'éléments

Pour ajouter ou modifier des éléments dans un dictionnaire, il suffit d'assigner une valeur à une clé.
etudiant["nom"] = "Bob" # Modifie le nom
etudiant["email"] = "bob@[Link]" # Ajoute un nouvel élément

E. Vérification de l'existence d'une clé

Vous pouvez vérifier si une clé existe dans un dictionnaire en utilisant l'opérateur in.
if "nom" in etudiant:
print("La clé 'nom' existe.")

Leçon 6 : Gestion des Erreurs

I-Introduction à la gestion des exceptions.
A. Qu'est-ce qu'une exception ?
Une exception est un événement qui se produit pendant l'exécution d'un programme, perturbant le
flux normal des instructions. Les exceptions peuvent être causées par des erreurs dans le code, des
entrées invalides ou des conditions inattendues.

B. Importance de la gestion des exceptions

La gestion des exceptions est essentielle pour :
  Améliorer la robustesse : Éviter que le programme ne plante en gérant les erreurs de
manière contrôlée.
 Fournir des messages d'erreur clairs : Aider les utilisateurs et les développeurs à
comprendre ce qui s'est mal passé.
 Contrôler le flux du programme : Permettre au programme de continuer à fonctionner ou
de se terminer proprement en cas d'erreur.

C. Lever une exception

En Python, vous pouvez lever une exception à l'aide de l'instruction raise.
def diviser(a, b):
if b == 0:
raise ValueError("Le dénominateur ne peut pas être zéro.")
return a / b

D. Gestion des exceptions avec try et except

La gestion des exceptions en Python se fait principalement à l'aide des blocs try et except.

1. Syntaxe de base
try:
# Code qui peut provoquer une exception
resultat = diviser(10, 0)
except ValueError as e:
# Code exécuté en cas d'exception
print(f"Une erreur s'est produite : {e}")

2. Plusieurs exceptions
Vous pouvez gérer plusieurs types d'exceptions en utilisant plusieurs blocs except.
try:
# Code qui peut provoquer plusieurs exceptions
resultat = diviser(10, "a")
except ValueError:
print("Erreur de valeur.")
except TypeError:
print("Erreur de type.")

3. Bloc else
Un bloc else peut être ajouté après tous les blocs except. Ce bloc s'exécute si aucune exception
n'est levée dans le bloc try.
try:
resultat = diviser(10, 2)
except ValueError as e:
print(f"Erreur : {e}")
else:
print(f"Le résultat est : {resultat}")

4. Bloc finally
Le bloc finally s'exécute toujours, que des exceptions soient levées ou non. Il est souvent utilisé
pour libérer des ressources.
try:
fichier = open("mon_fichier.txt", "r")
contenu = [Link]()
except FileNotFoundError:
print("Le fichier n'existe pas.")
finally:
[Link]() # S'assure que le fichier est toujours fermé

E. Exceptions personnalisées
Vous pouvez créer vos propres exceptions en définissant une classe qui hérite de la classe
Exception.
class MonErreur(Exception):
pass

def verifier_condition(condition):
if not condition:
raise MonErreur("La condition n'est pas remplie.")

try:
verifier_condition(False)
except MonErreur as e:
print(e)

Leçon 7 : Fichiers et Entrée/Sortie

I-Lecture et écriture de fichiers texte.
A. Introduction
La gestion des fichiers est une compétence essentielle en programmation. En Python, vous pouvez
facilement lire et écrire des fichiers texte à l'aide des fonctions intégrées.

B. Ouverture d'un fichier

Pour manipuler un fichier, vous devez d'abord l'ouvrir à l'aide de la fonction open(). Cette
fonction prend deux arguments principaux :
1. Nom du fichier : Le chemin du fichier à ouvrir.
2. Mode : Le mode d'ouverture du fichier, qui peut être :
 'r' : Lecture (par défaut).
 'w' : Écriture (créée un nouveau fichier ou écrase un fichier existant).
 'a' : Ajout (ajoute du contenu à la fin du fichier).
 'b' : Mode binaire (pour les fichiers binaires).
 'x' : Création (lève une erreur si le fichier existe déjà).

Exemple d'ouverture d'un fichier :

# Ouvrir un fichier en mode lecture
fichier = open("mon_fichier.txt", "r")

C. Lecture de fichiers
1. Lire tout le contenu
Pour lire l'intégralité du contenu d'un fichier, utilisez la méthode read().
contenu = [Link]()
print(contenu)

2. Lire ligne par ligne

Pour lire un fichier ligne par ligne, utilisez la méthode readline() ou une boucle for.
# Lire une seule ligne
ligne = [Link]()
print(ligne)

# Lire toutes les lignes avec une boucle

for ligne in fichier:
print(ligne)

3. Lire toutes les lignes dans une liste

La méthode readlines() renvoie une liste contenant toutes les lignes du fichier.
lignes = [Link]()
print(lignes)

D. Écriture dans des fichiers

1. Écrire du texte
Pour écrire dans un fichier, ouvrez-le en mode 'w' ou 'a' et utilisez la méthode write().
# Ouvrir un fichier en mode écriture
fichier = open("mon_fichier.txt", "w")

# Écrire du texte dans le fichier

[Link]("Bonjour, monde !\n")
[Link]("Ceci est une nouvelle ligne.\n")

2. Écrire plusieurs lignes

Pour écrire plusieurs lignes à la fois, vous pouvez utiliser writelines().
lignes = ["Ligne 1\n", "Ligne 2\n", "Ligne 3\n"]
[Link](lignes)

E. Fermeture d'un fichier

Après avoir terminé de lire ou d'écrire, fermez le fichier en utilisant la méthode close().
[Link]()

II-Gestion des fichiers avec le contexte (with).

A. Introduction à l'instruction with
L'instruction with en Python est utilisée pour simplifier la gestion des ressources, comme les
fichiers. Elle garantit que les ressources sont correctement acquises et libérées, même en cas
d'erreur. Cela évite les fuites de ressources, comme des fichiers non fermés.
B. Avantages de l'utilisation de with
1. Fermeture automatique : Le fichier est automatiquement fermé à la fin du bloc with,
même si une exception est levée.
2. Code plus propre : Réduit le besoin d'appeler close() explicitement.
3. Gestion des erreurs : Simplifie le traitement des erreurs en encapsulant le code qui
manipule les fichiers.

C. Syntaxe de base
La syntaxe de l'instruction with pour ouvrir un fichier est la suivante :

python
with open("nom_du_fichier.txt", "mode") as variable:
# Opérations sur le fichier

D. Exemples d'utilisation
1. Lecture d'un fichier
Voici comment lire le contenu d'un fichier à l'aide de with :

python
with open("mon_fichier.txt", "r") as fichier:
contenu = [Link]()
print(contenu)

Dans cet exemple, le fichier est ouvert en mode lecture ("r"), et son contenu est lu et affiché. Le
fichier est automatiquement fermé à la fin du bloc with.

2. Écriture dans un fichier

Pour écrire dans un fichier, utilisez également with :
python
with open("mon_fichier.txt", "w") as fichier:
[Link]("Ceci est une nouvelle ligne.\n")
[Link]("Et une autre ligne.\n")

Ici, le fichier est ouvert en mode écriture ("w"), et deux lignes sont écrites. Le fichier est fermé
automatiquement après l'écriture.

3. Ajout à un fichier
Pour ajouter du contenu à un fichier existant, utilisez le mode 'a' (ajout) :

python
with open("mon_fichier.txt", "a") as fichier:
[Link]("Ajout d'une ligne à la fin.\n")
E. Lecture ligne par ligne
Vous pouvez également lire un fichier ligne par ligne en utilisant with :

python
with open("mon_fichier.txt", "r") as fichier:
for ligne in fichier:
print([Link]()) # `strip()` pour enlever les espaces et les sauts
de ligne

F. Gestion des exceptions avec with

Bien que with gère la fermeture des fichiers, vous pouvez également ajouter des blocs try-
except à l'intérieur pour gérer les exceptions :

python
try:
with open("mon_fichier.txt", "r") as fichier:
contenu = [Link]()
print(contenu)
except FileNotFoundError:
print("Le fichier n'existe pas.")
except IOError:
print("Une erreur est survenue lors de la lecture du fichier.")

III-Introduction à la manipulation de fichiers CSV.

A. Qu'est-ce qu'un fichier CSV ?
Un fichier CSV (Comma-Separated Values) est un format de fichier texte utilisé pour stocker des
données tabulaires. Chaque ligne du fichier représente une ligne de données, et les valeurs de
chaque colonne sont séparées par des virgules (ou d'autres délimiteurs comme des points-virgules).

B. Pourquoi utiliser des fichiers CSV ?

 Simplicité : Les fichiers CSV sont faciles à lire et à écrire, tant pour les humains que pour
les machines.
 Interopérabilité : De nombreux logiciels, y compris les tableurs comme Microsoft Excel et
Google Sheets, supportent le format CSV.
 Légèreté : Les fichiers CSV ont une taille de fichier faible par rapport à d'autres formats
comme Excel.

C. Bibliothèque csv de Python

Python fournit une bibliothèque intégrée appelée csv pour lire et écrire des fichiers CSV
facilement.

D. Lecture de fichiers CSV

Pour lire un fichier CSV, vous pouvez utiliser la fonction [Link]().

1. Exemple de lecture d'un fichier CSV

Supposons que vous ayez un fichier [Link] avec le contenu suivant :
nom,age,ville
Alice,30,Paris
Bob,25,Lyon
Charlie,35,Marseille

Vous pouvez lire ce fichier comme suit :

import csv

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

lecteur = [Link](fichier)
# Ignorer l'en-tête
next(lecteur)

for ligne in lecteur:

nom, age, ville = ligne
print(f"Nom: {nom}, Âge: {age}, Ville: {ville}")

E. Écriture dans des fichiers CSV

Pour écrire dans un fichier CSV, utilisez [Link]().

1. Exemple d'écriture dans un fichier CSV

Voici comment écrire des données dans un fichier CSV :
import csv

donnees = [
["nom", "age", "ville"],
["Alice", 30, "Paris"],
["Bob", 25, "Lyon"],
["Charlie", 35, "Marseille"]
]

with open("[Link]", "w", newline='') as fichier:

ecrivain = [Link](fichier)
[Link](donnees)

F. Gestion des délimiteurs

Vous pouvez personnaliser le délimiteur utilisé dans le fichier CSV en spécifiant l'argument
delimiter.
with open("[Link]", "r") as fichier:
lecteur = [Link](fichier, delimiter=';') # Utiliser un point-virgule
comme délimiteur
for ligne in lecteur:
print(ligne)

G. Utilisation de DictReader et DictWriter

Les classes [Link] et [Link] permettent de lire et d'écrire des fichiers
CSV sous forme de dictionnaires, ce qui facilite l'accès par nom de colonne.

1. Exemple avec DictReader

import csv
with open("[Link]", "r") as fichier:
lecteur = [Link](fichier)

for ligne in lecteur:

print(f"Nom: {ligne['nom']}, Âge: {ligne['age']}, Ville:
{ligne['ville']}")

2. Exemple avec DictWriter

import csv

donnees = [
{"nom": "Alice", "age": 30, "ville": "Paris"},
{"nom": "Bob", "age": 25, "ville": "Lyon"},
{"nom": "Charlie", "age": 35, "ville": "Marseille"}
]

with open("[Link]", "w", newline='') as fichier:

champs = ["nom", "age", "ville"]
ecrivain = [Link](fichier, fieldnames=champs)
[Link]() # Écrire l'en-tête
[Link](donnees)

Leçon 8 : Modules et Packages

I-Importation de modules standard.
A. Qu'est-ce qu'un module ?
Un module en Python est un fichier contenant du code Python, qui peut inclure des définitions de
fonctions, des classes et des variables. Les modules permettent d'organiser le code en le répartissant
dans des fichiers distincts, facilitant ainsi la réutilisation et la maintenance.

B. Modules standard de Python

Python est livré avec une bibliothèque standard riche qui contient de nombreux modules utiles pour
diverses tâches, comme la manipulation de fichiers, les calculs mathématiques, la gestion des dates
et heures, et bien d'autres. Quelques exemples de modules standard incluent :
 math : Fonctions mathématiques.
 datetime : Manipulation des dates et heures.
 os : Interaction avec le système d'exploitation.
 sys : Accès aux paramètres et fonctions du système Python.
 random : Génération de nombres aléatoires.

C. Importation de modules
Pour utiliser un module, vous devez l'importer dans votre script Python. Voici quelques façons
d'importer des modules :

1. Importation simple
Pour importer un module entier, utilisez la syntaxe suivante :
import nom_du_module

Exemple :
import math

resultat = [Link](16) # Utiliser la fonction sqrt du module math

print(resultat) # Affiche 4.0

2. Importation de fonctions spécifiques

Vous pouvez importer des fonctions spécifiques d'un module pour éviter de préfixer le nom du
module à chaque utilisation :
from nom_du_module import fonction

Exemple :
from math import sqrt

resultat = sqrt(25) # Pas besoin de préfixe, directement accessible

print(resultat) # Affiche 5.0

3. Importation avec alias

Vous pouvez donner un alias à un module ou à une fonction importée pour simplifier son
utilisation :
import nom_du_module as alias

Exemple :
import numpy as np # numpy est un module populaire pour les calculs numériques

# Utiliser l'alias pour créer un tableau

tableau = [Link]([1, 2, 3])
print(tableau)

D. Vérification de la documentation des modules

Pour explorer les fonctions et classes disponibles dans un module, vous pouvez utiliser la fonction
help() ou consulter la documentation officielle de Python.
import math
help(math) # Affiche la documentation du module math

II-Création de modules personnalisés.

A. Qu'est-ce qu'un module personnalisé ?
Un module personnalisé est un fichier Python contenant du code que vous créez pour organiser et
réutiliser vos fonctions, classes et variables. Les modules permettent de structurer votre code, de le
rendre plus lisible et de faciliter son partage entre différents projets.

B. Création d'un module

1. Créer un fichier Python : Un module est simplement un fichier avec l'extension .py. Par
exemple, vous pourriez créer un fichier nommé mon_module.py.

2. Ajouter du code dans le module : Écrivez les fonctions, classes et variables que vous
souhaitez inclure dans votre module. Par exemple :
# mon_module.py
def saluer(nom):
"""Fonction qui retourne un message de salutation."""
return f"Bonjour, {nom}!"

def additionner(a, b):

"""Fonction qui retourne la somme de deux nombres."""
return a + b

PI = 3.14159

C. Utilisation d'un module personnalisé

Pour utiliser un module personnalisé dans un autre fichier Python, vous devez l'importer de la
même manière que vous importeriez un module standard.
1. Importation du module : Utilisez import suivi du nom du module (sans l'extension .py).
# [Link]

import mon_module

# Utiliser les fonctions du module

message = mon_module.saluer("Alice")
print(message) # Affiche "Bonjour, Alice!"

resultat = mon_module.additionner(5, 7)
print(resultat) # Affiche 12

print(mon_module.PI) # Affiche 3.14159

D. Importation de fonctions spécifiques

Vous pouvez également importer des fonctions spécifiques de votre module pour éviter de préfixer
le nom du module :
# [Link]

from mon_module import saluer, additionner

print(saluer("Bob")) # Affiche "Bonjour, Bob!"

print(additionner(3, 4)) # Affiche 7

E. Organisation des modules

Pour organiser vos modules, vous pouvez les placer dans des sous-dossiers appelés packages. Un
package est un dossier contenant un fichier spécial nommé __init__.py, qui peut être vide ou
contenir du code d'initialisation du package. Voici comment créer un package :
1. Créer une structure de dossiers :
mon_projet/
├── mon_package/
│ ├── __init__.py
│ ├── module_a.py
│ └── module_b.py
└── [Link]

2. Utiliser des modules dans un package :

Vous pouvez importer des modules d'un package dans votre script principal :
# module_a.py
def fonction_a():
return "Ceci est la fonction A."

# module_b.py
def fonction_b():
return "Ceci est la fonction B."

# __init__.py
from .module_a import fonction_a
from .module_b import fonction_b

# [Link]
from mon_package import fonction_a, fonction_b

print(fonction_a()) # Affiche "Ceci est la fonction A."

print(fonction_b()) # Affiche "Ceci est la fonction B."

III-Introduction aux packages et gestion des dépendances.

A. Qu'est-ce qu'un package ?
Un package en Python est une façon d'organiser des modules en un ensemble hiérarchique. Un
package est essentiellement un répertoire contenant un fichier spécial nommé __init__.py, qui
peut être vide ou contenir du code d'initialisation. Les packages permettent de structurer les
modules de manière à éviter les conflits de noms et à faciliter l'organisation du code.

1. Structure d'un package

Voici un exemple de structure de package :
mon_projet/
├── mon_package/
│ ├── __init__.py
│ ├── module_a.py
│ └── module_b.py
└── [Link]

B. Création d'un package

1. Créer le répertoire du package : Créez un dossier pour votre package et ajoutez-y un
fichier __init__.py.

2. Ajouter des modules : Placez vos modules dans ce dossier. Par exemple, module_a.py
et module_b.py.

3. Utiliser le package : Importez les modules à partir de votre package dans d'autres scripts
Python.
# module_a.py
def fonction_a():
return "Fonction A"

# module_b.py
def fonction_b():
return "Fonction B"

# __init__.py
from .module_a import fonction_a
from .module_b import fonction_b

# [Link]
from mon_package import fonction_a, fonction_b

print(fonction_a()) # Affiche "Fonction A"

print(fonction_b()) # Affiche "Fonction B"

C. Gestion des dépendances

La gestion des dépendances est cruciale dans le développement de logiciels, car elle permet de
s'assurer que toutes les bibliothèques nécessaires sont installées et à jour. Les dépendances sont des
packages externes dont votre projet a besoin pour fonctionner correctement.

1. Outils de gestion des dépendances

 pip : L'outil de gestion de packages standard pour Python. Il permet d'installer et de gérer
les packages Python à partir du Python Package Index (PyPI).
 [Link] : Un fichier texte qui liste toutes les dépendances de votre projet.
Chaque ligne contient le nom d'un package et éventuellement sa version.

Exemple de [Link] :
numpy==1.21.0
pandas>=1.3.0
requests

2. Installation des dépendances

Pour installer les dépendances listées dans un fichier [Link], utilisez la commande
suivante :
bash
pip install -r [Link]

3. Vérification des dépendances

Pour vérifier les packages installés et leurs versions, vous pouvez utiliser la commande :
bash
pip freeze

Cette commande affiche une liste de tous les packages installés dans l'environnement Python, avec
leurs versions.

D. Environnements virtuels
Il est recommandé d'utiliser des environnements virtuels pour gérer les dépendances de vos projets.
Un environnement virtuel est une installation isolée de Python qui permet d'installer des packages
sans interférer avec les autres projets.

1. Création d'un environnement virtuel

Pour créer un environnement virtuel, utilisez venv :
bash
python -m venv mon_env

2. Activation de l'environnement virtuel

 Sur Windows :
bash
mon_env\Scripts\activate

 Sur macOS et Linux :

bash
source mon_env/bin/activate

3. Installation de packages dans l'environnement virtuel

Une fois l'environnement virtuel activé, vous pouvez installer des packages avec pip, et ils seront
installés uniquement dans cet environnement.

Leçon 9 : Programmation Orientée Objet (Introduction)

I-Concepts de base de la POO (classes, objets, héritage).
A. Qu'est-ce que la programmation orientée objet (POO) ?
La programmation orientée objet est un paradigme de programmation qui utilise des "objets" pour
représenter des données et des comportements. La POO facilite la modélisation du monde réel en
regroupant des données et des fonctions qui opèrent sur ces données. Les concepts fondamentaux de
la POO incluent les classes, les objets, l'héritage et le polymorphisme.

B. Classes et objets
1. Classes
Une classe est une définition d'un type d'objet. Elle sert de modèle (ou plan) pour créer des objets,
encapsulant des données et des comportements. Une classe peut contenir des attributs (variables) et
des méthodes (fonctions).
Exemple de classe :
class Voiture:
def __init__(self, marque, modele, annee):
[Link] = marque
[Link] = modele
[Link] = annee

def demarrer(self):
print(f"La {[Link]} {[Link]} démarre.")

2. Objets
Un objet est une instance d'une classe. Lorsque vous créez un objet, vous utilisez le modèle défini
par la classe pour créer une entité spécifique.
Création d'objets :
ma_voiture = Voiture("Toyota", "Corolla", 2020)
ma_voiture.demarrer() # Affiche "La Toyota Corolla démarre."

C. Héritage
L'héritage est un mécanisme qui permet de créer une nouvelle classe à partir d'une classe existante.
La nouvelle classe (appelée classe dérivée ou sous-classe) hérite des attributs et des méthodes de la
classe de base (ou super-classe). Cela permet de réutiliser le code et de créer des hiérarchies de
classes.

1. Exemple d'héritage
class Vehicule:
def __init__(self, marque, modele):
[Link] = marque
[Link] = modele

def demarrer(self):
print(f"Le {[Link]} {[Link]} démarre.")

# Sous-classe qui hérite de la classe Vehicule

class Moto(Vehicule):
def __init__(self, marque, modele, type_moto):
super().__init__(marque, modele) # Appel du constructeur de la classe
de base
self.type_moto = type_moto

def demarrer(self):
print(f"La moto {[Link]} {[Link]} de type {self.type_moto}
démarre.")

# Création d'un objet de la classe Moto

ma_moto = Moto("Yamaha", "MT-07", "sport")
ma_moto.demarrer() # Affiche "La moto Yamaha MT-07 de type sport démarre."

D. Polymorphisme
Le polymorphisme permet d'utiliser une méthode de la même manière sur différents objets. Cela
signifie que vous pouvez appeler la même méthode sur des objets de différentes classes, et chaque
classe peut avoir sa propre implémentation de cette méthode.
Exemple de polymorphisme :
def faire_demarrer(vehicule):
[Link]()

faire_demarrer(ma_voiture) # Appelle la méthode demarrer de Voiture

faire_demarrer(ma_moto) # Appelle la méthode demarrer de Moto

II-Différence entre la programmation structurée et la POO.

A. Définition
1. Programmation structurée
La programmation structurée est un paradigme de programmation qui repose sur l'utilisation de
structures de contrôle (comme les boucles, les conditions et les instructions séquentielles) pour
organiser le code. Elle vise à améliorer la clarté et la qualité du code en évitant le recours à des
instructions de saut (comme goto).
2. Programmation orientée objet (POO)
La programmation orientée objet est un paradigme qui organise le code autour des "objets", qui
combinent données et comportements. La POO utilise des concepts tels que les classes, les objets,
l'héritage et le polymorphisme pour modéliser des systèmes complexes de manière plus intuitive.

B. Principes fondamentaux

C. Avantages et inconvénients
1. Programmation structurée
 Avantages :
 Simplicité : Facile à comprendre et à mettre en œuvre pour de petits programmes.
 Clarté : Utilise des structures de contrôle claires.
 Inconvénients :
 Difficulté à gérer des projets complexes : La séparation des données et des fonctions
peut rendre le code difficile à suivre.
 Réutilisabilité limitée : Moins de mécanismes pour réutiliser le code.

2. Programmation orientée objet

 Avantages :
 Modélisation intuitive : Permet de modéliser des systèmes complexes de manière
naturelle.
 Réutilisabilité : Favorise la réutilisation du code par héritage et polymorphisme.
 Encapsulation : Protège l'état interne des objets.
 Inconvénients :
  Complexité initiale : Peut être plus difficile à comprendre pour les débutants.
 Surcharge de conception : Peut nécessiter plus de temps de conception pour créer des
classes et des objets.
III-Création de classes simples.

A. Qu'est-ce qu'une classe ?

Une classe est une structure de base en programmation orientée objet qui définit un type d'objet.
Elle encapsule des données (attributs) et des comportements (méthodes) associés à cet objet.

B. Syntaxe de base d'une classe

La syntaxe pour définir une classe en Python est la suivante :
class NomDeClasse:
def __init__(self, param1, param2):
# Initialisation des attributs de l'objet
self.attribut1 = param1
self.attribut2 = param2

def methode(self):
# Comportement de l'objet
pass

Signification de chaque composant

1. class NomDeClasse:
 class : Mot-clé utilisé pour définir une nouvelle classe.
 NomDeClasse : Nom de la classe. Il est d'usage d'utiliser la convention de nommage en
CamelCase (majuscule au début de chaque mot). Ce nom sera utilisé pour créer des objets de
ce type.

2. def __init__(self, param1, param2):

 def : Mot-clé utilisé pour définir une nouvelle fonction ou méthode.
 init : Méthode spéciale appelée le constructeur. Elle est automatiquement appelée lorsque
vous créez une nouvelle instance de la classe. Son rôle est d'initialiser les attributs de l'objet.
 self : Référence à l'instance actuelle de la classe. Elle est utilisée pour accéder aux attributs
et aux méthodes de l'objet. Chaque méthode d'une classe doit inclure self comme premier
paramètre.
 param1, param2 : Paramètres que vous pouvez passer lors de la création d'un objet. Ce sont
des valeurs qui seront utilisées pour initialiser les attributs de l'objet.

3. self.attribut1 = param1
 self.attribut1 : Un attribut de l'objet, qui sera accessible depuis d'autres méthodes de la
classe. C'est une variable qui stocke l'état de l'objet.
 param1 : Valeur passée lors de la création de l'objet, qui est assignée à l'attribut
attribut1.
4. self.attribut2 = param2
 self.attribut2 : Un autre attribut de l'objet, similaire à attribut1.
 param2 : Valeur passée lors de la création de l'objet, assignée à l'attribut attribut2.

5. def methode(self):
 def : Mot-clé pour définir une méthode de la classe.
 methode : Nom de la méthode. Les noms de méthodes suivent généralement la convention
de nommage en minuscules, avec des mots séparés par des underscores si nécessaire.
 self : Référence à l'instance actuelle, comme pour le constructeur.

6. pass
 pass : Un mot-clé qui indique que la méthode ne fait rien pour le moment. C'est un espace
réservé qui peut être remplacé plus tard par du code fonctionnel. Cela permet de définir la
structure de la méthode sans la mettre en œuvre immédiatement.

Exemple d'utilisation
Pour illustrer, voici comment vous pourriez utiliser cette classe :
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.")

# Création d'un objet de la classe Personne

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

Dans cet exemple, nom et age sont des paramètres passés au constructeur, qui sont ensuite utilisés
pour initialiser les attributs [Link] et [Link]. La méthode se_presenter permet à
l'objet de se présenter en utilisant ses attributs.

C. Exemple de classe simple

Voici un exemple de classe représentant une Personne :
class Personne:
def __init__(self, nom, age):
[Link] = nom # Attribut pour le nom
[Link] = age # Attribut pour l'âge

def se_presenter(self):
"""Méthode pour présenter la personne."""
print(f"Bonjour, je m'appelle {[Link]} et j'ai {[Link]} ans.")

D. Création d'objets à partir de la classe

Pour créer un objet à partir de cette classe, vous pouvez utiliser le constructeur de la classe :
# Création d'objets
personne1 = Personne("Alice", 30)
personne2 = Personne("Bob", 25)

# Appel de la méthode se_presenter

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

E. Ajout de méthodes
Vous pouvez ajouter plusieurs méthodes à une classe pour définir différents comportements. Par
exemple, ajoutons une méthode pour célébrer un anniversaire :
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.")

def anniversaire(self):
[Link] += 1
print(f"{[Link]} a maintenant {[Link]} ans.")

Utilisation de la méthode anniversaire :

[Link]() # Affiche "Alice a maintenant 31 ans."