1. La programmation orientée objet : classes et objets

Jusqu'ici, tu as surtout programmé en manipulant des variables, des listes et des fonctions indépendantes les unes des autres : c'est la programmation procédurale. La programmation orientée objet (POO) propose une autre manière d'organiser un programme : elle regroupe des données et les fonctions qui les manipulent au sein d'une même entité, appelée objet.

Définition

Une classe est un modèle (un plan, un moule) qui décrit un ensemble d'objets possédant les mêmes attributs (les données qu'ils contiennent) et les mêmes méthodes (les fonctions qui leur sont propres). Un objet est une instance concrète de cette classe : il possède sa propre copie des attributs, avec ses propres valeurs.

Exemple — analogie

Le plan d'une maison correspond à la classe : il définit qu'une maison possède un nombre de pièces, une superficie, une couleur de façade, et des actions possibles (ouvrir la porte, allumer la lumière). Chaque maison réellement construite à partir de ce plan est un objet : la maison de Mamie a 4 pièces et une façade blanche, celle du voisin a 6 pièces et une façade ocre. Même plan (même classe), mais des maisons différentes (des objets différents), chacune avec ses propres valeurs.

En Python, tu utilises ce principe depuis le début sans forcément le remarquer : une chaîne de caractères "Kinshasa" est un objet de la classe str, une liste [1, 2, 3] est un objet de la classe list. Les méthodes .upper() ou .append() que tu connais déjà sont des méthodes définies dans ces classes.

TermeSignification
ClasseLe modèle général (ex. Eleve)
Objet / instanceUn exemplaire concret créé à partir de la classe
AttributUne donnée propre à l'objet (ex. nom, moyenne)
MéthodeUne fonction définie dans la classe, qui agit sur l'objet
selfRéférence vers l'objet lui-même, à l'intérieur d'une méthode

2. Créer des classes et des méthodes

En Python, une classe se définit avec le mot-clé class. La méthode spéciale __init__, appelée constructeur, est exécutée automatiquement à la création de chaque objet : elle sert à initialiser les attributs.

Pythonclass Eleve: def __init__(self, nom, moyenne): self.nom = nom self.moyenne = moyenne def a_la_mention(self): if self.moyenne >= 16: return "Très bien" elif self.moyenne >= 14: return "Bien" elif self.moyenne >= 12: return "Assez bien" elif self.moyenne >= 10: return "Passable" else: return "Aucune mention" # Création d'un objet : une instance de la classe Eleve eleve1 = Eleve("Fatou Mbemba", 15.5) print(eleve1.nom) # Fatou Mbemba print(eleve1.moyenne) # 15.5 print(eleve1.a_la_mention()) # Bien

Quelques points essentiels à retenir :

  • Le premier paramètre de toute méthode est toujours self : il désigne l'objet sur lequel la méthode est appelée. Python le fournit automatiquement — tu ne l'indiques jamais lors de l'appel (eleve1.a_la_mention(), et non eleve1.a_la_mention(eleve1)).
  • Les attributs se lisent et s'écrivent avec la notation pointée : eleve1.nom.
  • On peut créer autant d'objets que l'on veut à partir d'une même classe : eleve2 = Eleve("Brice Ikama", 9).
  • Une classe peut aussi définir une méthode spéciale __str__ pour contrôler l'affichage de l'objet avec print().

3. Manipuler des données avec pandas

Définition

pandas est une bibliothèque Python spécialisée dans la manipulation et l'analyse de données tabulaires. Sa structure centrale est le DataFrame : un tableau à deux dimensions, organisé en lignes et en colonnes, comparable à une feuille de calcul.

Pythonimport pandas as pd donnees = { "nom": ["Aline", "Brice", "Chris"], "moyenne": [14.5, 11.0, 17.25] } df = pd.DataFrame(donnees) print(df.head()) # nom moyenne # 0 Aline 14.50 # 1 Brice 11.00 # 2 Chris 17.25

La bibliothèque s'importe par convention sous l'alias pd. La méthode .head() affiche les premières lignes du DataFrame (les 5 premières par défaut, ou moins si le tableau est plus petit) — pratique pour vérifier rapidement le contenu d'un grand jeu de données sans tout afficher. pandas propose aussi des opérations statistiques immédiates, comme df["moyenne"].mean() pour calculer une moyenne, ou df.sort_values("moyenne") pour trier les lignes.

