Python

Tip

Écosystème Recommandé - Gestionnaire de projet & packages : uv (remplace pip, poetry, pyenv, pipx en 10-100x plus rapide). - Linter & Formatter : Ruff (remplace black, flake8, isort, pydocstyle en un seul binaire ultra-rapide). - Débogage : Fonction intégrée breakpoint() (pdb) ou debugpy pour le debug via IDE / conteneurs.

1. Écosystème & Outillage

1.1. `uv` Gestionnaire de Packages

Développé en Rust par Astral, uv est devenu le standard pour gérer les versions de Python, les dépendances et les environnements virtuels à une vitesse fulgurante.

Installation

# Via le script officiel (recommandé sous Linux/macOS)
curl -LsSf https://astral.sh/uv/install.sh | sh

# Ou sous Arch Linux
sudo pacman -S uv

# Ou Debian 
sudo apt install uv

Gestion des versions de Python

uv peut télécharger, installer et gérer automatiquement les versions de Python de manière isolée sans toucher aux paquets de la distribution système :

# Télécharger et installer une ou plusieurs versions de Python
uv python install 3.12 3.13

# Lister les versions installées et disponibles
uv python list

# Verrouiller la version de Python pour le répertoire courant (.python-version)
uv python pin 3.12

Gestion de Projets (PEP 621)

uv gère le cycle de vie complet d'un projet basé sur pyproject.toml et un fichier de verrouillage déterministe uv.lock :

# 1. Initialiser un nouveau projet
uv init mon-projet
cd mon-projet

# 2. Ajouter des dépendances (met à jour pyproject.toml et uv.lock)
uv add requests fastapi uvicorn

# 3. Ajouter des dépendances de développement / test
uv add --dev pytest ruff mypy

# 4. Supprimer une dépendance
uv remove requests

# 5. Synchroniser l'environnement virtuel (.venv) avec le lockfile
uv sync

# 6. Exécuter un script dans l'environnement virtuel (SANS avoir à activer le .venv !)
uv run script.py
uv run pytest

Exécution d'Outils CLI Éphémères (`uvx` - Remplaçant de `pipx`)

uvx permet de lancer n'importe quel outil Python en ligne de commande dans un environnement temporaire et isolé sans l'installer globalement :

# Exécuter ruff directement
uvx ruff check .
uvx ruff format .

# Lancer un serveur HTTP éphémère ou un client CLI
uvx httpie https://api.ipify.org?format=json

# Pour installer un outil de manière permanente dans ~/.local/bin :
uv tool install ruff

Utilisation Classique (Remplaçant direct de `pip` et `virtualenv`)

Pour des projets simples ou des scripts legacy :

# Créer un environnement virtuel .venv en quelques millisecondes
uv venv

# Installer des dépendances depuis un fichier requirements.txt
uv pip install -r requirements.txt

# Générer un lockfile compatible requirements.txt
uv pip compile pyproject.toml -o requirements.txt

1.2. `Ruff` : Linter & Formateur Ultra-Rapide

Également conçu par Astral en Rust, Ruff regroupe les fonctionnalités de Black, Flake8, isort, pyupgrade, bandit et bien d'autres en étant 10 à 100 fois plus rapide.

Commandes Essentielles

# 1. Analyse statique (Linter)
ruff check .

# 2. Correction automatique des erreurs simples (imports inutilisés, syntaxe...)
ruff check --fix .

# 3. Formatage du code (remplace intégralement Black et isort)
ruff format .

# 4. Mode surveillance (ré-analyse à chaque sauvegarde de fichier)
ruff check --watch .

Configuration dans `pyproject.toml`

Exemple de configuration standard et propre dans le fichier pyproject.toml du projet :

[tool.ruff]
# Longueur maximale des lignes (88 est le standard Black)
line-length = 88
target-version = "py312"

