1.

Introduction à Python

Objectifs :

 Comprendre ce qu’est Python et son utilité.

 Installer et configurer l’environnement de travail.
 Exécuter un script Python simple.

Contenu détaillé :

1. Présentation de Python et des domaines d’application

 Qu'est-ce que Python ?

o Python est un langage de programmation interprété, haut niveau
et polyvalent.
o Il est connu pour sa syntaxe simple et lisible, ce qui le rend idéal
pour les débutants.
 Domaines d’application :
o Scientifique : Analyse de données, calcul scientifique (avec
NumPy, SciPy).
o Web : Développement d'applications web (avec Django, Flask).
o IA et Machine Learning : Apprentissage automatique (avec
TensorFlow, PyTorch).
o Automatisation : Scripts pour automatiser des tâches
répétitives.
o Jeux : Développement de jeux (avec Pygame).

2. Installation de Python et d’un IDE

a) Installer Python :

 Téléchargez Python depuis python.org.

 Assurez-vous de cocher l'option "Add Python to PATH" pendant
l'installation.

b) Choisir un IDE :

 PyCharm : IDE puissant et complet pour Python.

 VS Code : Éditeur léger et extensible avec support Python.
 Jupyter Notebook : Idéal pour l'analyse de données et les projets
interactifs.

c) Configurer l'environnement :
  Ouvrez votre IDE et créez un nouveau fichier Python (extension .py).

3. Structure d’un script Python

a) Indentation :

 Python utilise l'indentation pour définir les blocs de code (ex. : boucles,
conditions).
 Exemple :
python

Copy

if 5 > 2:
print("Cinq est plus grand que deux !")

b) Commentaires :

 Les commentaires sont précédés de # et ne sont pas exécutés.

 Exemple :
python

Copy

# Ceci est un commentaire

print("Bonjour, Python !")

c) Fonctions de base :

 print() : Affiche du texte à l'écran.

python

Copy

print("Bonjour, Python !")

 input() : Permet à l'utilisateur de saisir du texte.
python

Copy

nom = input("Entrez votre nom : ")

print("Bonjour, " + nom + " !")

Exercices pratiques :
Exercice 1 : Afficher "Bonjour, Python !"

 Objectif : Écrire un programme qui affiche "Bonjour, Python !".

 Solution :
python

Copy

print("Bonjour, Python !")

Exercice 2 : Demander le nom de l’utilisateur et afficher un message

personnalisé

 Objectif : Demander à l'utilisateur son nom et afficher un message

personnalisé.
 Solution :
python

Copy

# Demander le nom de l'utilisateur

nom = input("Entrez votre nom : ")

# Afficher un message personnalisé

print("Bonjour, " + nom + " !")

Explication des exercices :

 Exercice 1 :
o La fonction print() est utilisée pour afficher du texte à l'écran.
o Le texte est passé entre guillemets ("...").
 Exercice 2 :
o La fonction input() permet de saisir du texte.
o Le texte saisi est stocké dans une variable ( nom).
o La fonction print() affiche un message personnalisé en
concaténant des chaînes de caractères avec l'opérateur +.

Conclusion :

 Vous avez découvert Python, son utilité et ses domaines d'application.

 Vous avez installé Python et configuré un IDE pour écrire et exécuter
des scripts.
 Vous avez appris les bases de la syntaxe Python, y compris
l'indentation, les commentaires et les fonctions print() et input().
2. Les bases de Python

Objectifs :

 Manipuler les types de données simples en Python.

 Connaître les opérations de base (arithmétiques, logiques, de
comparaison).
 Comprendre les variables et la conversion de types.

Contenu détaillé :

1. Types de données

a) int (entier) :

 Représente des nombres entiers (ex. : 5, -3, 42).

 Exemple :
python

Copy

age = 25

b) float (nombre à virgule flottante) :

 Représente des nombres décimaux (ex. : 3.14, -0.5).

 Exemple :
python

Copy

pi = 3.14159

c) str (chaîne de caractères) :

 Représente du texte (ex. : "Bonjour", "Python").

 Exemple :
python

Copy

nom = "Alice"

d) bool (booléen) :
  Représente une valeur logique (True ou False).
 Exemple :
python

Copy

est_actif = True

2. Opérations de base

a) Opérations arithmétiques :

 Addition (+), soustraction (-), multiplication (*), division (/).

 Exemple :
python

Copy

resultat = 10 + 5 * 2 # Résultat = 20

b) Opérations de comparaison :

 Égalité (==), inégalité (!=), supérieur (>), inférieur (<).

 Exemple :
python

Copy

est_superieur = 10 > 5 # Résultat = True

c) Opérations logiques :

 ET (and), OU (or), NON (not).

 Exemple :
python

Copy

est_valide = (age > 18) and (nom != "")

3. Variables et affectation

 Déclaration :
o Une variable est créée en lui attribuant une valeur.
 o Exemple :
python

Copy

x = 10
 Réaffectation :
