Ruff : arrête de formater ton Python à la main, il s'en charge en 50 ms

Tu passes plus de temps à compter les espaces qu'à écrire ton code ? Un import mal trié, une ligne qui déborde, une variable jamais utilisée : autant de détails que ton cerveau ne devrait jamais gérer. Ruff s'en charge. C'est un linter et un formateur Python écrit en Rust, donc absurdement rapide : là où flake8 met dix secondes, Ruff répond en cinquante millisecondes. Un seul binaire, deux commandes, et ton code ressort propre, trié et corrigé. Voici comment t'en servir en dix minutes.

Pourquoi Ruff (et pas trois outils différents)

Historiquement, il fallait empiler flake8 pour les erreurs, Black pour le formatage et isort pour trier les imports. Trois outils, trois configs, trois vitesses différentes. Ruff réunit tout ça dans un seul exécutable. Résultat : moins de dépendances, zéro conflit de réglages, et une vitesse dix à cent fois supérieure. C'est aujourd'hui le standard de facto pour la qualité de code en Python.

Étape 1 : installer Ruff

Ruff s'installe comme n'importe quel outil. Deux options : pip pour rester dans ton environnement virtuel, ou uv pour une installation globale instantanée. Ruff n'a aucune dépendance, il n'embarque ni Python ni bibliothèque derrière lui.

bash

pip install ruff

# ou, plus rapide et sans venv :
uv tool install ruff

Vérifie que tout est en place : la commande suivante doit afficher un numéro de version.

bash

ruff --version

Étape 2 : un premier scan, sans rien casser

Crée un fichier test.py volontairement sale, avec un import inutilisé et une variable morte, puis lance le scan :

python

import os
import json

ma_variable_inutile = 42


def addition(a, b):
    return a + b

bash

ruff check test.py

Ruff liste chaque problème avec son code : F401 pour un import inutilisé, F841 pour une variable morte. Il te donne le fichier, la ligne et un message directement actionnable. Pas de fausse alerte, pas de jargon : chaque ligne pointe un vrai problème.

Étape 3 : laisser Ruff corriger tout seul

Le vrai atout de Ruff, c'est qu'il ne se contente pas de râler : il répare. Ajoute --fix et il supprime les imports morts, trie les imports et corrige une bonne partie des soucis sans jamais toucher au sens de ton code :

bash

ruff check --fix test.py

Ce qui reste après le --fix mérite vraiment ton attention : une logique ambiguë, une erreur potentielle. Ruff ne réécrit que ce qui est sans danger. La sémantique de ton programme reste intacte, garantie.

Étape 4 : formater tout le projet d'un coup

En plus du lint, Ruff embarque un formateur qui remplace Black. Il reformate ton code selon un style unique — indentations, espaces, sauts de ligne — sans en changer le comportement :

bash

ruff format .

Les deux commandes se complètent : ruff check corrige la logique suspecte, ruff format gère l'apparence. Lance-les dans cet ordre — d'abord check --fix, puis format — et tu obtiens un code lisible partout, du premier au dernier fichier.

Étape 5 : configurer une bonne fois pour toutes

Tu n'as pas à répéter les options à chaque fois. Déclare tes réglages une seule fois dans pyproject.toml et Ruff s'en souviendra, pour toi et pour toute ton équipe :

toml

[tool.ruff]
line-length = 100
target-version = "py311"

[tool.ruff.lint]
select = ["E", "F", "I", "N", "W", "UP"]
ignore = ["E501"]

[tool.ruff.format]
quote-style = "double"

Le champ select choisit les familles de règles actives : E et W pour le style (PEP 8), F pour les bugs flagrants, I pour le tri des imports, UP pour les syntaxes modernes de Python. target-version évite que Ruff te suggère une syntaxe que ta version ne supporte pas encore.

Étape 6 : Ruff tourne sans que tu y penses

Le gain décisif arrive quand Ruff tourne tout seul. Côté éditeur, installe l'extension officielle « Ruff » dans VS Code et active la correction à la sauvegarde. Côté Git, un hook pre-commit bloque tout code sale avant qu'il n'atteigne le dépôt :

yaml

repos:
  - repo: https://github.com/astral-sh/ruff-pre-commit
    rev: v0.16.7
    hooks:
      - id: ruff
        args: [--fix]
      - id: ruff-format

À partir de là, plus besoin d'y penser : chaque commit est vérifié, chaque sauvegarde est nettoyée. Le style devient une affaire d'outil, pas de discipline personnelle. Ton équipe n'a même plus à en discuter.

Le résultat

En dix minutes, tu as remplacé trois outils par un seul et gagné un facteur dix à cent en vitesse. Ruff ne rend pas ton code intelligent : il le rend propre, donc lisible, donc facile à faire évoluer. Et un code lisible, c'est un code que les humains — pas seulement les machines — comprennent encore dans six mois. C'est exactement ça, le but.