[tool.ruff.lint]
# Sélection des règles :
# E/W : Erreurs et avertissements de style (pycodestyle)
# F   : Erreurs logiques et variables non définies (Pyflakes)
# I   : Tri automatique des imports (isort)
# B   : Pièges courants et bugs potentiels (flake8-bugbear)
# UP  : Modernisation de la syntaxe vers Python récent (pyupgrade)
select = ["E", "F", "W", "I", "B", "UP"]

# Règles à ignorer si besoin
ignore = ["E501"] # Ignorer la longueur max de ligne si gérée par le formatter

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

2. Débogage en Python (Debugger)

2.1. Débogage Natif : `breakpoint()` et `pdb`

Depuis Python 3.7, la fonction intégrée breakpoint() est la manière standard et universelle de suspendre l'exécution et d'entrer dans le débogueur interactif (pdb).

Exemple d'utilisation

def calculer_total(prix_unitaire: float, quantite: int, remise: float) -> float:
    sous_total = prix_unitaire * quantite

    # Point d'arrêt interactif : le programme s'arrête ici
    breakpoint()

    total = sous_total - (sous_total * remise)
    return total

calculer_total(25.0, 4, 0.10)

Lors de l'exécution (python mon_script.py ou uv run mon_script.py), le terminal bascule sur l'invite (Pdb) :

> /chemin/vers/script.py(6)calculer_total()
-> total = sous_total - (sous_total * remise)
(Pdb)

Commandes Indispensables de `pdb`

Commande	Raccourci	Rôle / Action
`next`	`n`	Exécute la ligne courante et s'arrête à la suivante (sans entrer dans les sous-fonctions).
`step`	`s`	Entre dans la fonction appelée sur la ligne courante (Step into).
`continue`	`c`	Reprend l'exécution normale jusqu'au prochain `breakpoint()` ou la fin du programme.
`print(var)`	`p var`	Évalue et affiche la valeur de la variable ou expression spécifiée.
`pp var`	`pp var`	Affiche joliment (Pretty-Print) des structures complexes (dictionnaires, listes imbriquées).
`list`	`l`	Affiche les 11 lignes de code source autour de la ligne actuelle.
`where`	`w`	Affiche la pile d'appels complète (stack trace) pour comprendre comment on est arrivé ici.
`quit`	`q`	Interrompt immédiatement le débogueur et arrête le script.
`help`	`h`	Affiche la liste des commandes ou l'aide d'une commande spécifique (`h next`).

Tip

Désactiver les breakpoints sans modifier le code :
Pour exécuter un script en ignorant tous les breakpoint() (par exemple en test ou production) :

PYTHONBREAKPOINT=0 uv run mon_script.py

2.2. Débogage dans l'IDE & Débogage à Distance (`debugpy`)

Configuration IDE (VS Code / Antigravity)

Dans .vscode/launch.json :

{
    "version": "0.2.0",
    "configurations": [
        {
            "name": "Python: Fichier Courant",
            "type": "debugpy",
            "request": "launch",
            "program": "${file}",
            "console": "integratedTerminal"
        },
        {
            "name": "Python: Attacher au Conteneur/Distant (Port 5678)",
            "type": "debugpy",
            "request": "attach",
            "connect": {
                "host": "localhost",
                "port": 5678
            },
            "pathMappings": [
                {
                    "localRoot": "${workspaceFolder}",
                    "remoteRoot": "/app"
                }
            ]
        }
    ]
}

Débogage d'une Application Distante ou en Conteneur Docker

debugpy permet de lancer un script et d'attendre qu'un IDE s'y connecte pour déboguer avec points d'arrêt visuels :

# Dans le conteneur ou serveur distant :
uv run python -m debugpy --listen 0.0.0.0:5678 --wait-for-client mon_script.py

3. Extensions IDE & Typage

3.1. Pyrefly

Configuration via le fichier pyrefly.toml :

python-platform = "linux"
reportMissingImports = "none"

Source : Documentation Pyrefly

