SciPy en Python : tutoriel complet sur les bibliothèques et fonctions

SciPy en Python : tutoriel complet sur les bibliothèques et fonctions

SciPy en Python

SciPy est une bibliothèque open-source qui étend NumPy pour fournir des outils pour résoudre des problèmes mathématiques, scientifiques, d'ingénierie et techniques. Construite sur NumPy, SciPy offre un large ensemble de commandes de haut niveau pour la manipulation et la visualisation de données.

Sous-packages

• scipy.io – Entrée/sortie de fichiers pour MATLAB, NetCDF, CSV et bien d'autres formats
• scipy.special – Fonctions mathématiques spéciales (Bessel, Gamma, etc.)
• scipy.linalg – Routines d'algèbre linéaire
• scipy.interpolate – Techniques d'interpolation
• scipy.optimize – Optimisation et ajustement de courbes
• scipy.stats – Distributions statistiques et génération de nombres aléatoires
• scipy.integrate – Intégration numérique
• scipy.fftpack – Transformées de Fourier rapides
• scipy.signal – Traitement de signal
• scipy.ndimage – Traitement d'image multi-dimensionnel

Ce tutoriel couvre :

• Qu'est-ce que SciPy et pourquoi c'est important
• Différences entre NumPy et SciPy
• Installation et configuration de l'environnement
• Sous-packages clés avec exemples de code
• Applications pratiques : algèbre linéaire, transformées de Fourier, optimisation, traitement d'image, intégration numérique

Pourquoi utiliser SciPy ?

• Ensemble complet d'outils scientifiques, second seulement à des bibliothèques comme GNU Scientific Library et MATLAB
• Facile à utiliser, rapide, et entièrement compatible avec les tableaux NumPy
• Largement adopté dans le milieu académique et industriel, assurant un support robuste et des contributions communautaires

NumPy vs SciPy

NumPy

• Bibliothèque de base pour le calcul numérique haute performance en Python, écrite en C
• Fournit des objets array et opérations de base (tri, remodelage, indexation)
• Fondation pour toutes les bibliothèques scientifiques en Python

SciPy

• Construite sur NumPy, l'étendant avec des algorithmes spécialisés
• Inclut des suites complètes d'algèbre linéaire, optimisation, statistiques, et plus
• Essentielle pour les flux de travail scientifiques avancés

Installation et configuration de l'environnement

Installez SciPy avec pip ou les gestionnaires de paquets système :

Python3 -m pip install --user numpy scipy

sudo apt-get install python-scipy python-numpy

sudo port install py35-scipy py35-numpy

Importez SciPy et NumPy dans vos scripts :

from scipy import special
import numpy as np

Entrée/Sortie de fichiers avec scipy.io

Sauvegarder et charger facilement des fichiers MATLAB .mat :

import numpy as np
from scipy import io as sio

array = np.ones((4, 4))
sio.savemat('exemple.mat', {'ar': array})
chargé = sio.loadmat('exemple.mat', struct_as_record=True)
print(chargé['ar'])

Sortie :

array([[1., 1., 1., 1.],
       [1., 1., 1., 1.],
       [1., 1., 1., 1.],
       [1., 1., 1., 1.]])

Fonctions spéciales – scipy.special

Exemples de fonctions spéciales couramment utilisées :

• Racine cubique : scipy.special.cbrt(x) → cbrt([27, 64]) # [3., 4.]
• 10^x : scipy.special.exp10(x) → exp10([1,10]) # [1.e+01 1.e+10]
• Combinaisons : scipy.special.comb(N, k, exact=False, repetition=True) → comb(5, 2) # 15.0
• Permutations : scipy.special.perm(N, k, exact=True) → perm(5, 2) # 20
• LogSumExp : scipy.special.logsumexp(x)
• Bessel J : scipy.special.jn(n, x)

Algèbre linéaire – scipy.linalg

Calculer déterminant, inverse, valeurs propres et vecteurs propres :

from scipy import linalg
import numpy as np

A = np.array([[4,5],[3,2]])
print(linalg.det(A))        # -7.0
print(linalg.inv(A))        # matrice inverse
vals, vecs = linalg.eig(A)
print(vals)
print(vecs)

Sortie :

-7.0
array([[-0.28571429,  0.71428571],
       [ 0.42857143, -0.57142857]])