4. Créer des graphiques avec matplotlib

matplotlib est la bibliothèque de référence pour représenter des données sous forme de graphiques en Python. Son module pyplot, importé sous l'alias plt, fournit des fonctions simples pour tracer courbes, barres, nuages de points, etc.

Pythonimport matplotlib.pyplot as plt noms = ["Aline", "Brice", "Chris"] moyennes = [14.5, 11.0, 17.25] plt.bar(noms, moyennes, color="#4338CA") plt.title("Moyennes de la classe") plt.xlabel("Élève") plt.ylabel("Moyenne / 20") plt.show()

Pour représenter une évolution dans le temps plutôt qu'une comparaison entre catégories, on préfère un graphique en ligne avec plt.plot() :

Pythonmois = ["Sept.", "Oct.", "Nov.", "Déc."] moyenne_classe = [11.2, 12.0, 12.8, 13.5] plt.plot(mois, moyenne_classe, marker="o", color="#1F9D55") plt.title("Évolution de la moyenne de la classe") plt.ylabel("Moyenne / 20") plt.grid(True) plt.show()

plt.show() est indispensable : c'est cette instruction qui ouvre la fenêtre affichant le graphique construit par les instructions précédentes.

5. Automatiser des tâches répétitives

L'un des grands intérêts de la programmation est d'automatiser des tâches longues, répétitives et sources d'erreurs si elles sont réalisées manuellement : renommer des centaines de fichiers, trier des données, générer des documents, etc. Le module os permet d'interagir avec le système de fichiers.

Exemple — renommage automatique de fichiers

Un professeur souhaite renommer toutes les photos d'identité d'une classe, stockées en vrac dans un dossier, en eleve_001.jpg, eleve_002.jpg, etc.

Pythonimport os dossier = "photos_classe" for i, nom_fichier in enumerate(os.listdir(dossier), start=1): extension = nom_fichier.split(".")[-1] nouveau_nom = f"eleve_{i:03d}.{extension}" ancien_chemin = os.path.join(dossier, nom_fichier) nouveau_chemin = os.path.join(dossier, nouveau_nom) os.rename(ancien_chemin, nouveau_chemin) print(f"{nom_fichier} renommé en {nouveau_nom}")

os.listdir() renvoie la liste des fichiers d'un dossier, enumerate(..., start=1) fournit un compteur, et os.rename() effectue le renommage. Ce même principe — parcourir une liste et appliquer un traitement identique à chaque élément — s'applique à d'innombrables tâches : convertir des fichiers, envoyer des messages en masse, remplir automatiquement des formulaires, etc.

6. Créer une interface graphique avec tkinter

tkinter est le module standard de Python (inclus par défaut, sans installation) pour créer des interfaces graphiques : fenêtres, boutons, champs de texte, étiquettes, etc.

Pythonimport tkinter as tk def dire_bonjour(): etiquette.config(text="Bonjour et bienvenue !") fenetre = tk.Tk() fenetre.title("Ma première interface") fenetre.geometry("300x150") etiquette = tk.Label(fenetre, text="Clique sur le bouton", font=("Arial", 12)) etiquette.pack(pady=20) bouton = tk.Button(fenetre, text="Cliquer ici", command=dire_bonjour) bouton.pack() fenetre.mainloop()

Quelques éléments clés : Tk() crée la fenêtre principale, .pack() place un widget (élément graphique) dans la fenêtre, l'argument command associe une fonction à un bouton (sans les parenthèses, car on transmet la fonction elle-même, pas son résultat), et mainloop() démarre la boucle d'attente des événements (clics, saisies...) : sans cet appel, la fenêtre ne s'affiche pas.

7. Les bases du web scraping

Définition

Le web scraping consiste à récupérer automatiquement, par programme, des informations affichées sur des pages web, plutôt que de les copier manuellement. Un script envoie une requête vers une page, récupère son contenu HTML, puis en extrait les données utiles (titres, prix, dates...).

Pythonimport requests from bs4 import BeautifulSoup reponse = requests.get("https://exemple-bibliotheque.cg/nouveautes") page = BeautifulSoup(reponse.text, "html.parser") titres = page.find_all("h2", class_="titre-livre") for titre in titres: print(titre.get_text())

La bibliothèque requests télécharge le contenu de la page, et BeautifulSoup (souvent importée depuis le paquet bs4) permet d'analyser ce contenu HTML pour y repérer précisément les balises recherchées.