4. Fondamentaux du Langage Python

4.1. Variables et Gestion Mémoire

En Python, une variable est créée dès qu'on lui assigne une valeur. Le typage est dynamique :

x = 5       # x est un entier
y = "Hello" # y est une chaîne de caractères

Les variables peuvent changer de type dynamiquement si on leur réassigne une nouvelle valeur :

x = 4       # x est un entier
x = "Sally" # x est maintenant une chaîne de caractères

Python gère la mémoire automatiquement via un Garbage Collector. Lorsqu'une variable n'est plus référencée (par exemple, si on utilise del ou si elle sort du scope d'une fonction), Python "oublie" cette variable et libère l'espace mémoire associé.

a = [1, 2, 3]
del a  # Supprime la variable 'a', la liste devient éligible au garbage collection

Autre exemple avec le caractère +

followers_nb = 55 + 10
print("Followers:", followers_nb) # Affiche : Followers: 65

La sortie de la console sera :

Opérateurs logiques : and, or, not :

is_active = True
has_permission = False

# Combinaison logique
can_access = is_active and (has_permission or not False)
print("Accès autorisé :", can_access)  # True

4.2. Types de Données Principaux

Vous pouvez inspecter le type d'une variable avec type() :

str (String) : Chaînes de caractères ("Hello")
int (Integer) : Nombres entiers (10)
float (Floating point) : Nombres à virgule (3.14)
bool (Boolean) : Valeurs vraies (True) ou fausses (False)

nom = "Antoine"
age = 25
taille = 1.75
est_actif = True

print(type(nom))        # <class 'str'>
print(type(age))        # <class 'int'>
print(type(taille))     # <class 'float'>
print(type(est_actif))  # <class 'bool'>

4.3. F-Strings (Formatted Strings)

Permettent d'insérer proprement des variables ou expressions dans des chaînes :

name = "Antoine"
print("Utilisateur :", name)
print(f"Nice to meet you, {name}!")

taux = 0.196
prix_ht = 100
print(f"Prix TTC : {prix_ht * (1 + taux):.2f} €")

4.4. Opérateurs de Comparaison et Assignation

== : Égal à (valeur)
!= : Différent de
> / < : Strictement supérieur / inférieur
>= / <= : Supérieur ou égal / Inférieur ou égal
is : Identité mémoire (ex: if var is None:)

nombre = 10
print(nombre == 10)  # True
print(nombre != 5)   # True

Assignation augmentée :

score = 10
score += 5   # équivalent à score = score + 5 (15)

vies = 3
vies -= 1    # équivalent à vies = vies - 1 (2)

4.5. Entrées Utilisateur (`input`)

La fonction input() retourne toujours une chaîne de caractères (str). Un transtypage (cast) est nécessaire pour manipuler des chiffres :

# Saisie d'un texte (str par défaut)
nom = input("Entrez votre nom : ")

# Saisie d'un entier (int) pour changer 
age = int(input("Entrez votre âge : "))

4.6. Structures Conditionnelles (`if`, `elif`, `else`)

note = 15

if note >= 16:
    print("Très bien")
elif note >= 12:
    print("Bien")
elif note >= 10:
    print("Passable")
else:
    print("Insuffisant")

4.7. Boucles (`while` et `for`)

Boucle `while`

compteur = 0

while compteur < 5:
    print(f"Compteur : {compteur}")
    compteur += 1

Contrôle de boucle avec break (interruption) et continue (saut d'itération) :

while True:
    reponse = input("Tapez 'quitter' pour sortir : ")
    if reponse == "quitter":
        break
    print(f"Reçu : {reponse}")

Boucle `for` et `range()`

# Parcourt de 0 à 4 (5 exclu)
for i in range(5):
    print(i)

# Parcourt d'une liste
serveurs = ["medusa", "chimera", "backup"]
for srv in serveurs:
    print(f"Hôte : {srv}")