o La valeur d'une variable peut être modifiée.
o Exemple :
python

Copy

x = 20

4. Conversion de types

 int() : Convertit en entier.

python

Copy

nombre = int("42") # Résultat = 42

 float() : Convertit en nombre à virgule flottante.
python

Copy

nombre = float("3.14") # Résultat = 3.14

 str() : Convertit en chaîne de caractères.
python

Copy

texte = str(42) # Résultat = "42"

 bool() : Convertit en booléen.
python

Copy

est_vrai = bool(1) # Résultat = True

Exercices pratiques :
Exercice 1 : Calculer l’aire d’un cercle

 Objectif : Demander à l'utilisateur le rayon d'un cercle et calculer son

aire.
 Formule : Aire = π × rayon²
 Solution :
python

Copy

# Importer la constante pi du module math

from math import pi

# Demander le rayon à l'utilisateur

rayon = float(input("Entrez le rayon du cercle : "))

# Calculer l'aire
aire = pi * rayon ** 2

# Afficher le résultat
print("L'aire du cercle est :", aire)

Exercice 2 : Vérifier si un nombre est pair ou impair

 Objectif : Demander à l'utilisateur un nombre et vérifier s'il est pair ou

impair.
 Solution :
python

Copy

# Demander un nombre à l'utilisateur

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

# Vérifier si le nombre est pair ou impair

if nombre % 2 == 0:
print(nombre, "est un nombre pair.")
else:
print(nombre, "est un nombre impair.")

Explication des exercices :

Exercice 1 :

 from math import pi : Importe la constante π du module math.

 float(input(...)) : Convertit la saisie de l'utilisateur en nombre à
virgule flottante.
 rayon ** 2 : Calcule le carré du rayon.
  print() : Affiche le résultat.

Exercice 2 :

 int(input(...)) : Convertit la saisie de l'utilisateur en entier.

 nombre % 2 : Calcule le reste de la division par 2.
o Si le reste est 0, le nombre est pair.
o Sinon, il est impair.
 if...else : Structure conditionnelle pour afficher le résultat.

Conclusion :

 Vous avez appris à manipuler les types de données simples en Python

(int, float, str, bool).
 Vous avez découvert les opérations de base (arithmétiques, logiques,
de comparaison).
 Vous avez pratiqué la conversion de types et résolu des problèmes
simples avec Python.
3. Structures de contrôle

Objectifs :

 Utiliser des conditions (if, elif, else) pour contrôler le flux d'exécution.
 Comprendre les boucles (for, while) pour répéter des actions.
 Maîtriser les instructions de contrôle (break, continue).

Contenu détaillé :

1. Conditions : if, elif, else

 if : Exécute un bloc de code si une condition est vraie.

python

Copy

if condition:
# Code à exécuter si la condition est vraie
 elif : Vérifie une autre condition si la précédente est fausse.
python

Copy

elif autre_condition:
# Code à exécuter si l'autre condition est vraie
 else : Exécute un bloc de code si aucune condition n'est vraie.
python

Copy

else:
# Code à exécuter si toutes les conditions sont fausses
 Exemple :
python

Copy

age = 18
if age < 18:
print("Mineur")
elif age == 18:
print("Tout juste majeur")
else:
print("Majeur")
2. Boucles : for et while

a) Boucle for :

 Répète un bloc de code pour chaque élément d'une séquence (liste,

chaîne, etc.).
 Syntaxe :
python

Copy

for élément in séquence:

# Code à répéter
 Exemple :
python

Copy

for i in range(5): # Répète 5 fois (de 0 à 4)

print(i)

b) Boucle while :

 Répète un bloc de code tant qu'une condition est vraie.

 Syntaxe :
python

Copy

while condition:
# Code à répéter
 Exemple :
python

Copy

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

3. Instructions de contrôle : break, continue

a) break :
  Interrompt immédiatement la boucle.
 Exemple :
python

Copy

for i in range(10):
if i == 5:
break # Arrête la boucle lorsque i atteint 5
print(i)

b) continue :

 Saute le reste de l'itération actuelle et passe à la suivante.

 Exemple :
python

Copy

for i in range(10):
if i % 2 == 0:
continue # Saute les nombres pairs
print(i)

Exercices pratiques :

Exercice 1 : Vérifier si un nombre est positif, négatif ou nul

 Objectif : Demander un nombre à l'utilisateur et afficher s'il est positif,

négatif ou nul.
 Solution :
python

Copy

# Demander un nombre à l'utilisateur

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

# Vérifier si le nombre est positif, négatif ou nul

if nombre > 0:
print("Le nombre est positif.")
elif nombre < 0:
print("Le nombre est négatif.")
else:
print("Le nombre est nul.")

Exercice 2 : Générer et afficher les nombres de 1 à 10

  Objectif : Utiliser une boucle for pour afficher les nombres de 1 à 10.
 Solution :
python

Copy

# Boucle for pour afficher les nombres de 1 à 10