[ 9.+0.j -1.+0.j]
[[ 0.70710678 -0.5547002 ]
 [ 0.70710678  0.83205029]]

Transformée de Fourier discrète – scipy.fftpack

Transformer un sinusoïde et visualiser son spectre :

%matplotlib inline
from matplotlib import pyplot as plt
import numpy as np
from scipy import fftpack

freq = 5
sample_rate = 50
t = np.linspace(0, 2, 2 * sample_rate, endpoint=False)
wave = np.sin(freq * 2 * np.pi * t)
plt.plot(t, wave)
plt.xlabel('Temps (s)'); plt.ylabel('Amplitude')
plt.show()

A = fftpack.fft(wave)
frequency = fftpack.fftfreq(len(wave)) * sample_rate
plt.stem(frequency, np.abs(A))
plt.xlabel('Fréquence (Hz)')
plt.ylabel('Magnitude')
plt.xlim(-sample_rate/2, sample_rate/2)
plt.ylim(0, 110)
plt.show()

Optimisation – scipy.optimize

Trouver le minimum d'une fonction scalaire en utilisant BFGS et recherche globale avec basin-hopping :

%matplotlib inline
import numpy as np
import matplotlib.pyplot as plt
from scipy import optimize

def func(a):
    return a*2 + 20*np.sin(a)

plt.plot(np.linspace(-10, 10, 400), func(np.linspace(-10, 10, 400)))
plt.show()

min_bfgs = optimize.fmin_bfgs(func, 0)
print('Résultat BFGS :', min_bfgs)

min_basin = optimize.basinhopping(func, 0)
print('Résultat Basin-hopping :', min_basin.x)

La sortie montre le minimum local trouvé par BFGS et l'optimum global confirmé par basin-hopping.

Algorithme Nelder-Mead

Minimisation simple sans contrainte sans information de gradient :

from scipy.optimize import minimize

def f(x):
    return 0.4*(1 - x[0])**2

res = minimize(f, [2, -1], method='Nelder-Mead')
print('Résultat :', res.x, 'Valeur fonction :', res.fun)

Traitement d'image – scipy.ndimage

Manipuler des images : afficher, retourner, pivoter, et appliquer des filtres.

from scipy import ndimage, misc
from matplotlib import pyplot as plt

panda = misc.face()
plt.imshow(panda)
plt.title('Original')
plt.show()

flip_down = np.flipud(panda)
plt.imshow(flip_down)
plt.title('Retourné verticalement')
plt.show()

rotated = ndimage.rotate(panda, 135)
plt.imshow(rotated)
plt.title('Pivoté 135°')
plt.show()

Intégration numérique – scipy.integrate

Intégrales simples et doubles avec estimation d'erreur automatique :

from scipy import integrate

# Intégrale simple de x^2 de 0 à 1
simple = integrate.quad(lambda x: x**2, 0, 1)
print('Intégrale simple :', simple)

# Intégrale double de 64*x*y sur un domaine triangulaire
double = integrate.dblquad(lambda x, y: 64*x*y, 0, 2/4,
                           lambda x: 0,
                           lambda y: (1 - 2*y**2)**0.5)
print('Intégrale double :', double)

Les deux renvoient un tuple : (valeur, erreur estimée).

Résumé

SciPy étend NumPy pour fournir une pile complète de calcul scientifique, incluant algèbre linéaire, optimisation, statistiques, traitement de signal et manipulation d'image. Ses sous-packages étendus et son support communautaire robuste la rendent indispensable pour chercheurs et ingénieurs.

Nom du package	Description
scipy.io	Entrée/sortie fichiers pour MATLAB, CSV, NetCDF, etc.
scipy.special	Fonctions mathématiques spéciales (Bessel, Gamma, etc.)
scipy.linalg	Routines d'algèbre linéaire avancées
scipy.interpolate	Méthodes d'interpolation
scipy.optimize	Outils d'optimisation et d'ajustement de courbes
scipy.stats	Distributions statistiques & génération nombres aléatoires
scipy.integrate	Intégration numérique (quad, dblquad, etc.)
scipy.fftpack	Transformées de Fourier rapides
scipy.signal	Utilitaires de traitement de signal
scipy.ndimage	Traitement d'image multi-dimensionnel