Découvrez les bibliothèques Python qui ont révolutionné le développement

Python est l’un des langages de programmation les plus populaires au monde, et cela tient en grande partie à sa large gamme de bibliothèques. Elles contiennent du code déjà écrit pour accomplir des tâches courantes, ce qui rend le travail des développeurs beaucoup plus simple et plus fluide.

Depuis plusieurs années, de nouvelles bibliothèques apparaissent et les plus établies évoluent. Voici celles qui ont marqué le développement Python, avec leur état actuel (octobre 2026) et des exemples de code que nous avons exécutés avec Python 3.14.

FastAPI

FastAPI a été créé comme alternative rapide aux frameworks web plus traditionnels tels que Flask et Django. Il génère automatiquement la documentation de votre API à partir des annotations de type (« type hints ») et prend aussi en charge les WebSockets. La bibliothèque est simple d’accès, mais une formation sur le langage reste très utile pour bien en profiter. FastAPI est très activement maintenu (version 0.143 en octobre 2026) et compatible avec Python 3.14.

Exemple :

from fastapi import FastAPI

app = FastAPI()

@app.get("/")
def read_root():
    return {"Hello": "World"}

Pour le lancer : fastapi dev main.py (après pip install "fastapi[standard]").

Pydantic

Pydantic permet de valider vos données grâce aux annotations de type. Son cœur est écrit en Rust depuis la version 2, ce qui le rend très rapide. Il s’intègre étroitement avec FastAPI et génère automatiquement des schémas JSON pour documenter votre API. La version actuelle est la 2.14.

Exemple :

from pydantic import BaseModel

class Character(BaseModel):
    name: str
    strength: int

c = Character(name='Conan', strength=9)
print(c.model_dump())

Attention : dans les tutoriels plus anciens, vous verrez c.dict(). Cette méthode est dépréciée depuis Pydantic 2 au profit de model_dump(), et elle sera supprimée dans la future version 3.

Streamlit

Streamlit est une bibliothèque Python très accessible pour créer des applications web de visualisation de données, avec une interface soignée et sans écrire de HTML ni de JavaScript. Elle est toujours très active (version 1.65). Pour lancer une application : streamlit run app.py.

Exemple :

import streamlit as st

x = st.slider('Select a value')
st.write(x, 'squared is', x * x)

Rich

Rich enrichit la sortie console : couleurs, tableaux, barres de progression, rendu Markdown, affichage lisible des erreurs. Le dépôt se trouve désormais sous l’organisation Textualize (version 15 en 2026).

Exemple :

from rich.console import Console

console = Console()
console.print("Hello World", style="bold red")

En somme, ces bibliothèques permettent de gagner en efficacité et de proposer plus facilement des solutions à des problèmes courants. N’hésitez pas à en essayer une ou plusieurs dans vos prochains projets.

Boostez votre productivité avec l’analyse et la visualisation de données : pandas, NumPy et Matplotlib

Si vous travaillez avec des données en Python, vous avez probablement entendu parler de pandas, NumPy et Matplotlib. Ces bibliothèques sont très répandues parmi les data scientists : elles permettent de manipuler de gros tableaux de données et de créer facilement des graphiques.

Les avantages de ces bibliothèques pour la data science

pandas, NumPy et Matplotlib offrent plusieurs avantages :

• Productivité améliorée : un ensemble cohérent d’outils plutôt qu’une combinaison de solutions disparates.
• Manipulation rapide des tableaux de données (DataFrames) : on filtre, regroupe et transforme des tables entières sans écrire de boucles for fastidieuses.
• Visualisations riches : Matplotlib permet de créer de nombreux types de graphiques (histogrammes, nuages de points, cartes de chaleur…) pour servir au mieux votre message.

1. pandas

pandas est une bibliothèque open source, construite au-dessus de NumPy, qui fournit des structures de données adaptées aux données tabulaires : les DataFrames. C’est souvent la première bibliothèque que l’on charge dans un environnement d’analyse. La version actuelle est la 3.0 (3.0.6), qui demande Python 3.11 ou plus récent. La version 3 apporte des changements de comportement par rapport à la 2 (notamment le type texte dédié par défaut et la copie à l’écriture), à garder en tête si vous migrez du code ancien.

2. NumPy

