Qu'est-ce qu'une PEP en Python ?

Définition d'une PEP en Python

Une PEP (acronyme de Python Enhancement Proposal, ou « Proposition d'amélioration de Python ») est un document de conception officiel qui décrit une nouvelle fonctionnalité, un processus ou une convention pour le langage Python. Les PEP constituent le mécanisme principal par lequel la communauté Python propose, discute et adopte les évolutions du langage.

Chaque PEP est identifiée par un numéro unique (par exemple, PEP 8, PEP 20, PEP 484) et suit un cycle de vie bien défini : brouillon, acceptée, rejetée ou remplacée. Si vous souhaitez maîtriser Python en profondeur, comprendre les PEP est essentiel, et c'est d'ailleurs un sujet abordé dans notre formation complète sur Python.

L'origine et le rôle des PEP

Le système des PEP a été introduit en l'an 2000, inspiré par les RFC (Request for Comments) utilisées pour les standards Internet et les DEP (Design Enhancement Proposals) d'autres langages. La toute première PEP, la PEP 1, décrit justement le processus des PEP lui-même.

Les PEP remplissent plusieurs rôles fondamentaux :

• Proposer de nouvelles fonctionnalités : toute modification majeure du langage doit passer par une PEP avant d'être implémentée.
• Documenter les décisions de conception : les PEP expliquent le pourquoi derrière chaque choix technique.
• Établir des conventions : certaines PEP définissent des standards de style et de bonnes pratiques (comme la célèbre PEP 8).
• Informer la communauté : les PEP informatives décrivent des concepts ou des processus sans nécessairement proposer de changement.

Les trois types de PEP

Toutes les PEP ne sont pas identiques. Elles se classent en trois catégories distinctes :

Le cycle de vie d'une PEP

Une PEP suit un parcours précis depuis sa création jusqu'à son adoption (ou son rejet). Voici les étapes principales :

1. Brouillon (Draft) : l'auteur rédige la proposition et la soumet à la communauté.
2. Discussion : la PEP est débattue sur les listes de diffusion Python et les forums officiels.
3. Acceptée (Accepted) : si le consensus est atteint, la PEP est acceptée par le Conseil directeur de Python (Steering Council).
4. Finale (Final) : la fonctionnalité est implémentée et intégrée dans une version de Python.
5. Rejetée (Rejected) : si la proposition ne convainc pas, elle est rejetée.
6. Remplacée (Superseded) : une PEP plus récente peut remplacer une ancienne.

Les PEP les plus importantes à connaître

Parmi les centaines de PEP existantes, certaines sont absolument incontournables pour tout développeur Python. Nous allons les passer en revue.

PEP 8 — Guide de style pour le code Python

La PEP 8 est sans doute la PEP la plus connue et la plus citée. Elle définit les conventions de style pour écrire du code Python lisible et cohérent. Voici quelques règles emblématiques de la PEP 8 :

# ✅ Conforme à la PEP 8
def calculer_prix_total(prix_unitaire, quantite):
    """Calcule le prix total d'une commande."""
    prix_total = prix_unitaire * quantite
    return prix_total


# Deux lignes vides entre les fonctions de niveau module
def appliquer_reduction(prix, pourcentage=10):
    """Applique une réduction au prix donné."""
    reduction = prix * pourcentage / 100
    return prix - reduction


# ❌ Non conforme à la PEP 8
def calculerPrixTotal(PrixUnitaire,Quantite):
    prixTotal=PrixUnitaire*Quantite
    return prixTotal

Les principales règles de la PEP 8 incluent :

• L'indentation avec 4 espaces (pas de tabulations).
• Les lignes ne doivent pas dépasser 79 caractères.
• Les noms de variables et de fonctions utilisent le snake_case.
• Les noms de class utilisent le PascalCase.
• Deux lignes vides séparent les définitions de fonctions et de classes au niveau du module.
• Les imports sont placés en haut du fichier, regroupés par catégorie.

PEP 20 — Le Zen de Python

La PEP 20 contient les 19 aphorismes qui forment la philosophie de Python. Vous pouvez les afficher directement dans l'interpréteur Python :

import this

Voici quelques-uns des principes les plus importants :

# "Beautiful is better than ugly."
# Préférez un code élégant
nombres_pairs = [x for x in range(20) if x % 2 == 0]

# "Explicit is better than implicit."
# Soyez explicite dans vos intentions
def convertir_en_celsius(fahrenheit):
    return (fahrenheit - 32) * 5 / 9

# "Simple is better than complex."
# Privilégiez la simplicité
# Au lieu de :
resultat = (lambda x: x ** 2)(5)
# Préférez :
def carre(x):
    return x ** 2

resultat = carre(5)

# "Readability counts."
# La lisibilité est primordiale
# Utilisez des noms descriptifs et des docstrings

Le Zen de Python guide les décisions de conception du langage et constitue un excellent repère pour écrire du code Pythonique. Les commentaire et les docstring participent à cette philosophie de lisibilité.

PEP 257 — Conventions pour les docstrings

La PEP 257 complète la PEP 8 en détaillant les conventions pour rédiger des docstring. Elle distingue les docstrings d'une ligne et les docstrings multi-lignes :

# Docstring d'une ligne (PEP 257)
def doubler(n):
    """Retourne le double de n."""
    return n * 2


# Docstring multi-lignes (PEP 257)
def rechercher_utilisateur(nom, base_de_donnees):
    """Recherche un utilisateur par son nom dans la base de données.

    Args:
        nom: Le nom de l'utilisateur à rechercher.
        base_de_donnees: L'instance de la base de données.

    Returns:
        Un dictionnaire contenant les informations de l'utilisateur,
        ou None si l'utilisateur n'est pas trouvé.

    Raises:
        ConnectionError: Si la connexion à la base échoue.
    """
    pass

PEP 484 — Type Hints

La PEP 484 a introduit les annotations de type (type hints) dans Python 3.5, transformant profondément la façon dont nous écrivons du code Python :

from typing import Optional


def saluer(nom: str, enthousiaste: bool = False) -> str:
    """Génère un message de salutation."""
    if enthousiaste:
        return f"Bonjour {nom} !!!"
    return f"Bonjour {nom}"


def trouver_element(elements: list[str], cible: str) -> Optional[int]:
    """Retourne l'index de la cible ou None."""
    try:
        return elements.index(cible)
    except ValueError:
        return None


# Les type hints n'affectent pas l'exécution,
# mais aident les IDE et les outils d'analyse statique
resultat: str = saluer("Alice", enthousiaste=True)
print(resultat)  # Bonjour Alice !!!

Les annotations de type fonctionnent parfaitement avec les f-string, les list, les dict, les tuple et les sets.

PEP 572 — L'opérateur morse (:=)

La PEP 572, introduite dans Python 3.8, a ajouté l'opérateur d'affectation par expression, surnommé « opérateur morse » en raison de sa ressemblance avec un morse vu de côté := :

# Sans l'opérateur morse
nombres = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
filtres = []
for n in nombres:
    carre = n ** 2
    if carre > 50:
        filtres.append(carre)

print(filtres)  # [64, 81, 100]

# Avec l'opérateur morse (PEP 572)
filtres = [carre for n in nombres if (carre := n ** 2) > 50]
print(filtres)  # [64, 81, 100]

# Utile aussi pour éviter les appels de fonction redondants
import re

texte = "Mon email est contact@example.com"
if (match := re.search(r'[\w.]+@[\w.]+', texte)):
    print(f"Email trouvé : {match.group()}")

PEP 557 — Data Classes

La PEP 557 a introduit les dataclass dans Python 3.7, simplifiant considérablement la création de classes destinées principalement à stocker des données :

from dataclasses import dataclass


@dataclass
class Produit:
    nom: str
    prix: float
    quantite: int = 0

    @property
    def valeur_stock(self) -> float:
        return self.prix * self.quantite


# Pas besoin de définir __init__, __repr__, __eq__
produit = Produit("Clavier", 49.99, 25)
print(produit)  # Produit(nom='Clavier', prix=49.99, quantite=25)
print(produit.valeur_stock)  # 1249.75

Autres PEP notables

Au-delà des PEP présentées ci-dessus, voici d'autres PEP qui ont marqué l'histoire de Python :

Comment lire et trouver une PEP

Toutes les PEP sont accessibles publiquement sur le site officiel peps.python.org. Voici comment naviguer efficacement dans ce répertoire :

# Vous pouvez aussi accéder au Zen de Python (PEP 20)
# directement depuis votre interpréteur
import this

# Pour consulter la version de Python et les PEP associées
import sys
print(sys.version)
# Exemple : 3.12.0 (main, Oct  2 2023, ...)

# Chaque version de Python est elle-même associée à une PEP
# Python 3.12 → PEP 693
# Python 3.11 → PEP 664
# Python 3.10 → PEP 619

Bonnes pratiques liées aux PEP

Connaître les PEP ne suffit pas : il faut les appliquer dans votre travail quotidien. Voici les bonnes pratiques que nous vous recommandons :

• Respectez la PEP 8 : utilisez un linter comme flake8 ou un formateur comme black pour vérifier automatiquement la conformité de votre code.
• Utilisez les type hints (PEP 484) : même si Python est un langage dynamique, les annotations de type améliorent la lisibilité et permettent la détection d'erreurs avec mypy.
• Écrivez des docstrings (PEP 257) : documentez vos fonctions, classes et modules selon les conventions établies.
• Suivez le Zen de Python (PEP 20) : en cas de doute sur la meilleure façon d'écrire du code, référez-vous aux principes fondamentaux.
• Restez informé : lisez les PEP associées aux nouvelles versions de Python pour comprendre les évolutions du langage.

# Exemple de code respectant plusieurs PEP à la fois
from dataclasses import dataclass  # PEP 557


@dataclass  # PEP 557 - Data Classes
class Etudiant:
    """Représente un étudiant inscrit à une formation."""  # PEP 257

    nom: str          # PEP 484 - Type Hints
    age: int          # PEP 484
    moyenne: float    # PEP 484

    def est_admis(self) -> bool:  # PEP 484 + PEP 8 (snake_case)
        """Vérifie si l'étudiant est admis (moyenne >= 10)."""  # PEP 257
        return self.moyenne >= 10.0


# PEP 8 : deux lignes vides avant la définition de niveau module
def afficher_resultats(etudiants: list[Etudiant]) -> None:
    """Affiche les résultats de tous les étudiants."""
    for etudiant in etudiants:
        statut = "Admis" if etudiant.est_admis() else "Recalé"
        # PEP 498 - f-strings
        print(f"{etudiant.nom} ({etudiant.age} ans) : {statut}")


# Utilisation
etudiants = [
    Etudiant("Alice", 22, 15.5),
    Etudiant("Bob", 20, 8.0),
    Etudiant("Charlie", 21, 12.3),
]

afficher_resultats(etudiants)

Écrire sa propre PEP

Bien que ce soit un processus avancé, tout membre de la communauté Python peut proposer une PEP. Voici les étapes générales :

1. Discutez d'abord votre idée sur le forum discuss.python.org pour recueillir des retours.
2. Trouvez un sponsor : un core developer doit parrainer votre proposition.
3. Rédigez la PEP au format reStructuredText en suivant le modèle de la PEP 12.
4. Soumettez une pull request sur le dépôt GitHub python/peps.
5. Itérez en fonction des retours de la communauté et du Steering Council.

Questions fréquentes

Une PEP est un document de proposition et de conception : elle explique pourquoi et comment une fonctionnalité doit être ajoutée au langage. La documentation officielle, quant à elle, décrit comment utiliser les fonctionnalités déjà implémentées. En d'autres termes, la PEP précède la documentation : une fonctionnalité est d'abord proposée via une PEP, puis une fois acceptée et implémentée, elle est documentée dans la documentation officielle.

Non, il n'est absolument pas nécessaire de lire les centaines de PEP existantes. Concentrez-vous sur les plus importantes : la PEP 8 (guide de style), la PEP 20 (Zen de Python), la PEP 257 (docstrings) et la PEP 484 (type hints). Ensuite, vous pouvez consulter ponctuellement les PEP liées aux fonctionnalités que vous utilisez au quotidien.

La PEP 8 n'est pas techniquement obligatoire : Python n'empêche pas l'exécution de code non conforme. Cependant, elle est considérée comme un standard de facto dans la communauté Python. La plupart des projets open source, des entreprises et des équipes de développement exigent le respect de la PEP 8. Des outils comme black, flake8 et pylint permettent de vérifier et d'appliquer automatiquement ces conventions.

La meilleure façon d'apprendre Python et d'intégrer les bonnes pratiques issues des PEP est de suivre un parcours structuré. Nous vous recommandons notre formation dédiée à Python sur Believemy, qui vous guidera pas à pas dans la maîtrise du langage tout en appliquant les conventions et les meilleures pratiques issues des PEP les plus importantes.