for i in range(1, 11): # range(1, 11) génère de 1 à 10 inclus
print(i)

Exercice 3 : Calculer la moyenne des notes

 Objectif : Demander des notes à l'utilisateur jusqu'à ce qu'il entre -1,

puis calculer la moyenne.
 Solution :
python

Copy

# Initialiser les variables

somme = 0
nombre_notes = 0

# Boucle while pour demander des notes

while True:
note = float(input("Entrez une note (ou -1 pour terminer) : "))
if note == -1:
break # Sortir de la boucle si l'utilisateur entre -1
somme += note
nombre_notes += 1

# Calculer et afficher la moyenne

if nombre_notes > 0:
moyenne = somme / nombre_notes
print("La moyenne des notes est :", moyenne)
else:
print("Aucune note n'a été saisie.")

Explication des exercices :

Exercice 1 :

 float(input(...)) : Convertit la saisie de l'utilisateur en nombre à

virgule flottante.
 if...elif...else : Structure conditionnelle pour vérifier si le nombre est
positif, négatif ou nul.

Exercice 2 :
  range(1, 11) : Génère une séquence de nombres de 1 à 10.
 for : Boucle pour parcourir et afficher chaque nombre.

Exercice 3 :

 while True : Boucle infinie qui s'arrête avec break.

 break : Interrompt la boucle lorsque l'utilisateur entre -1.
 somme et nombre_notes : Variables pour stocker la somme des
notes et leur nombre.
 moyenne : Calculée en divisant la somme par le nombre de notes.

Conclusion :

 Vous avez appris à utiliser les conditions ( if, elif, else) pour contrôler le
flux d'exécution.
 Vous avez découvert les boucles (for, while) pour répéter des actions.
 Vous avez pratiqué les instructions de contrôle ( break, continue) pour
gérer les boucles.
4. Collections en Python

Objectifs :

 Manipuler des listes, tuples, ensembles et dictionnaires.

 Parcourir et modifier ces structures de données.

Contenu détaillé :

1. Listes

 Création :

python

Copy

ma_liste = [1, 2, 3, 4, 5]
 Ajout d'éléments :
o append() : Ajoute un élément à la fin.

python

Copy

ma_liste.append(6) # [1, 2, 3, 4, 5, 6]
o insert() : Ajoute un élément à une position spécifique.
python

Copy

ma_liste.insert(2, 10) # [1, 2, 10, 3, 4, 5, 6]

 Suppression d'éléments :
o remove() : Supprime la première occurrence d'un élément.

python

Copy

ma_liste.remove(3) # [1, 2, 10, 4, 5, 6]

o pop() : Supprime un élément à une position donnée (ou le
dernier).
python

Copy
 ma_liste.pop(2) # [1, 2, 4, 5, 6]
 Tri :
o sort() : Trie la liste en place.

python

Copy

ma_liste.sort() # [1, 2, 4, 5, 6]
o sorted() : Retourne une nouvelle liste triée.
python

Copy

nouvelle_liste = sorted(ma_liste)

2. Tuples

 Création :

python

Copy

mon_tuple = (1, 2, 3)
 Immutabilité :
o Les tuples ne peuvent pas être modifiés après création.
 Indexation :
o Accéder aux éléments par leur indice.

python

Copy

premier_element = mon_tuple[0] # 1

3. Ensembles

 Création :

python

Copy
 mon_ensemble = {1, 2, 3, 4, 5}
 Opérations :
o Union (|) : Combine deux ensembles.

python

Copy

ensemble1 = {1, 2, 3}
ensemble2 = {3, 4, 5}
union = ensemble1 | ensemble2 # {1, 2, 3, 4, 5}
o Intersection (&) : Trouve les éléments communs.
python

Copy

intersection = ensemble1 & ensemble2 # {3}

o Différence (-) : Trouve les éléments présents dans un seul
ensemble.
python

Copy

difference = ensemble1 - ensemble2 # {1, 2}

4. Dictionnaires

 Création :

python

Copy

mon_dictionnaire = {"nom": "Alice", "âge": 25}

 Ajout et modification :
o Ajouter ou modifier une valeur avec une clé.

python

Copy

mon_dictionnaire["ville"] = "Paris" # {"nom": "Alice", "âge": 25, "ville":

"Paris"}
 Suppression :
o pop() : Supprime une paire clé-valeur.
 python

Copy

mon_dictionnaire.pop("ville") # {"nom": "Alice", "âge": 25}

 Parcourir un dictionnaire :
o Parcourir les clés, valeurs ou paires clé-valeur.

python

Copy

for cle, valeur in mon_dictionnaire.items():

print(cle, valeur)

Exercices pratiques :

Exercice 1 : Trier une liste de nombres

 Objectif : Demander à l'utilisateur une liste de nombres, puis la trier.

 Solution :
python

Copy

# Demander à l'utilisateur de saisir des nombres séparés par des espaces

