Installation, environnements et outils

Installation, environnements et outils#

Hide code cell source

 
import matplotlib.pyplot as plt
import matplotlib.patches as patches
import numpy as np
import seaborn as sns

sns.set_theme(style="whitegrid", palette="muted", font_scale=1.1)

Pourquoi Python ?#

Python est aujourd’hui l’un des langages de programmation les plus utilisés au monde, et ce pour de bonnes raisons. Sa syntaxe claire, sa lisibilité remarquable et l’étendue de son écosystème en font un choix de prédilection aussi bien pour les débutants que pour les ingénieurs expérimentés.

L’histoire de Python commence en 1991, lorsque Guido van Rossum, alors chercheur au Centrum Wiskunde & Informatica (CWI) aux Pays-Bas, publie la version 0.9 de son nouveau langage. Guido travaillait auparavant sur ABC, un langage pédagogique conçu pour être facile à apprendre, mais frustré par ses limitations, il décide de créer quelque chose de nouveau. Il baptise son langage Python en hommage à la troupe comique britannique Monty Python’s Flying Circus, dont il était admirateur — un choix qui donne d’emblée au projet une touche d’humour et de légèreté.

La philosophie de Python est résumée dans un document poétique connu sous le nom de Zen de Python, rédigé par Tim Peters. On peut l’afficher à tout moment depuis l’interpréteur Python :

import this

The Zen of Python, by Tim Peters

Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren't special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one-- and preferably only one --obvious way to do it.
Although that way may not be obvious at first unless you're Dutch.
Now is better than never.
Although never is often better than *right* now.
If the implementation is hard to explain, it's a bad idea.
If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea -- let's do more of those!

Ces vingt aphorismes constituent une véritable charte de conception. Parmi les plus importants : Beautiful is better than ugly (le code doit être élégant), Explicit is better than implicit (la clarté prime sur la magie), Simple is better than complex (la simplicité est une vertu), et There should be one obvious way to do it (Python décourage la prolifération de styles différents pour accomplir la même chose). Cette philosophie se traduit concrètement dans la conception du langage : Python impose l’indentation comme structure syntaxique, favorise les noms explicites et rend le code lisible presque comme de la prose.

Cas d’usage et domaines d’application#

La polyvalence de Python est l’une de ses forces majeures. Il est utilisé dans des domaines extrêmement variés :

  • Scripts et automatisation : Python remplace avantageusement les scripts shell pour automatiser des tâches répétitives — renommage de fichiers, traitement de données, envoi d’emails, interaction avec des API.

  • Développement web : des frameworks comme Django et FastAPI permettent de construire des applications web robustes et performantes. Django suit le paradigme MVC et inclut un ORM puissant ; FastAPI est orienté vers les API asynchrones et tire parti des annotations de types.

  • Science des données et analyse : l’écosystème NumPy, Pandas, Matplotlib et Seaborn a rendu Python incontournable pour l’analyse et la visualisation de données.

  • Intelligence artificielle et apprentissage automatique : TensorFlow, PyTorch, scikit-learn et Hugging Face Transformers ont fait de Python la langue franche de l’IA. Pratiquement toutes les recherches en deep learning sont publiées avec du code Python.

  • Calcul scientifique : SciPy, SymPy, Astropy et bien d’autres bibliothèques servent de fondation aux sciences physiques, biologiques et computationnelles.

  • Systèmes embarqués et IoT : MicroPython et CircuitPython apportent Python sur les microcontrôleurs, ouvrant la voie à une programmation de bas niveau accessible.

Cette omniprésence s’explique aussi par la richesse de la bibliothèque standard (standard library), qui couvre nativement des besoins aussi divers que la manipulation de fichiers, la compression, les protocoles réseau, la cryptographie, la gestion des dates, le multithreading et bien plus encore.

Installer Python#

Python 2 vs Python 3#

Il est important de comprendre que Python 2 et Python 3 sont deux langages distincts et incompatibles. Python 2 a été officiellement abandonné le 1er janvier 2020 : il ne reçoit plus aucune mise à jour de sécurité. Toute nouvelle installation doit impérativement utiliser Python 3. Dans ce livre, nous utilisons exclusivement Python 3 (version 3.10 ou supérieure).

