Comment effectuer des dérivées symboliques (indéfinies) en Python avec SymPy ?

Introduction

La différentiation symbolique est une compétence fondamentale en mathématiques, en physique, en ingénierie et en science des données. En Python, la bibliothèque SymPy offre un moyen puissant et convivial de calculer des dérivées de manière symbolique, ce qui permet de manipuler et d’analyser des expressions mathématiques de façon exacte plutôt qu’approchée. Cela est particulièrement utile pour des tâches telles que :

Dans un article précédent, nous avons exploré Comment effectuer des intégrations indéfinies (symboliques) en Python avec SymPy, où nous avons appris à calculer des primitives de manière symbolique. Dans cet article, nous nous concentrons sur le sujet complémentaire : la différentiation symbolique, en montrant comment calculer des dérivées de fonctions, des dérivées d’ordre supérieur, des dérivées partielles, et bien plus encore à l’aide de Python et de SymPy.

Installer SymPy

1

pip install sympy

Différentiation symbolique de base

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

import sympy as sp

# Définir un symbole
x = sp.symbols('x')

# Définir une expression
expr = x**2 + 3*x + 5

# Dériver par rapport à x
dexpr = sp.diff(expr, x)

print(dexpr)

Sortie

1

2*x + 3

Dérivées d’ordre supérieur

1
2

sp.diff(expr, x, 2)   # dérivée seconde
sp.diff(expr, x, 3)   # dérivée troisième

Dérivées partielles (fonctions de plusieurs variables)

1
2
3
4
5
6
7
8
9

x, y = sp.symbols('x y')

f = x**2 * y + sp.sin(y)

df_dx = sp.diff(f, x)
df_dy = sp.diff(f, y)

print(df_dx)  # 2*x*y
print(df_dy)  # x**2 + cos(y)

Différentiation implicite

\begin{equation}
x^2 + y^2 = 1
\end{equation}

1
2
3
4
5
6
7
8
9

x = sp.symbols('x')
y = sp.Function('y')(x)

expr = x**2 + y**2 - 1

dy_dx = sp.diff(expr, x)
solution = sp.solve(dy_dx, sp.diff(y, x))[0]

print(solution)

Résultat

1

-x/y(x)

Dérivées symboliques de fonctions

1
2
3
4

x = sp.symbols('x')
f = sp.Function('f')

sp.diff(f(x), x)

Sortie

Évaluer une dérivée en un point

1
2
3
4
5
6
7
8

# Définir une expression
expr = x**2 + 3*x + 5

# Dériver par rapport à x
dexpr = sp.diff(expr, x)

# Évaluer la dérivée en un point
dexpr.subs(x, 2)  # Résultat : 7

Ou numériquement :

1

float(dexpr.subs(x, 2))  # Résultat : 7.0

Convertir une dérivée symbolique en fonction NumPy

Utile pour le tracé ou le calcul numérique :

1
2
3
4
5
6

import numpy as np

f_num = sp.lambdify(x, dexpr, 'numpy')

xvals = np.linspace(0, 5, 100)
yvals = f_num(xvals)

Vous pouvez visualiser la fonction originale ainsi que sa dérivée sur un même graphique, en utilisant différentes couleurs et une légende pour plus de clarté. Voici un exemple clair avec une expression symbolique :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

import matplotlib.pyplot as plt

# Définir le symbole et la fonction
x = sp.symbols('x')
expr = x**2 + 3*x + 5  # fonction originale

# Calculer la dérivée symboliquement
dexpr = sp.diff(expr, x)

# Convertir les expressions symboliques en fonctions numériques
f_num = sp.lambdify(x, dexpr, 'numpy')   # dérivée
f_orig = sp.lambdify(x, expr, 'numpy')   # fonction originale

# Créer les valeurs de x
xvals = np.linspace(0, 5, 100)

# Évaluer les fonctions
yvals_deriv = f_num(xvals)
yvals_orig = f_orig(xvals)