entree = input("Entrez des nombres séparés par des espaces : ")

# Convertir la saisie en une liste de nombres

nombres = list(map(float, entree.split()))

# Trier la liste
nombres.sort()

# Afficher la liste triée

print("Liste triée :", nombres)

Exercice 2 : Créer un dictionnaire de notes

 Objectif : Stocker les notes des étudiants dans un dictionnaire et les

afficher.
 Solution :
python

Copy

# Créer un dictionnaire pour stocker les notes

 notes = {"Alice": 85, "Bob": 90, "Charlie": 78}

# Ajouter une nouvelle note

notes["David"] = 92

# Afficher les notes

for etudiant, note in notes.items():
print(f"{etudiant} : {note}")

Exercice 3 : Trouver les éléments communs entre deux ensembles

 Objectif : Trouver les éléments communs entre deux ensembles.

 Solution :
python

Copy

# Définir deux ensembles

ensemble1 = {1, 2, 3, 4, 5}
ensemble2 = {4, 5, 6, 7, 8}

# Trouver l'intersection
elements_communs = ensemble1 & ensemble2

# Afficher les éléments communs

print("Éléments communs :", elements_communs)

Explication des exercices :

Exercice 1 :

 input() : Demande à l'utilisateur de saisir des nombres.

 split() : Divise la chaîne de caractères en une liste de sous-chaînes.
 map(float, ...) : Convertit chaque sous-chaîne en nombre à virgule
flottante.
 sort() : Trie la liste en place.

Exercice 2 :

 dictionnaire : Stocke les notes des étudiants avec leurs noms comme
clés.
 items() : Parcourt les paires clé-valeur du dictionnaire.
 f-string : Formate l'affichage des notes.

Exercice 3 :

 & : Opérateur d'intersection pour trouver les éléments communs.

 print() : Affiche les éléments communs.
Conclusion :

 Vous avez appris à manipuler des listes, tuples, ensembles et

dictionnaires en Python.
 Vous avez pratiqué le tri, l'ajout, la suppression et le parcours de ces
structures.
 Ces compétences sont essentielles pour gérer des collections de
données en Python.
5. Fonctions

Objectifs :

 Définir et utiliser des fonctions en Python.

 Comprendre les paramètres et les valeurs de retour.
 Explorer les fonctions lambda et la portée des variables.

Contenu détaillé :

1. Déclaration et appel de fonctions

 Déclaration :
o Utilisez le mot-clé def pour définir une fonction.
o Exemple :
python

Copy

def dire_bonjour():
print("Bonjour !")
 Appel :
o Utilisez le nom de la fonction suivi de parenthèses pour l'appeler.
o Exemple :
python

Copy

dire_bonjour() # Affiche "Bonjour !"

2. Paramètres et valeurs de retour

a) Paramètres :

 Les fonctions peuvent accepter des paramètres pour personnaliser leur

comportement.
 Exemple :
python

Copy

def saluer(nom):
print(f"Bonjour, {nom} !")
 saluer("Alice") # Affiche "Bonjour, Alice !"

b) Valeurs de retour :

 Utilisez le mot-clé return pour renvoyer une valeur.

 Exemple :
python

Copy

def addition(a, b):

return a + b

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

3. Paramètres par défaut et optionnels

 Paramètres par défaut :

o Les paramètres peuvent avoir des valeurs par défaut.
o Exemple :
python

Copy

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

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

saluer("Bob") # Affiche "Bonjour, Bob !"
 Paramètres optionnels :
o Utilisez *args pour accepter un nombre variable de paramètres.
o Exemple :
python

Copy

def addition_multiple(*args):
return sum(args)

resultat = addition_multiple(1, 2, 3, 4) # resultat = 10

4. Portée des variables

 Variable locale :
o Une variable définie dans une fonction est locale à cette fonction.
 o Exemple :
python

Copy

def ma_fonction():
x = 10 # Variable locale
print(x)

ma_fonction() # Affiche 10
print(x) # Erreur : x n'est pas défini en dehors de la fonction
 Variable globale :
o Une variable définie en dehors de toute fonction est globale.
o Exemple :
python

Copy

x = 5 # Variable globale

def ma_fonction():
print(x) # Accède à la variable globale

ma_fonction() # Affiche 5

5. Lambda fonctions

 Définition :
o Une fonction lambda est une petite fonction anonyme.
o Syntaxe : lambda paramètres: expression.
 Exemple :
python

Copy

addition = lambda a, b: a + b
resultat = addition(3, 5) # resultat = 8

Exercices pratiques :

Exercice 1 : Calculer la factorielle d’un nombre

 Objectif : Écrire une fonction qui calcule la factorielle d'un nombre.

 Solution :
python
 Copy

def factorielle(n):
if n == 0 or n == 1:
return 1
else:
return n * factorielle(n - 1)

# Exemple d'utilisation
print(factorielle(5)) # Affiche 120