NumPy est la bibliothèque fondamentale du calcul scientifique en Python : elle fournit des tableaux multidimensionnels (arrays) efficaces, indispensables en machine learning. La version actuelle est la 2.5 (Python 3.12 ou plus récent requis).

3. Matplotlib

Matplotlib est la bibliothèque de visualisation de référence en Python, utilisée par beaucoup d’autres paquets pour leurs graphiques. La version actuelle est la 3.11.

Exemple et utilisation concrète

Supposons qu’un analyste financier travaille sur un historique de données boursières comportant plusieurs colonnes : date d’achat, prix d’acquisition, prix actuel, etc.

Considérons les besoins suivants :

1°) Sélectionner toutes les lignes achetées après 2015.
2°) Créer une nouvelle colonne contenant la différence entre le prix actuel et le prix d’acquisition.
3°) Afficher uniquement les titres dont le prix actuel dépasse le prix d’acquisition.

Voici un exemple équivalent en code :

import pandas as pd

df = pd.DataFrame({
    "date_achat": pd.to_datetime(["2012-03-01", "2016-05-02", "2019-01-10"]),
    "prix_achat": [10.0, 20.0, 30.0],
    "prix_actuel": [15.0, 18.0, 45.0],
})

recents = df[df["date_achat"] > "2015-12-31"].copy()
recents["ecart"] = recents["prix_actuel"] - recents["prix_achat"]
print(recents[recents["ecart"] > 0])

Nous avons filtré, créé une nouvelle colonne et sélectionné les lignes voulues sans aucune boucle for.

Les bibliothèques de web scraping à utiliser (et celles à éviter)

Le web scraping est une technique permettant d’extraire des données de sites web. Il peut servir à de la veille concurrentielle ou à automatiser la récupération de données. Voyons quelles bibliothèques Python privilégier et lesquelles éviter. Pensez toujours à respecter les conditions d’utilisation et le fichier robots.txt des sites visés.

Les bibliothèques à utiliser

Beautiful Soup

Beautiful Soup est l’une des bibliothèques les plus utilisées en Python pour le web scraping. Elle permet d’analyser du HTML et du XML, y compris mal formés, et de rechercher facilement un élément dans le document. Elle est toujours maintenue (version 4.15). Elle ne télécharge pas les pages : on l’associe à une bibliothèque HTTP comme Requests.

from bs4 import BeautifulSoup
import requests

response = requests.get("https://example.com", timeout=10)
soup = BeautifulSoup(response.text, "html.parser")
print(soup.title.text)  # Example Domain

Playwright (à la place de Requests-HTML)

Pour les pages dont le contenu est généré par JavaScript, la solution moderne est Playwright, maintenu activement (version 1.63), qui pilote un vrai navigateur (Chromium, Firefox, WebKit). Après pip install playwright et playwright install chromium :

from playwright.sync_api import sync_playwright

with sync_playwright() as p:
    browser = p.chromium.launch()
    page = browser.new_page()
    page.goto("https://example.com")
    print(page.title())  # Example Domain
    browser.close()

Scrapy

Scrapy est un framework d’extraction de données open source, rapide et efficace, écrit en Python. Il est conçu pour traiter de gros volumes de pages : gestion des files de requêtes, suivi des liens, export des résultats. Il est très actif (version 2.19, Python 3.10 ou plus récent requis).

import scrapy

class BlogSpider(scrapy.Spider):
    name = 'blogspider'
    start_urls = ['https://quotes.toscrape.com/']

    def parse(self, response):
        for quote in response.css('.quote .text'):
            yield {'title': quote.css('::text').get()}

        next_page = response.css('li.next a::attr(href)').get()
        if next_page is not None:
            yield response.follow(next_page, self.parse)

Pour l’exécuter : scrapy runspider blogspider.py -o resultats.json.

Les bibliothèques à éviter

Requests-HTML

Requests-HTML combinait Requests et un navigateur Chromium piloté par pyppeteer. C’était pratique, mais la dernière version date de 2019 et pyppeteer n’a pas publié de nouvelle version depuis 2024 (statut « Alpha »). Pour un nouveau projet, préférez Playwright, présenté plus haut.

PyQuery : à nuancer

Nous avions déconseillé PyQuery en raison d’un manque de maintenance. Ce n’est plus vrai : il est de nouveau publié régulièrement (version 2.1.0 en juillet 2026, Python 3.11 à 3.13 annoncés). Sa syntaxe inspirée de jQuery reste agréable si vous la connaissez déjà ; Beautiful Soup reste toutefois le choix le plus courant.

