TP N° 5 : Python et les bases de données SQLite
Module : Programmation Orientée Objets
Niveau : CPI 2 Année universitaire :2024-2025
Exercice 1 : Gestionnaire de tâches
1. Création de la classe GestionnaireTaches :
Créez une classe GestionnaireTaches qui contient les méthodes suivantes :
creer_base_de_donnees() : méthode pour créer la base de données SQLite3 nommée [Link]
avec une table nommée taches. La table taches doit contenir les colonnes suivantes :
id : clé primaire de type entier
titre : texte représentant le titre de la tâche
description : texte représentant la description de la tâche
ajouter_tache(titre, description) : méthode pour ajouter une nouvelle tâche à la table taches de la
base de données.
afficher_taches() : méthode pour afficher toutes les tâches présentes dans la table taches avec leurs
titres et descriptions.
supprimer_tache(id_tache) : méthode pour supprimer une tâche de la table taches de la base de
données en utilisant son ID.
menu() : méthode pour afficher un menu interactif permettant à l'utilisateur de gérer les tâches. Le
menu doit proposer les options suivantes :
1. Ajouter une tache
2. Afficher les taches
3. Rechercher une tache par ID
4. Supprimer une tache
5. Quitter le programme
Écrivez un programme principal qui instancie la classe GestionnaireTaches et utilise le menu interactif pour
permettre à l'utilisateur de gérer les tâches. Assurez-vous de gérer les erreurs et les cas où l'utilisateur fournit
des entrées incorrectes.
Exercice 2 : Gestion d'expériences avec SQLite3
1
Vous devez créer un programme Python utilisant SQLite3 pour gérer des expériences scientifiques. Voici les
étapes à suivre :
1. Créez une classe GestionExperiences avec les méthodes suivantes :
- __init__(self, nom_exp, date_exp, responsable, resultats) : Initialise la classe avec les informations
d'une expérience.
2. creer_table_experiences(self) : Crée une table 'experiences' dans la base de données SQLite si elle
n'existe pas déjà.
- La table doit avoir les colonnes suivantes : 'id' (clé primaire, 'nom_exp' (texte), 'date_exp' (texte),
'responsable' (texte), 'resultats' (texte).
- ajouter_experience(self) : Ajoute l'expérience actuelle à la table 'experiences'.
- afficher_experiences(self) : Affiche toutes les expériences enregistrées dans la table 'experiences'.
- rechercher_experience(self, id_exp) : Recherche une expérience par son ID dans la table
'experiences' et affiche ses détails.
- modifier_resultats(self, id_exp, nouveaux_resultats) : Modifie les résultats d'une expérience
donnée par son ID dans la table 'experiences'.
- supprimer_experience(self, id_exp) : Supprime une expérience de la table 'experiences' par son
ID.
Créez une instance de la classe GestionExperiences avec des informations d'une expérience spécifique, puis
utilisez-la pour effectuer des opérations (Création, Lecture, Mise à jour, Suppression) sur la base de données.
Exercice 3 : Gestion des employés avec héritage et SQLite3
Vous allez créer un programme Python pour gérer une entreprise avec une hiérarchie d'employés en utilisant
l'héritage des classes et la bibliothèque SQLite3 pour la gestion des données.
1. Créez une classe de base Employe avec les attributs suivants :
__init__(self, nom, prenom, poste) : Initialise la classe avec le nom, prénom et poste de l'employé.
afficher_details(self) : Affiche les détails de l'employé (nom, prénom, poste).
Créez des classes dérivées pour différents types d'employés :
Manager : Un manager est un employé avec des attributs supplémentaires comme le nombre
d'employés sous sa supervision.
Technicien : Un technicien est un employé avec des compétences techniques spécifiques.
Stagiaire : Un stagiaire est un employé temporaire avec une durée de stage spécifique.
2. Utilisez SQLite3 pour créer une base de données nommée '[Link]' et une table 'employes'
avec les colonnes appropriées pour stocker les informations des employés, en incluant les
informations spécifiques à chaque type d'employé.
3. Implémentez les méthodes suivantes dans chaque classe dérivée pour la gestion des données dans la
base de données :
2
ajouter_employe(self) : Ajoute l'employé à la base de données.
afficher_employes(self) : Affiche tous les employés de la base de données avec leurs détails
respectifs.
rechercher_employe(self, nom) : Recherche un employé par son nom dans la base de données et
affiche ses détails.
modifier_poste(self, nom, nouveau_poste) : Modifie le poste d'un employé donné par son nom
dans la base de données.
supprimer_employe(self, nom) : Supprime un employé de la base de données par son nom.
4. Créez des instances de chaque classe dérivée et utilisez-les pour ajouter, afficher, rechercher,
modifier et supprimer des employés dans la base de données.
Exercice 4 : Gestion des contacts
Vous devez créer un gestionnaire de contacts en utilisant SQLite3. Voici les spécifications de l'exercice :
1. Classe GestionnaireContacts :
- La classe doit avoir les attributs suivants pour chaque contact : id (clé primaire de type entier), nom,
prenom, email et telephone.
- La classe doit avoir une méthode __init__ qui prend en paramètres id, nom, prenom, email et
telephone pour initialiser un contact et l'insérer dans la base de données.
- La classe doit avoir une méthode creer_table_contacts qui crée la table "contacts" dans la base de
données si elle n'existe pas déjà.
-
- La classe doit avoir une méthode afficher_contacts qui affiche tous les contacts présents dans la
base de données.
- La classe doit avoir une méthode rechercher_contact_par_id qui prend en paramètre l'ID d'un
contact et affiche ses détails s'il existe.
- La classe doit avoir une méthode modifier_contact qui prend en paramètres l'ID d'un contact ainsi
que les nouvelles valeurs pour nom, prenom, email et telephone, et modifie les informations du contact
correspondant.
- La classe doit avoir une méthode supprimer_contact qui prend en paramètre l'ID d'un contact et le
supprime de la base de données.
- La classe doit avoir une méthode nombre_total_contacts qui affiche le nombre total de contacts
présents dans la base de données.
Utilisez SQLite3 pour créer et gérer la base de données "[Link]".
3
TP N° 6 : Python et les bases de données SQLite
Module : Programmation Orientée Objets
Niveau : CPI 2 Année universitaire :2024-2025
Exercice 1 : Gestion de stock dans un magasin
Dans cet exercice, vous modéliserez une application de gestion de stock. L'objectif est de permettre diverses
opérations sur les produits (ajout, mise à jour, suppression) et de calculer des indicateurs utiles.
Base de données : [Link]
Table : produits(id, nom, categorie, prix_unitaire, quantite_stock)
Classe : Produit
Méthodes à développer :
ajouter_produit(self): Insère un nouveau produit dans la table
mettre_a_jour_produit(self, id): Permet de modifier les attributs d’un produit identifié (ex: prix,
quantité)
supprimer_produit(self, id): Supprime un produit définitivement à partir de son ID
afficher_par_categorie(self, categorie) Filtre les produits appartenant à une catégorie
afficher_stock_faible(self): Affiche les produits dont la quantité est inférieure à un seuil, utile pour
détecter les ruptures.
valeur_totale_stock(self): Calcule la valeur globale du stock en multipliant le prix unitaire par la
quantité pour chaque produit.
Exercice 2 — Suivi des tâches dans un projet
Vous concevrez ici une application de suivi de tâches attribuées aux membres d’un projet. Le but est de gérer
les tâches et d’en tirer des statistiques.
Base de données : [Link]
Table : taches(id, nom, responsable, date_debut, date_fin, temps_estime)
Classe : Tache
Méthodes à développer :
ajouter_tache(self) Insère une tâche avec toutes ses données
taches_par_personne(self, nom): Affiche toutes les tâches assignées à une personne donnée.
afficher_taches_en_cours(self) Affiche les tâches en cours dont la date actuelle est comprise entre
date_debut et date_fin.
4
temps_total_par_personne(self, nom) : Calcule le temps total estimé pour toutes les tâches d’une
personne.
jours_restants(self, id): Calcule le nombre de jours restant avant la date_fin pour une tâche.
Exercice 3: Statistiques de ventes dans un restaurant
Vous développerez ici un outil pour enregistrer les ventes d’un restaurant et en extraire des statistiques utiles
(chiffre d’affaires, plat préféré...).
Base de données : [Link]
Table : ventes(id, plat, prix_unitaire, quantite, date_vente)
Classe : Vente
Méthodes à développer :
ajouter_vente(self) : Ajoute une nouvelle vente dans la base
recette_totale(self): Calcule la somme totale des ventes par produit de chaque ligne.
vente_par_jour(self, date): Affiche toutes les ventes effectuées à une date donnée
plat_le_plus_vendu(self); Identifie le plat ayant été vendu en plus grande quantité
chiffre_affaire_par_plat(self): Affiche le chiffre d’affaires total généré par plat via SUM et
GROUP BY.
Exercice 4 — Menu interactif de gestion des employés
Vous construirez une interface en ligne de commande permettant de gérer une base d’employés et d’effectuer
des opérations sur leurs données, y compris des calculs de salaire et ancienneté.
Base de données : [Link]
Table : employes(matricule, nom, poste, salaire, date_embauche)
Méthodes à développer :
ajouter_employe(self)
liste_employes(self)
augmenter_salaire(self, matricule, pourcentage): Augmente le salaire d’un employé selon un
pourcentage donné en calculant le nouveau salaire.
employes_par_poste(self, poste) Affiche tous les employés ayant un poste spécifique
anciennete_employe(self, matricule) Calcule le nombre de jours depuis l'embauche d’un employé
en comparant les dates.