Environnement de développement professionnel

Objectifs

À la fin de cette séance, vous serez capables de :

Configurer des environnements virtuels isolés avec venv
Gérer les dépendances avec Poetry
Écrire du code traçable avec le logging
Automatiser la qualité avec pre-commit
Comprendre les pratiques d’Intégration Continue

Introduction

En tant que futurs professionnels de l’informatique, vous allez travailler sur des projets complexes. Cette séance vous montre comment configurer un environnement professionnel avec Python. Les outils présentés sont obligatoires en entreprise. Les maîtriser dès maintenant vous donnera un avantage compétitif.

1. Les environnements virtuels avec venv

1.1 Pourquoi utiliser un environnement virtuel ?

Imaginez que vous travaillez sur deux projets différents :

Projet A : nécessite Python 3.10 et pandas 2.0
Projet B : nécessite Python 3.9 et pandas 1.5

Sans environnement virtuel, vous auriez :

Des conflits entre les versions des bibliothèques
Des erreurs difficiles à résoudre
Du code qui marche chez vous mais pas en production

Solution : Les environnements virtuels isolent complètement les dépendances. Vous rencontrerez cela en entreprise dès le premier projet.

1.2 Cas concret : Que se passe-t-il sans environnement virtuel ?

Vous installez pandas 2.0 pour le Projet A
Vous travaillez sur le Projet B qui nécessite pandas 1.5
Vous mettez à jour pandas → le Projet A casse

Avec un environnement virtuel, chaque projet est isolé. Les modifications ne s’affectent pas mutuellement.

1.3 Création d’un environnement virtuel

Créez un environnement dédié à chaque projet :

# Créer l'environnement
python -m venv venv

# Activer sur Linux/Mac
source venv/bin/activate

# Activer sur Windows
venv\Scripts\activate

# Installer des dépendances
pip install pandas==1.5.3

# Désactiver quand vous avez fini
deactivate

⚠️ Attention : Activez toujours l’environnement avant d’installer des packages. Sans activation, les packages s’installent globalement et polluent le système.

1.4 Résumé

L’environnement virtuel isole vos projets. Chaque projet a ses propres versions. C’est une bonne pratique obligatoire.

Exercice 1 : Création et utilisation d'un environnement virtuel

Créez un projet avec un environnement virtuel. Installez pandas 1.5.3 et vérifiez la version.

Indice : Utilisez python -m venv pour créer l’environnement, puis activez-le avant d’installer pandas. Script pandas :

import pandas as pd

print(f"Version pandas: {pd.__version__}")

data = {'x': [1, 2, 3], 'y': [10, 20, 30]}
df = pd.DataFrame(data)
print("\nProjet A:")
print(df)
print(f"Somme: {df['y'].sum()}")

Puis exécutez :

# Vérifier la version installée
python -c "import pandas; print(pandas.__version__)"

# Exécuter le script
python script.py

Exercice 2 : Démonstration de l'isolation avec deux projets

Créez deux projets distincts (projet_a et projet_b) avec leurs propres environnements virtuels. Installez pandas 2.0 dans projet_a et pandas 1.5.3 dans projet_b. Vérifiez que chaque projet utilise bien sa propre version sans conflit.

2. Gestion des dépendances avec Poetry

Poetry est un outil moderne qui combine :

Gestion des dépendances (comme pip)
Création d’environnements virtuels (comme venv)
Gestion des versions automatique
Génération de fichiers lock pour la reproductibilité

En entreprise, Poetry remplace avantageusement les fichiers requirements.txt. Vous l’utiliserez dans de vrais projets.

📚 Documentation officielle : Poetry - Python Dependency Management

3. Le logging : bien mieux que des print()

3.1 Pourquoi utiliser le logging plutôt que des print() ?

Les print() sont limités et ne conviennent pas aux projets professionnels. Le logging offre des fonctionnalités avancées indispensables :

Niveaux de gravité : Le logging fournit 5 niveaux (DEBUG, INFO, WARNING, ERROR, CRITICAL) permettant de filtrer les messages selon leur importance. Les print() affichent tout sans distinction.

Formatage avancé : Le logging permet d’ajouter automatiquement la date, l’heure, le niveau de gravité et le module d’origine. Les print() nécessitent un formatage manuel.

Désactivation facile : Le logging peut être désactivé ou filtré par niveau sans modifier le code. Les print() doivent être supprimés ou commentés un par un.

Utilisable en production : Le logging est conçu pour la production avec rotation de fichiers et gestion de la performance. Les print() ne doivent jamais rester dans le code de production.

Le logging est utilisé dans tous les projets professionnels. Les print() sont réservés au debugging local.

3.2 Configuration du logging

# Configuration complète du logging
import logging

# Configurer le logger
logging.basicConfig(
    level=logging.DEBUG,
    # Format détaillé avec timestamp et niveau
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
    # Écrire dans un fichier
    filename='app.log'
)

# Créer un logger pour ce module
logger = logging.getLogger(__name__)

# Utiliser le logger
logger.debug("Message de debug")
logger.info("Opération réussie")
logger.warning("Attention !")
logger.error("Erreur détectée")
logger.critical("Erreur critique")

3.3 Exemple complet avec gestion d’erreurs

import logging

# Configuration initiale
logging.basicConfig(
    level=logging.DEBUG,
    format='%(asctime)s - %(levelname)s - %(message)s',
    filename='traitement.log'
)

logger = logging.getLogger(__name__)