from pyquery import PyQuery as pq

d = pq('<div id="test" class="class1"><ul><li>xxxx</li></ul></div>')
print(d('#test li').text())  # xxxx

lxml : excellent, mais à utiliser pour ce qu’il fait le mieux

lxml est une bibliothèque rapide et très complète pour analyser et manipuler du XML et du HTML, avec prise en charge de XPath. Elle est maintenue (version 6.1). Ce n’est pas un mauvais choix pour le scraping, contrairement à ce que nous écrivions : c’est même le moteur sous-jacent de PyQuery et une option de Beautiful Soup. Son API est simplement plus bas niveau que celle de Beautiful Soup.

from lxml import html

tree = html.fromstring(
    "<html><body><div title='buyer-name'>Carson</div>"
    "<span class='item-price'>$29.95</span></body></html>"
)

buyers = tree.xpath('//div[@title="buyer-name"]/text()')
prices = tree.xpath('//span[@class="item-price"]/text()')

print(buyers)  # ['Carson']
print(prices)  # ['$29.95']

Créez vos projets d’IA avec TensorFlow, Keras et scikit-learn

Si l’intelligence artificielle vous passionne, vous connaissez sans doute TensorFlow, Keras et scikit-learn. Ces bibliothèques offrent une grande variété d’outils pour créer des modèles et résoudre des problèmes de classification, de régression et d’autres tâches.

Commençons par comprendre ces outils

1. TensorFlow

TensorFlow est une plateforme open source créée par Google en 2015 pour construire des modèles de deep learning. Elle peut s’exécuter sur CPU, GPU ou TPU. La version actuelle est la 2.21 ; elle annonce la prise en charge de Python 3.10 à 3.13, pas encore de Python 3.14. Aujourd’hui, une grande partie de la recherche et des nouveaux projets utilise aussi PyTorch : TensorFlow n’est plus le choix par défaut qu’il était en 2023.

2. Keras

Keras est une API de haut niveau pour construire et entraîner des réseaux de neurones. Depuis Keras 3, elle est « multi-backend » : un même code fonctionne avec TensorFlow, JAX ou PyTorch. Elle n’est donc plus liée à TensorFlow comme nous l’écrivions. Keras permet de prototyper rapidement avant de passer à l’échelle (version actuelle : 3.15, Python 3.11 ou plus récent requis).

3. scikit-learn

scikit-learn fournit des algorithmes de machine learning classique (classification, régression, clustering, réduction de dimension…) avec une API très homogène. C’est un excellent point de départ avant le deep learning. La version actuelle est la 1.9.

Comment utiliser ces outils ?

Utiliser ces outils d’apprentissage automatique suit généralement plusieurs étapes :

• Récupérer et charger les données.
• Diviser le jeu de données en deux : entraînement et test.
• Construire le modèle, dont chaque couche peut être paramétrée selon vos besoins.
• Entraîner le modèle, puis l’évaluer sur les données de test.
• Une fois le modèle ajusté, l’utiliser pour prédire de nouveaux résultats.

Exemples d’utilisation

• Un programme qui apprend à distinguer une photo de chat d’une photo de chien. Il est entraîné sur des images déjà étiquetées, puis analyse les pixels de chaque nouvelle image pour la classer.
• La classification d’images médicales (par exemple des radiographies) pour aider les spécialistes dans leurs diagnostics. Ces systèmes sont entraînés sur de nombreuses images annotées par des experts et ne remplacent pas leur avis.

L’apprentissage automatique est l’une des technologies les plus importantes d’aujourd’hui, et ces bibliothèques en sont une bonne porte d’entrée.

Améliorez l’expérience utilisateur avec Tkinter, PyQt et wxPython

Lorsqu’on développe une application de bureau en Python, l’expérience utilisateur (UX) compte. Voici trois bibliothèques courantes pour créer des interfaces graphiques : Tkinter, PyQt (avec son équivalent officiel PySide) et wxPython.

Tkinter

Tkinter est la bibliothèque graphique de la bibliothèque standard de Python. Elle permet de créer facilement des fenêtres, boutons, champs de texte et autres widgets. Simple à utiliser, elle propose moins d’options que PyQt ou wxPython.

Exemple :