Exercice 2 : Vérifier si une chaîne est un palindrome

 Objectif : Créer une fonction qui vérifie si une chaîne est un

palindrome.
 Solution :
python

Copy

def est_palindrome(chaine):
chaine = chaine.lower().replace(" ", "") # Ignorer la casse et les espaces
return chaine == chaine[::-1]

# Exemple d'utilisation
print(est_palindrome("Kayak")) # Affiche True
print(est_palindrome("Python")) # Affiche False

Exercice 3 : Trier une liste de tuples avec une fonction lambda

 Objectif : Implémenter une fonction lambda pour trier une liste de

tuples.
 Solution :
python

Copy

# Liste de tuples (nom, âge)

personnes = [("Alice", 25), ("Bob", 20), ("Charlie", 30)]

# Trier par âge (deuxième élément du tuple)

personnes_triees = sorted(personnes, key=lambda x: x[1])

# Afficher la liste triée

print(personnes_triees) # Affiche [('Bob', 20), ('Alice', 25), ('Charlie', 30)]

Explication des exercices :

Exercice 1 :

 factorielle(n) : Fonction récursive qui calcule la factorielle d'un

nombre.
 if n == 0 or n == 1 : Cas de base pour arrêter la récursion.
 return n * factorielle(n - 1) : Appel récursif pour calculer la
factorielle.

Exercice 2 :

 chaine.lower() : Convertit la chaîne en minuscules.

 replace(" ", "") : Supprime les espaces.
 chaine[::-1] : Inverse la chaîne.
 return chaine == chaine[::-1] : Compare la chaîne originale à sa
version inversée.

Exercice 3 :

 sorted() : Trie la liste en fonction de la clé spécifiée.

 lambda x: x[1] : Fonction lambda pour trier par le deuxième élément
du tuple (âge).

Conclusion :

 Vous avez appris à définir et utiliser des fonctions en Python.

 Vous avez exploré les paramètres, les valeurs de retour, la portée des
variables et les fonctions lambda.
 Ces compétences sont essentielles pour organiser et réutiliser du code
efficacement.
6. Modules et bibliothèques

Objectifs :

 Importer et utiliser des modules standard : Apprendre à importer

et à utiliser les modules intégrés à Python pour étendre les
fonctionnalités de base du langage.
 Découvrir des bibliothèques tierces : Explorer des bibliothèques
externes qui peuvent être installées et utilisées pour des tâches
spécifiques.

Contenu :

1. Importation de modules :
o Python dispose de nombreux modules standard qui fournissent
des fonctionnalités supplémentaires. Par exemple, le
module math offre des fonctions mathématiques avancées, tandis
que le module random permet de générer des nombres aléatoires.
o Exemple d'importation et d'utilisation :
python

Copy

import math
print(math.sqrt(16)) # Affiche 4.0

import random
print(random.randint(1, 10)) # Génère un nombre aléatoire entre 1 et 10
2. Gestion des fichiers avec le module os :
o Le module os permet d'interagir avec le système d'exploitation,
notamment pour la gestion des fichiers et répertoires.
o Exemple d'utilisation :
python

Copy

import os

# Vérifier si un fichier existe

if os.path.exists("mon_fichier.txt"):
print("Le fichier existe.")
else:
print("Le fichier n'existe pas.")

# Lister les fichiers dans un répertoire

fichiers = os.listdir(".")
print(fichiers)
3. Installation de bibliothèques via pip :
 o pip est le gestionnaire de paquets de Python. Il permet d'installer
des bibliothèques tierces.
o Exemple d'installation d'une bibliothèque :
bash

Copy

pip install requests

o Une fois installée, la bibliothèque peut être importée et utilisée
dans votre code :
python

Copy

import requests
response = requests.get("https://www.example.com")
print(response.text)

Exercices :

1. Générer un mot de passe aléatoire avec le module random :

o Créez un script qui génère un mot de passe aléatoire de 12
caractères, composé de lettres majuscules, minuscules, et de
chiffres.
o Exemple de code :
python

Copy

import random
import string

def generer_mot_de_passe(longueur=12):
caracteres = string.ascii_letters + string.digits
mot_de_passe = ''.join(random.choice(caracteres) for i in range(longueur))
return mot_de_passe

print(generer_mot_de_passe())
2. Lire et écrire dans un fichier texte :
o Créez un script qui écrit une chaîne de caractères dans un fichier
texte, puis lit et affiche le contenu de ce fichier.
o Exemple de code :
python

Copy

# Écrire dans un fichier

 with open("mon_fichier.txt", "w") as fichier:
fichier.write("Bonjour, ceci est un test.")

# Lire le fichier
with open("mon_fichier.txt", "r") as fichier:
contenu = fichier.read()
print(contenu)
3. Utiliser une bibliothèque comme requests pour récupérer le
contenu d’une page web :
o Installez la bibliothèque requests et utilisez-la pour récupérer le
contenu HTML d'une page web, puis affichez les 100 premiers
caractères de ce contenu.
o Exemple de code :
python