def traiter_donnees(donnees):
    # Log le début du traitement
    logger.debug(f"Début du traitement avec {len(donnees)} éléments")
    
    try:
        # Traitement complexe...
        resultat = sum(donnees) / len(donnees)
        # Log le succès
        logger.info(f"Traitement réussi. Moyenne: {resultat}")
        return resultat
    except ZeroDivisionError:
        # Log l'erreur avec la trace complète
        logger.error("Données vides, impossible de calculer", exc_info=True)
        return None
    except Exception as e:
        # Log toute erreur inattendue
        logger.error(f"Erreur inattendue: {e}", exc_info=True)
        raise

# Utiliser la fonction
resultat = traiter_donnees([1, 2, 3, 4, 5])

⚠️ Attention : Utilisez exc_info=True pour logger la trace complète en cas d’erreur. Cela aide pour le debugging en production.

3.4 Les niveaux de gravité

DEBUG : Informations détaillées pour le debugging
INFO : Confirmations que tout fonctionne
WARNING : Quelque chose d’inattendu (par défaut)
ERROR : Erreur sérieuse
CRITICAL : Erreur très grave

Exercice 3 : Implémentation du logging

Créez un module qui charge un fichier CSV. Loggez chaque étape (ouverture, succès, erreur).

Indice : Configurez le logging avant d’ouvrir le fichier. Loggez les étapes clés : début, succès, erreur.

📚 Fin du contenu vu en classe
Le contenu suivant est proposé pour l’apprentissage en autonomie.

4. pre-commit : Automatiser la qualité du code

4.1 Le principe de pre-commit

pre-commit est un gardien automatique qui vérifie votre code avant chaque commit :

Vous exécutez git commit
pre-commit lance des vérifications automatiques
Si tout est bon → commit accepté
Si problème → commit bloqué jusqu’à correction

Les vérifications typiques sont :

Formatage du code (Black)
Vérification PEP 8 (flake8)
Détection d’erreurs (mypy)
Suppression d’espaces inutiles
Vérification de la syntaxe

4.2 Installation et configuration

# Installer pre-commit
pip install pre-commit

# Créer un fichier .pre-commit-config.yaml à la racine du projet
# (voir exemple ci-dessous)

# Installer les hooks Git
pre-commit install

# Exécuter manuellement sur tous les fichiers (optionnel)
pre-commit run --all-files

4.3 Fichier de configuration .pre-commit-config.yaml

# .pre-commit-config.yaml
repos:
  # Hook Black pour le formatage automatique
  - repo: https://github.com/psf/black
    rev: 23.12.1
    hooks:
      - id: black
        language_version: python3

  # Hook flake8 pour la vérification PEP 8
  - repo: https://github.com/PyCQA/flake8
    rev: 6.1.0
    hooks:
      - id: flake8
        # Limite les lignes à 88 caractères (standard Black)
        args: [--max-line-length=88]

  # Hooks généraux
  - repo: https://github.com/pre-commit/pre-commit-hooks
    rev: v4.4.0
    hooks:
      # Supprime les espaces en fin de ligne
      - id: trailing-whitespace
      # Ajoute une ligne vide à la fin des fichiers
      - id: end-of-file-fixer
      # Vérifie la syntaxe YAML
      - id: check-yaml
      # Empêche l'ajout de très gros fichiers
      - id: check-added-large-files
        args: ['--maxkb=1000']

4.4 Comment fonctionne pre-commit en pratique ?

# Étape 1 : Vous modifiez du code
# Vous avez des erreurs de formatage et d'indentation

# Étape 2 : Vous essayez de commiter
git add .
git commit -m "Ajout d'une nouvelle fonction"

# Étape 3 : pre-commit détecte les problèmes
# Black reformate votre code automatiquement
# flake8 signale les erreurs de style
# Le commit est bloqué

# Étape 4 : Vous corrigez les erreurs
# Pour Black : les modifications sont auto-appliquées
# Pour flake8 : vous devez corriger manuellement
git add .  # Ajouter les fichiers corrigés
git commit -m "Ajout d'une nouvelle fonction"  # Réessayer

# Étape 5 : Commit accepté !

⚠️ Attention : Ne pas faire git commit --no-verify pour contourner pre-commit. Cela annule toute la qualité du code.

Exercice 4 : Configuration de pre-commit

Installez pre-commit. Créez .pre-commit-config.yaml. Créez un fichier Python mal formaté et observez pre-commit corriger.

Indice : Installez pre-commit avec pip. Créez le fichier de configuration à la racine du projet. Puis faites pre-commit install.

5. Introduction à l’Intégration continue

5.1 Qu’est-ce que la CI (Intégration Continue) ?

La CI est un ensemble de pratiques automatisées :

À chaque push, un serveur teste votre code
Les vérifications sont identiques à pre-commit
Elles s’exécutent en parallèle
En cas d’erreur, vous êtes notifié immédiatement
Vous ne pouvez pas fusionner du code cassé

5.2 Outils courants

GitHub Actions : Gratuit pour les projets publics
GitLab CI : Intégré nativement à GitLab
Jenkins : Serveur d’intégration continue self-hosted
Azure Pipelines : Solution Microsoft

5.3 Avantages

Détection précoce des bugs
Tests automatisés sur chaque modification
Documentation du processus de build
Confiance dans le déploiement

5.4 Exemple simple avec GitHub Actions

# .github/workflows/tests.yml
name: Tests

# S'exécute à chaque push
on: [push]

jobs:
  test:
    # Utiliser une machine Ubuntu
    runs-on: ubuntu-latest

    steps:
      # Télécharger le code
      - uses: actions/checkout@v4

      # Configurer Python
      - uses: actions/setup-python@v5
        with:
          python-version: '3.11'

      # Installer les dépendances
      - run: pip install -r requirements.txt

      # Exécuter les tests
      - run: pytest

      # Exécuter flake8
      - run: flake8 .