Structuration de projets simples | Exercices corrigés

Concepts & Exercices

\(\text{Projet} = \text{Fichiers} + \text{Dossiers} + \text{Documentation}\)

Structure de projet

Arborescence

src → modules → tests

Organisation hiérarchique

Modularité

import module

Séparation des responsabilités

Documentation

README.md

Descriptif du projet

📁

Organisation : Dossiers séparés pour le code source, les tests, les ressources et la documentation.

🧩

Modularité : Division du code en modules réutilisables et indépendants.

📖

Documentation : Fichier README décrivant le projet, son installation et son utilisation.

Exercice 1

Créer l'arborescence d'un projet Python simple avec modules et tests

Exercice 2

Structurer un projet de jeu avec modules de logique, IHM et données

Exercice 3

Organiser un projet de gestion de bibliothèque avec modules distincts

Exercice 4

Structurer un projet de conversion de température avec documentation

Exercice 5

Créer un projet de calculatrice avec modules de calcul et d'interface

Corrigé : Exercices 1 à 3

1 Arborescence projet

Définition :

Arborescence : Organisation hiérarchique des fichiers et dossiers d'un projet informatique.

Méthode de structuration :

Créer un dossier racine pour le projet
Organiser les fichiers en dossiers fonctionnels (source, tests, docs, etc.)
Utiliser des noms clairs et cohérents pour les dossiers et fichiers
Inclure un fichier README pour expliquer le projet

mon_projet/

├── src/

│ ├── __init__.py

│ ├── main.py

│ └── utils.py

├── tests/

│ ├── __init__.py

│ ├── test_main.py

│ └── test_utils.py

├── docs/

│ └── README.md

├── requirements.txt

└── setup.py

Étape 1 : Analyser les besoins du projet

Identifier les différentes parties fonctionnelles du projet

Étape 2 : Créer la structure de base

Dossier racine avec dossiers pour le code source, les tests et la documentation

Étape 3 : Nommer les fichiers de manière cohérente

Utiliser des conventions de nommage claires et descriptives

Structure finale :

Arborescence claire séparant le code source, les tests unitaires et la documentation

Règles appliquées :

• Hiérarchie : Organiser les fichiers par fonctionnalité

• Clarté : Noms des dossiers et fichiers explicites

• Documentation : Fichier README présentant le projet

2 Module de jeu

Définition :

Modularité : Division d'un programme en modules indépendants et réutilisables.

jeu_devinette/

├── src/

│ ├── __init__.py

│ ├── jeu.py

│ ├── interface.py

│ └── donnees.py

├── tests/

│ ├── __init__.py

│ ├── test_jeu.py

│ └── test_donnees.py

├── README.md

└── main.py

Étape 1 : Identifier les responsabilités

Logique du jeu, interface utilisateur, gestion des données

Étape 2 : Créer les modules appropriés

Chaque module a une seule responsabilité bien définie

Étape 3 : Assurer l'indépendance des modules

Chaque module peut être modifié ou testé indépendamment

Structure finale :

Modules séparés pour la logique du jeu, l'interface et les données persistantes

Règles appliquées :

• Séparation des responsabilités : Chaque module a une fonction unique

• Indépendance : Les modules peuvent être modifiés sans affecter les autres

• Testabilité : Chaque module peut être testé individuellement

3 Projet bibliothèque

Définition :

Architecture en couches : Organisation du code selon des niveaux d'abstraction.

bibliotheque_app/

├── src/

│ ├── __init__.py

│ ├── modeles/

│ │ ├── __init__.py

│ │ ├── livre.py

│ │ └── utilisateur.py

│ ├── controleurs/

│ │ ├── __init__.py

│ │ ├── gestion_livres.py

│ │ └── gestion_utilisateurs.py

│ └── vues/

│ ├── __init__.py

│ ├── menu_principal.py

│ └── affichage_livres.py

├── tests/

│ ├── __init__.py

│ ├── test_modeles/

│ ├── test_controleurs/

│ └── test_vues/

├── README.md

└── main.py

Étape 1 : Identifier les couches du système

Modèles (données), contrôleurs (logique métier), vues (interface)

Étape 2 : Créer les dossiers correspondants