# Tracer les deux courbes
plt.figure(figsize=(8,5))
plt.plot(xvals, yvals_orig, label='f(x) = x^2 + 3x + 5', color='green', linewidth=2)
plt.plot(xvals, yvals_deriv, label="f'(x) = 2x + 3", color='blue', linewidth=2)
plt.title("Fonction et sa dérivée")
plt.xlabel("x")
plt.ylabel("Valeur")
plt.grid(True)
plt.legend()
# Sauvegarder la figure
plt.savefig("function_and_derivative.png", bbox_inches="tight", dpi=100)
plt.show()

Simplification et rendu des dérivées symboliques

Une fois une dérivée symbolique calculée avec SymPy, vous pouvez vouloir la simplifier, l’inspecter ou la rendre sous une forme mathématique propre et lisible. SymPy fournit plusieurs outils intégrés pour cela.

Simplification des dérivées symboliques

Après différentiation, les expressions peuvent parfois être algébriquement complexes. Vous pouvez les simplifier avec :

1

sp.simplify(dexpr)

Cette commande tente de réduire l’expression à une forme plus compacte et mathématiquement équivalente.

Affichage lisible dans la console (pretty-print)

Pour afficher la dérivée dans un format plus lisible, de type manuel scolaire, directement dans le terminal :

1

sp.pretty(dexpr)

Cela affiche une version ASCII de l’expression, utile en dehors des notebooks Jupyter.

Exporter les dérivées en LaTeX

Pour convertir une dérivée symbolique en code LaTeX valide :

1

sp.latex(dexpr)

Ceci est particulièrement utile pour :

• Rapports scientifiques
• Articles académiques
• Diapositives et documentation
• Notebooks Jupyter avec rendu LaTeX

Affichage des dérivées SymPy en LaTeX (Notebook Jupyter)

Dans un notebook Jupyter, les expressions SymPy — y compris les dérivées symboliques — peuvent être rendues élégamment en LaTeX à l’aide des outils d’affichage intégrés. Cela améliore considérablement la lisibilité et la qualité de présentation.

Option 1 : utiliser sp.init_printing() (recommandé)

Cela active le rendu LaTeX automatique pour toutes les sorties SymPy.

1
2
3
4
5
6
7
8
9

import sympy as sp

sp.init_printing()

x = sp.Symbol('x')
f = x**2 * sp.exp(x)

df = sp.diff(f, x)
df

Sortie :

La dérivée apparaît sous la forme d’une expression LaTeX correctement formatée directement dans la cellule de sortie.

Option 2 : afficher des équations avec display() et sp.Eq()

Pour montrer explicitement une équation de dérivation :

1
2
3
4
5
6
7
8

from sympy import symbols, diff, exp, Eq
from IPython.display import display

x = symbols('x')
f = x**2 * exp(x)
df = diff(f, x)

display(Eq(sp.Derivative(f, x), df))

Ceci est utile pour l’enseignement ou la documentation, car cela montre clairement l’opération de dérivation et son résultat.

Option 3 : rendu LaTeX manuel avec display(Math(...))

Pour un contrôle total sur l’équation affichée :

1
2
3

from IPython.display import display, Math

display(Math(f"\\frac{{d}}{{dx}}\\left(x^2 e^x\\right) = {sp.latex(df)}"))

Ici, sp.latex() convertit l’expression symbolique en LaTeX, tandis que Math() se charge du rendu.

Option 4 (optionnelle) : LaTeX en ligne dans des cellules Markdown

Pour une sortie de qualité publication, vous pouvez également écrire directement du LaTeX dans une cellule Markdown :

1

$\frac{d}{dx}\left(x^2 e^x\right) = e^x(x^2 + 2x)$

Ceci est idéal pour les tutoriels, les notes de cours et la documentation statique.

Erreurs courantes

• Utiliser ** et non ^
• Toujours déclarer les symboles avec symbols()
• Utiliser sympy.sin, sympy.exp, etc. (et non les versions NumPy)

Références