Copy

import requests

url = "https://www.example.com"
response = requests.get(url)
print(response.text[:100]) # Affiche les 100 premiers caractères de la page

Conclusion :

Les modules et bibliothèques sont des outils essentiels en Python pour

étendre les fonctionnalités du langage et accomplir des tâches complexes
avec moins de code. En maîtrisant l'importation de modules standard, la
gestion des fichiers avec os, et l'installation de bibliothèques tierces via pip,
vous serez en mesure de développer des applications plus robustes et
fonctionnelles.
7. Programmation orientée objet (POO)

Objectifs :

 Comprendre les concepts de base de la POO : Apprendre les

principes fondamentaux de la programmation orientée objet, tels que
les classes, les objets, l'encapsulation, l'héritage et le polymorphisme.
 Créer des classes et des objets : Savoir définir des classes,
instancier des objets et manipuler leurs attributs et méthodes.

Contenu :

1. Classes, objets, méthodes et attributs :

o Une classe est un modèle ou un plan pour créer des objets. Elle
définit les attributs (données) et les méthodes (comportements)
que les objets auront.
o Un objet est une instance d'une classe.
o Les attributs sont des variables qui appartiennent à un objet.
o Les méthodes sont des fonctions qui appartiennent à un objet.
Exemple de classe simple :

python

Copy

class Etudiant:
def __init__(self, nom, age):
self.nom = nom # Attribut
self.age = age # Attribut

def afficher_info(self): # Méthode

print(f"Nom: {self.nom}, Âge: {self.age}")

# Création d'un objet

etudiant1 = Etudiant("Alice", 20)
etudiant1.afficher_info() # Affiche "Nom: Alice, Âge: 20"
2. Constructeurs (__init__) :
o Le constructeur est une méthode spéciale appelée lors de la
création d'un objet. En Python, il est défini avec __init__.
o Il permet d'initialiser les attributs de l'objet.
Exemple :
python

Copy

class Etudiant:
def __init__(self, nom, age):
 self.nom = nom
self.age = age
3. Héritage et polymorphisme :
o Héritage : Une classe peut hériter des attributs et méthodes
d'une autre classe. Cela permet de réutiliser du code.
o Polymorphisme : La capacité d'une méthode à s'adapter à
différents types d'objets.
Exemple d'héritage :
python

Copy

class Personne:
def __init__(self, nom, age):
self.nom = nom
self.age = age

def se_presenter(self):
print(f"Je m'appelle {self.nom} et j'ai {self.age} ans.")

class Etudiant(Personne): # Héritage

def __init__(self, nom, age, note):
super().__init__(nom, age) # Appel du constructeur de la classe parente
self.note = note

def afficher_note(self):
print(f"Ma note est {self.note}.")

etudiant1 = Etudiant("Bob", 22, 15)

etudiant1.se_presenter() # Affiche "Je m'appelle Bob et j'ai 22 ans."
etudiant1.afficher_note() # Affiche "Ma note est 15."
4. Méthodes magiques (__str__, __repr__, etc.) :
o Les méthodes magiques sont des méthodes spéciales qui
commencent et se terminent par des doubles underscores ( __).
Elles permettent de définir des comportements spécifiques pour
les objets.
o Exemples :
 __str__ : Définit la représentation en chaîne de caractères
d'un objet (utilisée par print).
 __repr__ : Définit une représentation formelle de l'objet
(utilisée pour le débogage).
Exemple :
python

Copy

class Etudiant:
def __init__(self, nom, age):
 self.nom = nom
self.age = age

def __str__(self):
return f"Étudiant: {self.nom}, {self.age} ans"

def __repr__(self):
return f"Etudiant(nom={self.nom}, age={self.age})"

etudiant1 = Etudiant("Charlie", 21)

print(etudiant1) # Affiche "Étudiant: Charlie, 21 ans"
print(repr(etudiant1)) # Affiche "Etudiant(nom=Charlie, age=21)"

Exercices :

1. Créer une classe pour modéliser un étudiant avec ses notes et

calculer sa moyenne :
o Définissez une classe Etudiant avec des attributs pour le nom,
l'âge et une liste de notes.
o Ajoutez une méthode pour calculer la moyenne des notes.
o Exemple de code :
python

Copy

class Etudiant:
def __init__(self, nom, age):
self.nom = nom
self.age = age
self.notes = []

def ajouter_note(self, note):

self.notes.append(note)

def calculer_moyenne(self):
if not self.notes:
return 0
return sum(self.notes) / len(self.notes)

# Utilisation
etudiant1 = Etudiant("David", 23)
etudiant1.ajouter_note(15)
etudiant1.ajouter_note(18)
etudiant1.ajouter_note(12)
print(f"Moyenne de {etudiant1.nom}: {etudiant1.calculer_moyenne()}")
2. Implémenter un système de gestion de bibliothèque (livres,
emprunteurs) :
o Créez une classe Livre avec des attributs comme le titre, l'auteur
et l'état (disponible ou emprunté).
o Créez une classe Emprunteur avec des attributs comme le nom et
une liste de livres empruntés.
 o Ajoutez des méthodes pour emprunter et retourner des livres.
