Tu connais déjà NumPy, qui te débarrasse des boucles, et SymPy, qui dérive et factorise à ta place. Mais le jour où tu dois résoudre une équation non linéaire, calculer une intégrale ou ajuster une courbe sur des données bruitées, ni l'un ni l'autre ne suffit. C'est là que SciPy entre en scène.
SciPy est la boîte à outils du calcul scientifique en Python, construite au-dessus de NumPy. Optimisation, intégration, interpolation, statistiques, traitement du signal : tout y est, et tout tourne en local, sans clé API ni serveur. Aujourd'hui, on s'attaque à quatre cas concrets que tu rencontreras tôt ou tard : résoudre une équation, intégrer une fonction, minimiser une fonction et ajuster un modèle sur tes données.
Sous le capot, SciPy est organisé en modules : scipy.optimize pour l'optimisation, scipy.integrate pour les intégrales, scipy.fft pour le traitement du signal, scipy.stats pour les statistiques et scipy.linalg pour l'algèbre linéaire. On ne va pas tout explorer, mais tu repars avec les quatre réflexes qui couvrent l'essentiel.
Installe SciPy
SciPy s'installe comme n'importe quel paquet Python. Il embarque déjà NumPy, donc une seule commande suffit :
pip install scipyPas de clé API, pas de serveur, tout tourne sur ta machine. Vérifie que l'installation a fonctionné :
import scipy
print(scipy.__version__)Résous une équation que tu ne sais pas résoudre
Certaines équations n'ont pas de solution simple à la main. Prends x³ − 2x − 5 = 0, un classique impossible à factoriser proprement. NumPy ne sait pas la résoudre, mais SciPy le fait en trois lignes grâce à root_scalar :
from scipy.optimize import root_scalar
def f(x):
return x**3 - 2*x - 5
solution = root_scalar(f, bracket=[0, 3], method="brentq")
print(solution.root) # 2.0945...
print(f(solution.root)) # ~0 : la solution est bonneTu fournis une fonction f et un intervalle [0, 3] où la racine se cache. La méthode de Brent combine dichotomie et interpolation pour encadrer la solution, puis affine jusqu'à une précision de l'ordre de 10⁻¹⁴. Change f, change l'intervalle, et tu résous à peu près n'importe quelle équation à une inconnue. Pour un système de plusieurs équations, il y a son grand frère scipy.optimize.root.
Au passage, root_scalar accepte plusieurs méthodes : brentq, bisect, newton ou secant. Avec un intervalle connu, brentq est le choix par défaut, robuste et rapide. Sans intervalle mais avec une bonne estimation de départ, newton fait très bien l'affaire.
Intègre une fonction, même jusqu'à l'infini
L'intégrale de la gaussienne e^(−x²) sur tout l'axe réel vaut exactement √π. C'est un résultat célèbre, mais personne n'a envie de le recalculer à la main. SciPy, si :
from scipy.integrate import quad
import numpy as np
def gaussienne(x):
return np.exp(-x**2)
valeur, erreur = quad(gaussienne, -np.inf, np.inf)
print(valeur) # 1.7724...
print(np.sqrt(np.pi)) # 1.7724... on retombe pile dessusquad accepte des bornes infinies et te renvoie deux choses : la valeur de l'intégrale et une estimation de l'erreur. Ici on retombe pile sur la racine carrée de pi, à la quinzième décimale près. Pour une intégrale double ou triple, il existe dblquad et tplquad, même principe, mêmes bornes.
Minimise une fonction en quelques lignes
Trouver le minimum d'une fonction à la main, c'est dériver, annuler, vérifier : fastidieux dès que la fonction se complique. La fonction de Rosenbrock, avec sa vallée en forme de banane, est le cauchemar classique des algorithmes d'optimisation. SciPy s'en sort en trois lignes :
from scipy.optimize import minimize
def rosenbrock(x):
return (1 - x[0])**2 + 100 * (x[1] - x[0]**2)**2
resultat = minimize(rosenbrock, x0=[0, 0], method="BFGS")
print(resultat.x) # [1., 1.]
print(resultat.fun) # ~0On part d'un point de départ [0, 0], et l'algorithme BFGS descend vers le minimum en calculant des gradients. Résultat : [1, 1], exactement le fond de la vallée, avec une valeur quasi nulle. C'est la brique que tu retrouveras partout, du calage de modèle à la recherche de paramètres.
Ajuste une courbe sur des données bruitées
C'est le cas le plus utile au quotidien. Tu récupères des mesures pleines de bruit et tu soupçonnes une décroissance exponentielle derrière. Plutôt que de bidouiller les paramètres à la main, laisse curve_fit les trouver par moindres carrés :
import numpy as np
from scipy.optimize import curve_fit
rng = np.random.default_rng(42)
x = np.linspace(0, 4, 50)
y = 3.1 * np.exp(-0.8 * x) + rng.normal(0, 0.15, size=x.size)
def expo(x, a, b):
return a * np.exp(-b * x)
popt, pcov = curve_fit(expo, x, y)
print(popt) # [3.04, 0.77], proche de [3.1, 0.8]On a fabriqué des données avec a = 3.1 et b = 0.8, puis on a ajouté du bruit gaussien. curve_fit les retrouve malgré tout. popt contient les paramètres ajustés, pcov leur matrice de covariance : c'est d'elle que tu tires les incertitudes sur chaque valeur. Pour les cas simples, c'est du scikit-learn sans scikit-learn.
Un détail qui compte : curve_fit suppose que ton modèle expo(x, a, b) a exactement la bonne forme. Si le modèle est faux, l'ajustement sera faux, et c'est à toi de le choisir. Pour vérifier, regarde les résidus (les écarts entre y et le modèle) : ils doivent ressembler à du hasard, pas à une tendance.
Bonus : repère les fréquences cachées d'un signal
Un dernier tour qui impressionne toujours : la transformée de Fourier rapide (FFT). On mélange deux fréquences et SciPy les retrouve sans effort :
from scipy.fft import fft, fftfreq
import numpy as np
N, T = 800, 1.0 / 800.0
t = np.linspace(0.0, N * T, N, endpoint=False)
signal = np.sin(50.0 * 2 * np.pi * t) + 0.5 * np.sin(120.0 * 2 * np.pi * t)
yf = fft(signal)
xf = fftfreq(N, T)[:N // 2]
top = np.argsort(np.abs(yf[:N // 2]))[-2:]
print(np.sort(xf[top])) # [50., 120.]On a sommé une onde à 50 Hz et une autre à 120 Hz : la FFT les ressort telles quelles. C'est la brique de base du traitement du signal, de l'analyse audio à la détection d'anomalies.
Tu peux même filtrer un signal : mets à zéro les coefficients de la FFT que tu veux supprimer, puis applique la transformée inverse avec scipy.fft.ifft. Filtre passe-bas maison en trois lignes.
SciPy ne remplace ni NumPy ni SymPy, il les complète. NumPy te donne les tableaux, SymPy fait du calcul formel, et SciPy s'attaque au calcul numérique qui finit toujours par te tomber dessus : une équation à résoudre, une intégrale à évaluer, une fonction à minimiser, une courbe à ajuster.
Garde-le dans ta caisse à outils, juste à côté de ses cousins. La prochaine fois qu'un collègue te sort une équation tordue ou un jeu de données à dompter, tu auras la réponse en trois lignes.
Auteur
Krugz
Développeur fullstack
Développeur fullstack qui tente, tant bien que mal, de suivre l'actualité de l'IA au milieu d'une marée d'informations imbuvables et des milliers d'outils et de modèles qui sortent chaque jour.