Les différences majeures entre Python 2 et Python 3 incluent : la division entière (3/2 vaut 1.5 en Python 3 mais 1 en Python 2), les chaînes Unicode par défaut en Python 3, la syntaxe de print (fonction en Python 3, instruction en Python 2) et de nombreuses améliorations de la bibliothèque standard.

Gérer les versions avec pyenv#

La gestion de plusieurs versions de Python sur un même système peut vite devenir complexe. L’outil pyenv résout élégamment ce problème en permettant d’installer et de basculer entre différentes versions de Python sans toucher au Python système.

Installation de pyenv sur Linux/macOS :

curl https://pyenv.run | bash

Après l’installation, on ajoute les lignes suivantes à ~/.bashrc ou ~/.zshrc :

export PYENV_ROOT="$HOME/.pyenv"
export PATH="$PYENV_ROOT/bin:$PATH"
eval "$(pyenv init -)"

Les commandes essentielles de pyenv :

# Lister les versions disponibles
pyenv install --list

# Installer une version spécifique
pyenv install 3.12.3

# Définir la version globale
pyenv global 3.12.3

# Définir une version locale (dans le dossier courant)
pyenv local 3.11.8

# Vérifier la version active
python --version

La commande pyenv local crée un fichier .python-version dans le répertoire courant, ce qui garantit que tous les collaborateurs d’un projet utilisent exactement la même version de Python.

uv — le gestionnaire moderne#

Présentation#

uv est un outil de gestion de paquets et d’environnements Python écrit en Rust, développé par la société Astral (à l’origine de ruff, le linter ultra-rapide). Il a été conçu pour remplacer pip, pip-tools, virtualenv, venv et même une partie des fonctionnalités de poetry, en offrant une interface unifiée et des performances bien supérieures. Sur des projets comportant des centaines de dépendances, uv peut être dix à cent fois plus rapide que pip.

Installation de uv :

curl -LsSf https://astral.sh/uv/install.sh | sh

Créer un projet et un environnement virtuel#

Un environnement virtuel est un dossier isolé contenant une installation Python et ses paquets, indépendante du reste du système. Cela permet d’avoir des dépendances différentes par projet sans conflits.

# Créer un nouveau projet (génère pyproject.toml + .venv)
uv init mon_projet
cd mon_projet

# Ou créer simplement un environnement virtuel dans le dossier courant
uv venv

# Activer l'environnement (Linux/macOS)
source .venv/bin/activate

# Activer l'environnement (Windows)
.venv\Scripts\activate

Installer des paquets#

# Ajouter une dépendance au projet (màj pyproject.toml + uv.lock)
uv add numpy pandas matplotlib

# Installer un paquet sans l'ajouter aux dépendances du projet
uv pip install requests

# Installer les dépendances listées dans pyproject.toml
uv sync

# Afficher les paquets installés
uv pip list

Exécuter du code avec uv run#

La commande uv run exécute un script dans l’environnement du projet, sans avoir besoin d’activer manuellement l’environnement virtuel :

# Exécuter un script Python
uv run hello.py

# Exécuter une commande dans l'environnement
uv run python -c "import numpy; print(numpy.__version__)"

# Lancer Jupyter
uv run jupyter lab

Avantages sur pip et venv#

Par rapport à la combinaison traditionnelle pip + venv, uv offre plusieurs avantages décisifs :

  • Vitesse : la résolution des dépendances et leur téléchargement sont nettement plus rapides.

  • Reproductibilité : le fichier uv.lock fixe exactement les versions de toutes les dépendances, directes et transitives.

  • Interface unifiée : une seule commande gère la création d’environnements, l’installation de paquets et l’exécution de scripts.

  • Compatibilité : uv est compatible avec pyproject.toml et les standards modernes de l’écosystème Python.

Le REPL Python#

Le REPL (Read-Eval-Print Loop) est l’interpréteur interactif de Python. On le lance simplement en tapant python (ou python3) dans un terminal. Il lit chaque expression saisie, l’évalue et en affiche le résultat immédiatement — un outil précieux pour explorer le langage et tester des idées rapidement.

# Calcul immédiat
2 ** 10

1024

# La variable _ contient le dernier résultat calculé
_ * 2

2048