o Exemple de code :
python

Copy

class Livre:
def __init__(self, titre, auteur):
self.titre = titre
self.auteur = auteur
self.disponible = True

def __str__(self):
return f"{self.titre} par {self.auteur}"

class Emprunteur:
def __init__(self, nom):
self.nom = nom
self.livres_empruntes = []

def emprunter_livre(self, livre):

if livre.disponible:
livre.disponible = False
self.livres_empruntes.append(livre)
print(f"{livre.titre} a été emprunté par {self.nom}.")
else:
print(f"{livre.titre} n'est pas disponible.")

def retourner_livre(self, livre):

if livre in self.livres_empruntes:
livre.disponible = True
self.livres_empruntes.remove(livre)
print(f"{livre.titre} a été retourné par {self.nom}.")
else:
print(f"{livre.titre} n'a pas été emprunté par {self.nom}.")

# Utilisation
livre1 = Livre("1984", "George Orwell")
livre2 = Livre("Le Petit Prince", "Antoine de Saint-Exupéry")

emprunteur1 = Emprunteur("Alice")
emprunteur1.emprunter_livre(livre1)
emprunteur1.emprunter_livre(livre2)
emprunteur1.retourner_livre(livre1)

Conclusion :

La programmation orientée objet (POO) est un paradigme puissant qui

permet de structurer le code en regroupant les données et les
comportements dans des objets. En maîtrisant les concepts de classes,
objets, héritage, polymorphisme et méthodes magiques, vous serez en
mesure de créer des programmes plus modulaires, réutilisables et faciles à
maintenir. Les exercices proposés vous aideront à pratiquer ces concepts en
contexte réel.
8. Gestion des erreurs

Objectifs :

 Identifier et gérer les erreurs dans un programme : Apprendre à

détecter et à gérer les erreurs qui peuvent survenir pendant l'exécution
d'un programme.
 Utiliser les exceptions : Comprendre comment utiliser les exceptions
pour gérer les erreurs de manière structurée.

Contenu :

1. Bloc try...except :
o Le bloc try permet d'encapsuler du code qui pourrait générer une
exception.
o Le bloc except permet de capturer et de gérer l'exception si elle
se produit.
o Exemple :
python

Copy

try:
resultat = 10 / 0
except ZeroDivisionError:
print("Erreur: Division par zéro.")
2. Lancer des exceptions avec raise :
o Vous pouvez lancer manuellement une exception avec le mot-
clé raise. Cela est utile pour signaler des erreurs spécifiques dans
votre code.
o Exemple :
python

Copy

def verifier_age(age):
if age < 0:
raise ValueError("L'âge ne peut pas être négatif.")
return age

try:
verifier_age(-5)
except ValueError as e:
print(e) # Affiche "L'âge ne peut pas être négatif."
3. Bloc finally :
 o Le bloc finally est exécuté après les blocs try et except, qu'une
exception ait été levée ou non. Il est souvent utilisé pour libérer
des ressources ou effectuer des opérations de nettoyage.
o Exemple :
python

Copy

try:
fichier = open("mon_fichier.txt", "r")
contenu = fichier.read()
except FileNotFoundError:
print("Fichier non trouvé.")
finally:
fichier.close() # Ferme le fichier dans tous les cas

Exercices :

1. Écrire un programme qui gère la division par zéro :

o Créez un programme qui demande à l'utilisateur de saisir deux
nombres et qui effectue la division du premier par le second.
Gérez l'exception si l'utilisateur tente de diviser par zéro.
o Exemple de code :
python

Copy

try:
numerateur = int(input("Entrez le numérateur: "))
denominateur = int(input("Entrez le dénominateur: "))
resultat = numerateur / denominateur
print(f"Le résultat de la division est: {resultat}")
except ZeroDivisionError:
print("Erreur: Division par zéro.")
except ValueError:
print("Erreur: Veuillez entrer des nombres valides.")
2. Valider les entrées utilisateur avec des exceptions :
o Créez un programme qui demande à l'utilisateur de saisir son
âge. Validez que l'âge est un nombre positif. Si l'utilisateur entre
une valeur invalide, levez une exception et affichez un message
d'erreur.
o Exemple de code :
python

Copy

def valider_age(age):
if not isinstance(age, int) or age < 0:
 raise ValueError("L'âge doit être un nombre entier positif.")
return age

try:
age = int(input("Entrez votre âge: "))
valider_age(age)
print(f"Vous avez {age} ans.")
except ValueError as e:
print(f"Erreur: {e}")

Conclusion :

La gestion des erreurs est une partie essentielle de la programmation, car