import tkinter as tk

root = tk.Tk()

label = tk.Label(root, text="Hello World", font=("Arial Bold", 20))
label.pack()

root.mainloop()

Il suffit d’importer tkinter puis de déclarer les éléments à l’aide des classes proposées.

PyQt

PyQt offre une large gamme d’options pour personnaliser votre interface. Il est multiplateforme (Windows, Linux, macOS). Contrairement à Tkinter, il doit être installé séparément. Attention : PyQt5, utilisé dans la version initiale de cet article, n’a plus de nouvelle version depuis 2024. Pour un nouveau projet, utilisez PyQt6 (version 6.11) ou PySide6 (version 6.12), le binding officiel de Qt, publié sous licence LGPL, alors que PyQt est en GPL ou licence commerciale.

Exemple avec PyQt6 (pip install PyQt6) :

import sys
from PyQt6.QtWidgets import QApplication, QWidget, QPushButton, QVBoxLayout

app = QApplication(sys.argv)

window = QWidget()
layout = QVBoxLayout()
layout.addWidget(QPushButton('Bouton 1'))
layout.addWidget(QPushButton('Bouton 2'))
window.setLayout(layout)

window.show()
sys.exit(app.exec())

Quelques points forts de Qt :

• Un large ensemble de widgets et de contrôles
• Des feuilles de style pour personnaliser l’apparence
• L’affichage d’images, de graphiques et de contenu web

wxPython

wxPython permet de créer des interfaces graphiques qui reprennent l’apparence native de chaque système. Elle offre beaucoup d’options, mais elle est plus longue à prendre en main que Tkinter. Elle est toujours maintenue (version 4.3.1, juillet 2026, compatible Python 3.14).

Exemple (pip install wxPython) :

import wx

class Example(wx.Frame):
    def __init__(self, parent, title):
        super().__init__(parent, title=title, size=(260, 180))
        panel = wx.Panel(self)

        vbox = wx.BoxSizer(wx.VERTICAL)
        hbox = wx.BoxSizer(wx.HORIZONTAL)
        hbox.Add(wx.StaticText(panel, label='Entrez un texte…'), 0, wx.RIGHT | wx.TOP, 8)
        hbox.Add(wx.TextCtrl(panel), 1, wx.EXPAND | wx.TOP, 5)
        vbox.Add(hbox, 0, wx.EXPAND | wx.ALL, 10)
        panel.SetSizer(vbox)

app = wx.App()
frame = Example(None, 'Exemple wxPython')
frame.Show()
app.MainLoop()

La construction est très structurée : il faut créer des conteneurs (sizers) qui accueillent les différents éléments. wxPython demande un peu plus d’efforts, mais le résultat s’intègre bien au système.

Fonctionnalité	Tkinter	PyQt / PySide	wxPython
Installation	Incluse avec Python	À installer	À installer
Widgets	De base	Très large gamme	Large gamme
Personnalisation graphique	Limitée (thème ttk)	Très poussée	Moyenne
Mise en page	Gestionnaires pack(), grid(), place()	Layouts, éditeur visuel (Qt Designer)	Sizers

N’hésitez pas à expérimenter avec ces trois bibliothèques pour choisir celle qui convient le mieux à votre projet.

Optimisez vos performances avec Cython, Numba et PyPy

Pour améliorer les performances de votre code Python, plusieurs outils existent. Trois des plus connus sont Cython, Numba et PyPy. Un conseil avant de les essayer : mesurez d’abord (avec cProfile par exemple), et vérifiez si NumPy ou pandas ne résolvent pas déjà le problème en vectorisant le calcul.

Cython

Cython est un compilateur qui transforme du code Python, enrichi de types statiques, en code C. Selon les cas, ces types statiques peuvent accélérer sensiblement l’exécution. La version actuelle est la 3.3.

Voici un exemple, à enregistrer dans un fichier sumc.pyx :

import cython

@cython.boundscheck(False)
def sum_cython(int n):
    cdef long long s = 0
    cdef int i

    for i in range(n):
        s += i

    return s

Dans cet exemple, boundscheck(False) désactive la vérification des indices (elle n’a ici aucun effet pratique, il n’y a pas de tableau, mais elle sert dès que vous manipulez des tableaux). Les variables i et s sont déclarées avec cdef pour qu’elles soient de simples entiers C, et l’argument n est typé pour que le compilateur optimise mieux la boucle. Notez que s est un long long : avec un int de 32 bits, la somme déborderait dès que n dépasse environ 65 000, ce que Python, qui gère des entiers de taille arbitraire, ne fait pas.