Fonctions d’introspection#

Le REPL fournit plusieurs outils d’exploration particulièrement utiles :

# help() affiche la documentation d'un objet
help(len)

Help on built-in function len in module builtins:

len(obj, /)
    Return the number of items in a container.

# dir() liste les attributs et méthodes d'un objet
print(dir([]))

['__add__', '__class__', '__class_getitem__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getstate__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']

# type() retourne le type d'un objet
print(type(42))
print(type(3.14))
print(type("bonjour"))
print(type([1, 2, 3]))

<class 'int'>
<class 'float'>
<class 'str'>
<class 'list'>

Remarque 1

La variable spéciale _ dans le REPL contient toujours le résultat de la dernière expression évaluée. C’est une commodité pratique pour enchaîner des calculs sans avoir à stocker les résultats intermédiaires dans des variables. Cette convention ne fonctionne que dans le REPL interactif, pas dans un script ordinaire.

Pour une expérience interactive plus riche, on peut installer IPython (uv add ipython), qui offre la coloration syntaxique, la complétion avancée, la magie (%timeit, %matplotlib), et une gestion bien meilleure de l’historique.

Éditeurs et IDE#

Le choix de l’éditeur est une question de préférence personnelle, mais certains outils sont particulièrement bien adaptés à Python.

Visual Studio Code#

VS Code est un éditeur polyvalent, léger et extensible, qui est devenu l’un des environnements de développement Python les plus populaires. Pour configurer VS Code pour Python :

  1. Installer VS Code depuis code.visualstudio.com.

  2. Installer l’extension Python (publiée par Microsoft) depuis le marché d’extensions.

  3. Installer l’extension Pylance pour bénéficier d’une analyse statique avancée, de la complétion intelligente basée sur les annotations de types, et de l’inférence de types.

La configuration recommandée dans .vscode/settings.json :

{
  "python.defaultInterpreterPath": ".venv/bin/python",
  "editor.formatOnSave": true,
  "[python]": {
    "editor.defaultFormatter": "charliermarsh.ruff"
  },
  "python.analysis.typeCheckingMode": "basic"
}

PyCharm#

PyCharm (de JetBrains) est un IDE dédié à Python, plus lourd que VS Code mais offrant une intégration très poussée : débogueur visuel, profiler intégré, support natif des frameworks web, gestion des environnements virtuels et des bases de données. La version Community est gratuite et couvre l’essentiel.

Jupyter Lab#

Jupyter Lab est l’environnement de prédilection pour l’exploration de données et le calcul scientifique. Il combine du code exécutable, du texte au format Markdown, des équations LaTeX et des visualisations dans des notebooks interactifs. C’est le format utilisé dans ce livre.

Premier script Python#

Créons notre premier fichier Python. Par convention, les fichiers Python ont l’extension .py.

# Contenu du fichier hello.py
print("Bonjour, monde !")
print("Python version :", __import__('sys').version)

Bonjour, monde !
Python version : 3.13.5 (main, Jun 25 2025, 18:55:22) [GCC 14.2.0]

Dans un terminal, ce script s’exécute de deux façons :

# Méthode classique
python hello.py

# Avec uv (sans activer l'environnement)
uv run hello.py

Exemple 1 (Structure d’un script Python typique)

Un script Python bien structuré respecte quelques conventions :

#!/usr/bin/env python3
"""
Module de démonstration.

Ce module illustre la structure standard d'un script Python.
"""

# Imports de la bibliothèque standard d'abord
import sys
import os

# Puis imports tiers
import numpy as np

# Puis imports locaux
# from mon_module import ma_fonction


def main() -> None:
    """Point d'entrée principal du script."""
    print("Bonjour depuis main() !")
    print(f"Version Python : {sys.version}")


if __name__ == "__main__":
    main()

Le bloc if __name__ == "__main__": est fondamental : il garantit que main() n’est appelée que lorsque le fichier est exécuté directement, et non lorsqu’il est importé comme module par un autre fichier.