Organisation logique des modules par couche fonctionnelle

Étape 3 : Maintenir la cohérence

Chaque couche a ses propres responsabilités clairement définies

Structure finale :

Architecture en couches avec séparation claire des préoccupations

Règles appliquées :

• Architecture en couches : Séparation des préoccupations

• Cohérence : Organisation logique des modules

• Extensibilité : Ajout de fonctionnalités facilité par la structure

Corrigé : Exercices 4 à 5

4 Documentation

Définition :

Documentation : Ensemble des documents décrivant un projet logiciel.

convertisseur_temp/

├── src/

│ ├── __init__.py

│ ├── conversions.py

│ └── validation.py

├── docs/

│ ├── README.md

│ ├── INSTALL.md

│ └── API.md

├── requirements.txt

└── main.py

Étape 1 : Créer le fichier README principal

Description du projet, objectifs, technologies utilisées

Étape 2 : Documenter l'installation

Prérequis, étapes d'installation, configuration

Étape 3 : Documenter l'utilisation

Exemples d'utilisation, paramètres, résultats attendus

Documentation complète :

README, guide d'installation et documentation de l'API

Règles appliquées :

• Accessibilité : Documentation claire et accessible

• Complétude : Tous les aspects du projet sont documentés

• Maintenance : Documentation mise à jour avec le code

5 Calculatrice modulaire

Définition :

Modularité avancée : Architecture permettant l'extension du système.

calculatrice/

├── src/

│ ├── __init__.py

│ ├── operations/

│ │ ├── __init__.py

│ │ ├── arithmetique.py

│ │ └── trigonometrie.py

│ ├── interfaces/

│ │ ├── __init__.py

│ │ ├── console.py

│ │ └── graphique.py

│ └── outils/

│ ├── __init__.py

│ ├── historique.py

│ └── sauvegarde.py

├── tests/

│ ├── __init__.py

│ ├── test_operations/

│ ├── test_interfaces/

│ └── test_outils/

├── README.md

└── main.py

Étape 1 : Identifier les composants principaux

Opérations mathématiques, interfaces utilisateur, outils annexes

Étape 2 : Créer une architecture extensible

Modules organisés pour permettre l'ajout de nouvelles fonctionnalités

Étape 3 : Assurer la testabilité

Structure permettant des tests unitaires complets

Structure finale :

Architecture modulaire et extensible avec séparation claire des responsabilités

Règles appliquées :

• Extensibilité : Architecture permettant l'ajout de fonctionnalités

• Séparation des responsabilités : Chaque module a une fonction précise

• Testabilité : Structure favorable aux tests unitaires

Cours bien détaillé

\(\text{Projet} = \sum_{i=1}^{n} \text{Module}_i\)

Structure modulaire

🎯

Définition : La structuration de projets simples consiste à organiser les fichiers et dossiers d'un projet de manière logique et cohérente.

📏

Objectif : Faciliter la maintenance, la compréhension et l'extensibilité du code.

📐

Modularité : Division du code en modules réutilisables et indépendants.

📝

Documentation : Ensemble des documents décrivant le projet et son utilisation.

💡

Conseil : Utiliser une arborescence cohérente et des noms descriptifs pour les dossiers et fichiers

🔍

Attention : Éviter les dépendances circulaires entre modules

⚡

Astuce : Utiliser des fichiers __init__.py pour créer des packages Python

📋

Méthode : Suivre le principe SRP (Single Responsibility Principle)

✅

Vérification : Tester la structure avec des projets simples avant d'agrandir

Bonnes pratiques de structuration :

Séparation des responsabilités : Chaque module a une fonction unique
Hiérarchie logique : Organisation des dossiers par fonctionnalité
Nomage cohérent : Noms clairs et descriptifs pour les fichiers et dossiers
Documentation : Fichier README et documentation technique
Tests : Dossier dédié aux tests unitaires

Règles importantes :

Un projet bien structuré est plus facile à comprendre et maintenir
La modularité favorise la réutilisation du code
La documentation est essentielle pour la collaboration
Les tests doivent être organisés de manière similaire au code source
L'architecture en couches améliore la lisibilité du projet

Structuration de projets simplesExercices corrigés

Structuration de projets simples
Exercices corrigés