Il faut compiler le fichier, par exemple avec un setup.py (un compilateur C est nécessaire) :

from setuptools import setup
from Cython.Build import cythonize

setup(ext_modules=cythonize("sumc.pyx"))

Puis python setup.py build_ext --inplace, après quoi import sumc fonctionne comme n’importe quel module.

Numba

Numba, développé par l’écosystème Anaconda, utilise la compilation juste-à-temps (JIT, via LLVM) pour accélérer les fonctions numériques, en particulier celles qui manipulent des tableaux NumPy. Contrairement à Cython, aucune étape de compilation séparée n’est nécessaire : il suffit de décorer la fonction. Numba est activement maintenu (version 0.68) et compatible avec Python 3.14.

from numba import jit

@jit(nopython=True)
def sum_numba(n):
    s = 0

    for i in range(n):
        s += i

    return s

print(sum_numba(1_000_000))  # 499999500000

Le décorateur @jit indique à Numba de compiler la fonction en code machine au premier appel. Avec nopython=True, Numba génère une erreur s’il ne parvient pas à tout compiler sans repasser par l’interpréteur Python. Dans les versions récentes, @njit (équivalent de @jit(nopython=True)) est le raccourci habituel, et le mode « nopython » est de toute façon devenu le comportement par défaut de @jit.

PyPy

PyPy est une implémentation alternative de l’interpréteur Python qui utilise la compilation juste-à-temps. Il peut être nettement plus rapide que CPython sur du code Python « pur » avec beaucoup de boucles. La version actuelle (8.0) est compatible avec Python 3.11 et 3.12. Le support des extensions écrites en C, et donc de certaines bibliothèques scientifiques, est en revanche plus limité que sur CPython : vérifiez la compatibilité de vos dépendances avant de basculer.

Le plus simple pour l’installer est d’utiliser uv :

$ uv python install pypy

Vous pouvez ensuite exécuter votre programme avec :

$ uv run --python pypy mon-fichier-python.py

Cython, Numba et PyPy sont des outils performants qui permettent d’accélérer des scripts par rapport au Python « pur ». Chacun convient mieux à certains cas : Cython pour des extensions compilées, Numba pour le calcul numérique, PyPy pour du code Python pur. Testez avant de choisir.

Bibliographie

• Site officiel Cython
• Documentation PyPy
• GitHub Numba

Quelles sont les meilleures bibliothèques Python pour débuter ?

Pour débuter, privilégiez des bibliothèques simples d’accès, bien documentées et soutenues par une grande communauté.

NumPy

NumPy fournit des fonctions pour manipuler efficacement des tableaux multidimensionnels volumineux et des matrices. Elle est la base de la plupart des outils scientifiques en Python et sert beaucoup en science des données et en apprentissage automatique.

pandas

pandas est une bibliothèque incontournable de l’analyse de données : elle stocke et manipule facilement les données sous forme tabulaire grâce aux DataFrames, et s’articule très bien avec NumPy. Pour de très gros volumes, Polars est une alternative récente et rapide qui mérite un coup d’œil.

Matplotlib

Matplotlib permet aux débutants comme aux data scientists d’afficher simplement leurs données sous forme de graphiques 2D et en 3D. Elle propose une interface orientée objet. Si vous cherchez des graphiques plus esthétiques ou interactifs, regardez aussi Seaborn et Plotly.

scikit-learn

scikit-learn fournit des algorithmes d’apprentissage automatique pour la classification, la régression, le clustering ou encore la réduction de dimension. Sa documentation, riche en exemples, en fait un bon outil d’apprentissage.

Références :

• FastAPI : https://fastapi.tiangolo.com/
• Pydantic : https://docs.pydantic.dev/
• Streamlit : https://docs.streamlit.io/
• Rich : https://github.com/Textualize/rich

Bibliographie

Documentation pandas
Documentation NumPy
Documentation Matplotlib
Documentation TensorFlow
Documentation Keras
Documentation scikit-learn

Aller plus loin

Pour maîtriser ces bibliothèques et savoir laquelle choisir selon votre projet, découvrez notre formation Python à distance.