elle permet de rendre les programmes plus robustes et fiables. En utilisant
les blocs try...except, vous pouvez capturer et gérer les exceptions de manière
contrôlée. Le mot-clé raise vous permet de signaler des erreurs spécifiques,
tandis que le bloc finally est utile pour les opérations de nettoyage. Les
exercices proposés vous aideront à pratiquer ces concepts en contexte réel.
9. Automatisation et projets

Objectifs :

 Utiliser Python pour automatiser des tâches pratiques :

Apprendre à écrire des scripts Python pour automatiser des tâches
répétitives ou complexes.
 Travailler sur un projet final : Appliquer les connaissances acquises
pour développer un projet complet, en intégrant plusieurs concepts et
bibliothèques.

Exemples de projets :

1. Automatiser l’envoi d’e-mails :

o Utilisez le module smtplib pour envoyer des e-mails
automatiquement. Cela peut être utile pour envoyer des
rapports, des notifications ou des newsletters.
o Exemple de code :
python

Copy

import smtplib
from email.mime.text import MIMEText
from email.mime.multipart import MIMEMultipart

def envoyer_email(destinataire, sujet, corps):

# Configuration
expediteur = "[email protected]"
mot_de_passe = "votre_mot_de_passe"

# Création du message
message = MIMEMultipart()
message["From"] = expediteur
message["To"] = destinataire
message["Subject"] = sujet
message.attach(MIMEText(corps, "plain"))

# Connexion au serveur SMTP

with smtplib.SMTP("smtp.gmail.com", 587) as serveur:
serveur.starttls() # Sécurisation de la connexion
serveur.login(expediteur, mot_de_passe)
serveur.sendmail(expediteur, destinataire, message.as_string())
print("E-mail envoyé avec succès.")

# Utilisation
envoyer_email("[email protected]", "Sujet de l'e-mail", "Ceci est un
test d'envoi d'e-mail.")
2. Créer une calculatrice graphique avec tkinter :
 o Utilisez la bibliothèque tkinter pour créer une interface graphique
simple pour une calculatrice.
o Exemple de code :
python

Copy

import tkinter as tk

def cliquer(chiffre):
entree.insert(tk.END, chiffre)

def calculer():
try:
resultat = eval(entree.get())
entree.delete(0, tk.END)
entree.insert(0, str(resultat))
except Exception:
entree.delete(0, tk.END)
entree.insert(0, "Erreur")

# Création de la fenêtre
fenetre = tk.Tk()
fenetre.title("Calculatrice")

# Champ d'entrée
entree = tk.Entry(fenetre, width=20, font=("Arial", 16))
entree.grid(row=0, column=0, columnspan=4)

# Boutons
boutons = [
'7', '8', '9', '/',
'4', '5', '6', '*',
'1', '2', '3', '-',
'0', '.', '=', '+'
]

ligne = 1
colonne = 0
for bouton in boutons:
action = lambda x=bouton: cliquer(x) if x != '=' else calculer()
tk.Button(fenetre, text=bouton, width=5, height=2,
command=action).grid(row=ligne, column=colonne)
colonne += 1
if colonne > 3:
colonne = 0
ligne += 1

# Lancement de l'application
fenetre.mainloop()
3. Développer un mini-jeu (comme le jeu du pendu) :
o Créez un jeu du pendu en utilisant des concepts de base comme
les boucles, les conditions et les fonctions.
 o Exemple de code :
python

Copy

import random

def choisir_mot():
mots = ["python", "programmation", "ordinateur", "algorithme",
"développement"]
return random.choice(mots)

def afficher_mot_cache(mot, lettres_trouvees):

return " ".join([lettre if lettre in lettres_trouvees else "_" for lettre in mot])

def jeu_du_pendu():
mot = choisir_mot()
lettres_trouvees = set()
tentatives = 6

print("Bienvenue au jeu du pendu !")

while tentatives > 0:
print(f"\nMot à deviner: {afficher_mot_cache(mot, lettres_trouvees)}")
lettre = input("Devinez une lettre: ").lower()

if lettre in lettres_trouvees:
print("Vous avez déjà deviné cette lettre.")
elif lettre in mot:
lettres_trouvees.add(lettre)
if all(lettre in lettres_trouvees for lettre in mot):
print(f"Félicitations ! Vous avez deviné le mot: {mot}")
break
else:
tentatives -= 1
print(f"Lettre incorrecte. Il vous reste {tentatives} tentatives.")

if tentatives == 0:
print(f"Dommage ! Le mot était: {mot}")

# Lancement du jeu
jeu_du_pendu()

Conclusion :

L'automatisation et les projets pratiques sont d'excellents moyens de

consolider vos compétences en Python. En automatisant des tâches comme
l'envoi d'e-mails, en créant des interfaces graphiques avec tkinter, ou en
développant des jeux comme le pendu, vous appliquez des concepts clés
tout en réalisant des projets concrets. Ces projets vous permettent
également d'explorer des bibliothèques et des outils supplémentaires, ce qui
élargit vos compétences en programmation.