I1 — numpy et SQL

Objectif du chapitre. Apprendre à utiliser les bibliothèques scientifiques (numpy, matplotlib, scipy) pour le calcul vectorisé et la visualisation, et à requêter une base de données relationnelle avec SQL (SELECT, WHERE, JOIN, GROUP BY). Ce chapitre complète l'IPT en montrant les outils standards du calcul scientifique et de la gestion de données.

Notions

1. numpy

numpy fournit des tableaux multidimensionnels performants (calculs vectorisés, pas de boucles Python) ; les opérations élément par élément sont rapides (par exemple np.array([1,2,3]) * 2 renvoie [2,4,6]) ; les fonctions usuelles sont np.linspace, np.arange, np.sum, np.mean, np.sqrt, np.log, np.exp, np.sin, ... ; la complexité des opérations vectorisées est $O(n)$ (mais beaucoup plus rapide qu'une boucle Python grâce à la pré-compilation en C).

import numpy as np
x = np.linspace(0, 1, 101)   # 101 points entre 0 et 1
y = np.sin(x)                # sin appliqué à chaque point (vectorisé)
np.mean(y)                   # moyenne de y

2. matplotlib

matplotlib fournit des fonctions de plotting (courbes, histogrammes, scatter) ; les fonctions usuelles sont plt.plot, plt.scatter, plt.bar, plt.xlabel, plt.ylabel, plt.title, plt.show ; c'est l'outil standard pour visualiser des données.

import matplotlib.pyplot as plt
plt.plot(x, y)
plt.xlabel("x"); plt.ylabel("sin(x)"); plt.title("Sinus")
plt.show()

3. scipy

scipy fournit des fonctions scientifiques avancées (optimisation, intégration, interpolation, transformées de Fourier, équations différentielles) ; les modules usuels sont scipy.integrate (intégration), scipy.optimize (optimisation), scipy.interpolate (interpolation), scipy.fft (Fourier) ; c'est l'outil pour les calculs numériques complexes (complément des méthodes du chapitre I1 — Calcul numérique).

4. Bases de données / SQL

Une base de données relationnelle stocke les données dans des tables (lignes et colonnes) ; SQL est le langage de requête ; les requêtes usuelles sont : SELECT (extraire des colonnes), WHERE (filtrer les lignes), JOIN (relier plusieurs tables), GROUP BY (regrouper et agréger — COUNT, SUM, AVG) ; une requête simple est :

SELECT nom, SUM(prix) AS total
FROM commandes
WHERE date > '2024-01-01'
GROUP BY nom;

La complexité d'une requête dépend du nombre de lignes (sans index : $O(n)$ ; avec index : $O(\log n)$ pour une recherche par clé).

Capacités exigibles

Ce chapitre est un outil de l'IPT : il met en pratique la complexité (I1.complexite-algorithme) pour choisir entre une boucle Python et une opération vectorisée numpy, et pour estimer le coût d'une requête SQL (avec ou sans index). Les deux capacités sont traitées en détail dans le chapitre I1 — Algorithmes et complexité.

Ce qui tombe en colle et en DS

• Écrire une requête SQL simple (SELECT, WHERE, GROUP BY) et l'interpréter.
• Comparer le coût d'une opération en boucle Python vs vectorisée numpy.
• Estimer la complexité d'une requête avec/sans index.

Pièges classiques

• numpy : forme des tableaux : les opérations vectorisées exigent des tableaux de même forme (sinon erreur de diffusion ou résultat faux) ; il faut vérifier les formes (x.shape) avant de combiner des tableaux.
• SQL : GROUP BY : toute colonne dans le SELECT qui n'est pas agrégée (SUM, COUNT, ...) doit apparaître dans le GROUP BY (sinon erreur) ; il ne faut pas oublier de regrouper par la colonne de regroupement.
• SQL : index : une recherche par clé est en $O(\log n)$ si la colonne est indexée ; sans index, c'est une recherche linéaire $O(n)$ ; il faut indexer les colonnes fréquemment requêtées (mais pas toutes : les index ralentissent les insertions).

Pour aller plus loin

Annales utilisables sur ce chapitre : voir la page générale Ressources, exercices et annales pour les manuels recommandés et les banques d'exercices gratuites.