```{prf:definition} Module et script
:label: definition-01-01
En Python, tout fichier `.py` est à la fois un **script** (exécutable directement) et un **module** (importable par d'autres fichiers). La variable `__name__` vaut `"__main__"` quand le fichier est exécuté directement, et le nom du fichier (sans l'extension) quand il est importé. Cette dualité est au cœur du système de modules Python.

Visualisation de l’écosystème Python#

Hide code cell source

 
fig, ax = plt.subplots(figsize=(12, 8))
ax.set_xlim(0, 10)
ax.set_ylim(0, 10)
ax.axis('off')
ax.set_title("L'écosystème Python : des couches successives", fontsize=15,
             fontweight='bold', pad=20)

palette = sns.color_palette("muted", 4)

couches = [
    (0.3, 0.3, 9.4, 1.8, palette[0], "Langage Python",
     "Syntaxe, types, structures de contrôle, fonctions, classes…"),
    (0.7, 2.4, 8.6, 1.8, palette[1], "Bibliothèque standard (stdlib)",
     "os, sys, math, json, csv, re, datetime, pathlib, collections…"),
    (1.1, 4.5, 7.8, 1.8, palette[2], "Paquets tiers",
     "NumPy, Pandas, Matplotlib, Django, FastAPI, scikit-learn, PyTorch…"),
    (1.5, 6.6, 7.0, 1.8, palette[3], "Applications",
     "Scripts, API web, notebooks, modèles ML, outils CLI…"),
]

for (x, y, w, h, color, titre, sous_titre) in couches:
    box = patches.FancyBboxPatch(
        (x, y), w, h,
        boxstyle="round,pad=0.2",
        linewidth=2,
        edgecolor=color,
        facecolor=color,
        alpha=0.25
    )
    ax.add_patch(box)
    border = patches.FancyBboxPatch(
        (x, y), w, h,
        boxstyle="round,pad=0.2",
        linewidth=2,
        edgecolor=color,
        facecolor='none'
    )
    ax.add_patch(border)
    ax.text(x + w / 2, y + h - 0.45, titre,
            ha='center', va='center',
            fontsize=12, fontweight='bold', color=color)
    ax.text(x + w / 2, y + 0.6, sous_titre,
            ha='center', va='center',
            fontsize=8.5, color='#444444', style='italic')

# Flèche indiquant la direction de construction
for y_arrow in [2.15, 4.35, 6.45]:
    ax.annotate('', xy=(5.0, y_arrow + 0.05), xytext=(5.0, y_arrow - 0.05),
                arrowprops=dict(arrowstyle='->', color='#888888', lw=2))

ax.text(9.7, 5.5, 'Abstraction\ncroissante', ha='center', va='center',
        fontsize=9, color='#888888', style='italic',
        rotation=90)
ax.annotate('', xy=(9.5, 8.1), xytext=(9.5, 0.4),
            arrowprops=dict(arrowstyle='->', color='#aaaaaa', lw=1.5))

plt.tight_layout()
plt.show()
_images/1f964bcbad833276c6d20d1383b85b66847a3b523f75142b09f7f0278ff83478.png

Résumé#

Dans ce premier chapitre, nous avons posé les fondations nécessaires pour travailler avec Python :

  • Python est un langage créé en 1991 par Guido van Rossum, dont la philosophie est résumée dans le Zen de Python : clarté, simplicité, et une façon évidente de faire les choses. Il s’applique à une vaste gamme de domaines : scripts, web, data science, IA, sciences.

  • Il est impératif d’utiliser Python 3 (Python 2 est abandonné depuis 2020). L’outil pyenv permet de gérer facilement plusieurs versions sur un même système.

  • uv est le gestionnaire moderne de référence : il remplace pip + venv en offrant vitesse, reproductibilité (via uv.lock) et une interface unifiée pour créer des environnements, installer des paquets et exécuter des scripts.

  • Le REPL Python est un outil interactif indispensable pour explorer le langage. Les fonctions help(), dir() et type() permettent d’inspecter n’importe quel objet.

  • VS Code avec les extensions Python et Pylance constitue un environnement de développement confortable et puissant pour les projets Python.

  • Tout fichier .py est à la fois un script et un module ; le bloc if __name__ == "__main__": est la convention pour définir le point d’entrée d’un script.

Dans le chapitre suivant, nous plongerons dans les types de base de Python : entiers, flottants, booléens, chaînes de caractères et None, en explorant leurs propriétés et leurs opérations fondamentales.

Contenu