Aspects légaux et éthiques. Le web scraping n'est pas sans limites : il faut toujours respecter les conditions d'utilisation du site visité, vérifier le fichier robots.txt qui précise les zones autorisées à l'exploration automatique, respecter le droit d'auteur sur les contenus récupérés, et éviter d'envoyer un trop grand nombre de requêtes en peu de temps (ce qui peut surcharger le serveur, voire être assimilé à une attaque). Scraper un site sans autorisation pour en revendre le contenu, par exemple, est généralement illégal.

8. Connecter Python à une base de données SQLite

SQLite est un système de gestion de base de données léger, stocké dans un simple fichier, directement accessible en Python via le module standard sqlite3 (aucune installation supplémentaire n'est nécessaire).

Pythonimport sqlite3 connexion = sqlite3.connect("bibliotheque.db") curseur = connexion.cursor() curseur.execute(""" CREATE TABLE IF NOT EXISTS livres ( id INTEGER PRIMARY KEY AUTOINCREMENT, titre TEXT NOT NULL, auteur TEXT, annee INTEGER ) """) curseur.execute( "INSERT INTO livres (titre, auteur, annee) VALUES (?, ?, ?)", ("Une saison au Congo", "Aimé Césaire", 1966) ) connexion.commit() curseur.execute("SELECT * FROM livres") for ligne in curseur.fetchall(): print(ligne) connexion.close()

connect() ouvre (ou crée) le fichier de base de données, cursor() fournit un curseur permettant d'exécuter des requêtes SQL, et execute() transmet ces requêtes. Les ? dans la requête d'insertion sont des paramètres substitués : ils protègent contre les erreurs de syntaxe et les failles d'injection SQL. commit() valide définitivement les modifications, et close() referme proprement la connexion.

🧠 À retenir

  • Une classe est un modèle ; un objet est une instance concrète de ce modèle, avec ses propres attributs.
  • Le constructeur __init__ initialise les attributs d'un objet ; self désigne l'objet lui-même dans une méthode.
  • pandas structure les données en DataFrame et facilite leur lecture, leur tri et leurs statistiques.
  • matplotlib (module pyplot) permet de tracer des graphiques en barres (plt.bar()) ou en ligne (plt.plot()) ; plt.show() les affiche.
  • Le module os permet d'automatiser des tâches répétitives sur des fichiers, comme un renommage en masse.
  • tkinter fournit les briques (fenêtre, label, bouton) pour construire une interface graphique simple ; mainloop() la maintient active.
  • Le web scraping automatise la collecte d'informations sur le web, mais doit respecter les conditions d'utilisation, le droit d'auteur et le fichier robots.txt.
  • sqlite3 connecte Python à une base de données locale : connect(), cursor(), execute(), commit() et close() en sont les étapes clés.
1

Une classe Rectangle

Facile

Écris une classe Rectangle possédant deux attributs, longueur et largeur, initialisés dans le constructeur, ainsi qu'une méthode aire() qui renvoie l'aire du rectangle. Crée ensuite un objet r1 avec une longueur de 5 et une largeur de 3, et affiche son aire.

Correction
Pythonclass Rectangle: def __init__(self, longueur, largeur): self.longueur = longueur self.largeur = largeur def aire(self): return self.longueur * self.largeur r1 = Rectangle(5, 3) print(r1.aire()) # 15

self.longueur et self.largeur sont les attributs de l'objet ; ils sont créés dans __init__ puis réutilisés dans la méthode aire() grâce à self.

2

Un DataFrame de notes

Facile

À partir de la liste de notes notes = [12, 15.5, 8, 17, 10.5], crée un DataFrame pandas à une colonne nommée "note", affiche ses premières lignes avec .head(), puis calcule la moyenne de la classe.

Correction
Pythonimport pandas as pd notes = [12, 15.5, 8, 17, 10.5] df = pd.DataFrame({"note": notes}) print(df.head()) print("Moyenne :", df["note"].mean()) # Moyenne : 12.6

La clé du dictionnaire ("note") devient le nom de la colonne du DataFrame. .mean() calcule directement la moyenne de la colonne, sans écrire de boucle.

3

Graphique des notes

Moyen

Reprends la liste de notes de l'exercice précédent, associée à la liste de prénoms ["Aline", "Brice", "Chris", "Diane", "Eric"], et trace un graphique en ligne représentant ces notes, avec un titre, une étiquette sur l'axe des ordonnées et une grille.

Correction
Pythonimport matplotlib.pyplot as plt eleves = ["Aline", "Brice", "Chris", "Diane", "Eric"] notes = [12, 15.5, 8, 17, 10.5] plt.plot(eleves, notes, marker="o", color="#D7193F") plt.title("Notes de la classe") plt.ylabel("Note / 20") plt.grid(True) plt.show()

L'argument marker="o" ajoute un point rond à chaque valeur, ce qui facilite la lecture des notes individuelles sur la courbe.

4

Insertion dans SQLite

Moyen

Écris un script qui se connecte (ou crée) une base de données classe.db, crée si nécessaire une table eleves (colonnes id, nom, note), puis insère l'enregistrement ("Diane Loemba", 17) avant de valider et de fermer la connexion.

Correction
Pythonimport sqlite3 connexion = sqlite3.connect("classe.db") curseur = connexion.cursor() curseur.execute(""" CREATE TABLE IF NOT EXISTS eleves ( id INTEGER PRIMARY KEY AUTOINCREMENT, nom TEXT NOT NULL, note REAL ) """) curseur.execute( "INSERT INTO eleves (nom, note) VALUES (?, ?)", ("Diane Loemba", 17) ) connexion.commit() connexion.close()

La clause IF NOT EXISTS évite une erreur si le script est exécuté plusieurs fois : la table n'est créée qu'une seule fois. Il ne faut jamais oublier connexion.commit(), sans quoi l'insertion resterait en attente et ne serait pas enregistrée durablement.

5

Mini-projet : gestion des notes d'une classe

Difficile

Conçois un mini-projet de gestion des notes d'une classe : définis une classe Eleve (attributs nom et note), crée une liste de 5 objets Eleve, convertis-la en DataFrame pandas, affiche la moyenne de la classe, puis trace un diagramme en barres des notes avec une ligne horizontale représentant la moyenne.

Correction
Pythonimport pandas as pd import matplotlib.pyplot as plt class Eleve: def __init__(self, nom, note): self.nom = nom self.note = note classe = [ Eleve("Aline", 12), Eleve("Brice", 15.5), Eleve("Chris", 8), Eleve("Diane", 17), Eleve("Eric", 10.5) ] df = pd.DataFrame({ "nom": [e.nom for e in classe], "note": [e.note for e in classe] }) print(df.head()) print("Moyenne de la classe :", round(df["note"].mean(), 2)) plt.bar(df["nom"], df["note"], color="#1F9D55") plt.axhline(y=df["note"].mean(), color="#D7193F", linestyle="--", label="Moyenne") plt.title("Notes de la classe") plt.ylabel("Note / 20") plt.legend() plt.show()

Ce projet combine les trois notions du chapitre : la classe Eleve structure chaque élève, la liste en compréhension [e.nom for e in classe] extrait les attributs pour construire le DataFrame, et plt.axhline() superpose une ligne horizontale au niveau de la moyenne pour la comparer visuellement à chaque note.

QCM

10 questions · Correction immédiate

0Score
0/10Répondues
Question 1/10
Quelle affirmation décrit correctement la relation entre une classe et un objet ?
Question 2/10
Que fait ce programme ?
class Voiture: ... def __init__(self, marque): self.marque = marque ... v = Voiture("Toyota") ; print(v.marque)
Question 3/10
Dans une méthode de classe, à quoi correspond le paramètre self ?
Question 4/10
Quelle structure de données pandas permet de représenter un tableau à lignes et colonnes ?
Question 5/10
Dans df = pd.DataFrame({"note": [10, 12, 14]}) puis print(df.head()), que fait précisément .head() ?
Question 6/10
Quelle instruction matplotlib permet de tracer un graphique en barres ?
Question 7/10
Que fait ce script ?
import os
for fichier in os.listdir("dossier"): print(fichier)
Question 8/10
En tkinter, quelle instruction est indispensable pour que la fenêtre créée s'affiche réellement et réagisse aux clics ?
Question 9/10
Concernant le web scraping, quelle affirmation est correcte ?
Question 10/10
Dans ce script SQLite, à quoi sert précisément connexion.commit() ?
curseur.execute("INSERT INTO livres (titre) VALUES (?)", ("Roman",))
connexion.commit()