- À propos de la méthode subs() en SymPy
- Remplacer une variable par une valeur
- Remplacer plusieurs variables
- Remplacer un symbole par un autre symbole
- Remplacer une expression par une autre expression
- Effectuer plusieurs substitutions successives
- Évaluer numériquement une expression après substitution
- Utiliser subs() avec des fonctions mathématiques
- Comprendre que subs() ne modifie pas l'expression originale
- À retenir !
1. À propos de la méthode subs() en SymPy
La bibliothèque SymPy permet de construire et de manipuler des expressions mathématiques symboliques. Lorsqu'une expression contient une ou plusieurs variables, il est souvent nécessaire de remplacer ces variables par des valeurs, d'autres symboles ou même d'autres expressions.
La méthode subs(), abréviation de substitution, permet d'effectuer ces remplacements. Sa forme la plus simple est expression.subs(ancien, nouveau).
Le programme suivant crée l'expression x² + 3x + 2 puis remplace x par la valeur 2.
1 2 3 4 5 6 7 8 | from sympy import symbols x = symbols("x") expression = x**2 + 3*x + 2 resultat = expression.subs(x, 2) print(expression) print(resultat) |
Sortie :
1 2 | x**2 + 3*x + 2 12 |
SymPy remplace toutes les occurrences de x par 2 puis effectue automatiquement les calculs possibles.
2. Remplacer une variable par une valeur
L'utilisation la plus courante de subs() consiste à remplacer une variable symbolique par une valeur numérique. Cela permet notamment d'évaluer une expression pour une valeur particulière de la variable.
Le programme suivant calcule la valeur de l'expression x² - 5x + 6 pour x = 4.
1 2 3 4 5 6 7 | from sympy import symbols x = symbols("x") expression = x**2 - 5*x + 6 resultat = expression.subs(x, 4) print(resultat) |
Sortie :
1 | 2 |
Le calcul effectué correspond à 4² - 5 × 4 + 6 = 2.
Nous pouvons utiliser la même expression pour plusieurs valeurs de x en effectuant différentes substitutions.
1 2 3 4 5 6 7 8 | from sympy import symbols x = symbols("x") expression = x**2 + 1 print(expression.subs(x, 0)) print(expression.subs(x, 2)) print(expression.subs(x, 5)) |
Sortie :
1 2 3 | 1 5 26 |
La même expression symbolique peut ainsi être réutilisée autant de fois que nécessaire.
3. Remplacer plusieurs variables
Lorsqu'une expression contient plusieurs symboles, subs() permet d'effectuer plusieurs substitutions. Une méthode pratique consiste à fournir un dictionnaire contenant les symboles et leurs valeurs de remplacement.
Le programme suivant remplace simultanément x par 2 et y par 3.
1 2 3 4 5 6 7 | from sympy import symbols x, y = symbols("x y") expression = x**2 + 2*x*y + y**2 resultat = expression.subs({x: 2, y: 3}) print(resultat) |
Sortie :
1 | 25 |
SymPy effectue les substitutions puis calcule 2² + 2 × 2 × 3 + 3² = 25.
Il est également possible de fournir une liste de couples (ancien, nouveau). Cette forme est notamment utile lorsque l'ordre des substitutions doit être explicitement contrôlé.
1 2 3 4 5 6 7 | from sympy import symbols x, y = symbols("x y") expression = x + 2*y resultat = expression.subs([(x, 3), (y, 4)]) print(resultat) |
Sortie :
1 | 11 |
4. Remplacer un symbole par un autre symbole
La méthode subs() ne sert pas uniquement à remplacer un symbole par une valeur numérique. Elle peut également remplacer une variable symbolique par une autre.
Le programme suivant remplace x par y dans une expression.
1 2 3 4 5 6 7 | from sympy import symbols x, y = symbols("x y") expression = x**2 + 3*x + 1 resultat = expression.subs(x, y) print(resultat) |
Sortie :
1 | y**2 + 3*y + 1 |
La structure de l'expression est conservée, mais toutes les occurrences du symbole x ont été remplacées par y.
Nous pouvons également remplacer un symbole par une expression contenant un autre symbole.
1 2 3 4 5 6 7 | from sympy import symbols x, t = symbols("x t") expression = x**2 + 1 resultat = expression.subs(x, t + 1) print(resultat) |
Sortie :
1 | (t + 1)**2 + 1 |
5. Remplacer une expression par une autre expression
La méthode subs() peut également rechercher une sous-expression et la remplacer par une autre expression.
Le programme suivant remplace directement x + y par le symbole z.
1 2 3 4 5 6 7 | from sympy import symbols x, y, z = symbols("x y z") expression = (x + y)**2 + 3*(x + y) resultat = expression.subs(x + y, z) print(resultat) |
Sortie :
1 | z**2 + 3*z |
Cette possibilité est particulièrement intéressante pour effectuer des changements de variables ou simplifier la présentation de certaines expressions complexes.
Nous pouvons également remplacer une puissance particulière par un autre symbole.
1 2 3 4 5 6 7 | from sympy import symbols x, a = symbols("x a") expression = x**4 + 3*x**2 + 1 resultat = expression.subs(x**2, a) print(resultat) |
Sortie :
1 | a**2 + 3*a + 1 |
SymPy reconnaît ici que x**4 correspond à (x**2)**2 et peut donc effectuer la substitution dans cette structure algébrique.
6. Effectuer plusieurs substitutions successives
Il est possible d'enchaîner plusieurs appels à subs(). Chaque appel retourne une nouvelle expression sur laquelle la substitution suivante peut être appliquée.
Le programme suivant remplace d'abord x par y + 1, puis y par 2.
1 2 3 4 5 6 7 | from sympy import symbols x, y = symbols("x y") expression = x**2 + y resultat = expression.subs(x, y + 1).subs(y, 2) print(resultat) |
Sortie :
1 | 11 |
Après la première substitution, l'expression devient (y + 1)² + y. Après la seconde, elle devient 3² + 2 = 11.
L'ordre des substitutions peut avoir une importance. Le programme suivant montre que deux substitutions effectuées dans des ordres différents peuvent produire des résultats différents.
1 2 3 4 5 6 7 8 9 10 | from sympy import symbols x, y = symbols("x y") expression = x + y resultat1 = expression.subs(x, y).subs(y, 2) resultat2 = expression.subs(y, 2).subs(x, y) print(resultat1) print(resultat2) |
Sortie :
1 2 | 4 y + 2 |
Dans le premier cas, x devient d'abord y, puis toutes les occurrences de y sont remplacées par 2. Dans le second cas, y est d'abord remplacé par 2, puis x devient le symbole y.
7. Évaluer numériquement une expression après substitution
Après une substitution, le résultat peut rester une expression exacte. La méthode evalf() permet alors d'obtenir une approximation numérique.
Le programme suivant remplace x par 2 dans l'expression πx² puis calcule sa valeur décimale.
1 2 3 4 5 6 7 8 | from sympy import symbols, pi x = symbols("x") expression = pi*x**2 resultat = expression.subs(x, 2) print(resultat) print(resultat.evalf()) |
Sortie :
1 2 | 4*pi 12.5663706143592 |
Le premier résultat est exact, tandis que le second est une approximation décimale.
Nous pouvons également demander directement une précision plus importante avec evalf().
1 2 3 4 5 6 7 | from sympy import symbols, pi r = symbols("r") aire = pi*r**2 resultat = aire.subs(r, 3) print(resultat.evalf(30)) |
Sortie :
1 | 28.2743338823081391461637904495 |
Il est généralement préférable de conserver les expressions sous leur forme exacte pendant les calculs et de demander l'approximation numérique seulement à la fin.
8. Utiliser subs() avec des fonctions mathématiques
La méthode subs() fonctionne également avec les expressions contenant des fonctions mathématiques comme sin(), cos(), exp() ou log().
Le programme suivant remplace x par π/2 dans la fonction sinus.
1 2 3 4 5 6 7 | from sympy import symbols, sin, pi x = symbols("x") expression = sin(x) resultat = expression.subs(x, pi/2) print(resultat) |
Sortie :
1 | 1 |
SymPy connaît la valeur exacte de sin(π/2) et retourne donc directement 1.
Le même principe peut être appliqué à une expression exponentielle.
1 2 3 4 5 6 7 | from sympy import symbols, exp x = symbols("x") expression = exp(2*x) resultat = expression.subs(x, 0) print(resultat) |
Sortie :
1 | 1 |
Nous pouvons ainsi construire une fonction symbolique une seule fois puis utiliser subs() pour étudier sa valeur en différents points.
9. Comprendre que subs() ne modifie pas l'expression originale
Les expressions SymPy sont immuables. La méthode subs() ne modifie donc pas directement l'expression sur laquelle elle est appelée. Elle retourne une nouvelle expression.
Le programme suivant permet de constater ce comportement.
1 2 3 4 5 6 7 8 | from sympy import symbols x = symbols("x") expression = x**2 + 3*x + 2 resultat = expression.subs(x, 5) print("Expression originale :", expression) print("Nouvelle expression :", resultat) |
Sortie :
1 2 | Expression originale : x**2 + 3*x + 2 Nouvelle expression : 42 |
L'expression x**2 + 3*x + 2 reste donc disponible et peut être réutilisée pour effectuer d'autres substitutions.
Le programme suivant réutilise la même expression pour calculer plusieurs valeurs.
1 2 3 4 5 6 7 | from sympy import symbols x = symbols("x") expression = x**2 + 3*x + 2 for valeur in range(4): print(valeur, "->", expression.subs(x, valeur)) |
Sortie :
1 2 3 4 | 0 -> 2 1 -> 6 2 -> 12 3 -> 20 |
Cette propriété permet de définir une expression symbolique une seule fois puis de l'exploiter dans différents calculs sans perdre sa forme originale.
10. À retenir !
La méthode subs() est l'un des outils fondamentaux de SymPy pour effectuer des substitutions symboliques dans les expressions mathématiques.
- expression.subs(x, valeur) remplace le symbole x par une valeur.
- subs() peut remplacer un symbole par un autre symbole.
- Un symbole peut également être remplacé par une expression complète.
- Une sous-expression peut être remplacée par une autre expression.
- Un dictionnaire permet de fournir plusieurs substitutions.
- Une liste de couples permet notamment de contrôler explicitement l'ordre des substitutions.
- Plusieurs appels à subs() peuvent être enchaînés.
- L'ordre de substitutions successives peut modifier le résultat.
- evalf() permet d'obtenir une approximation numérique après substitution.
- subs() ne modifie pas l'expression originale : elle retourne une nouvelle expression.
Le programme suivant rassemble les principales utilisations de subs() en créant une expression à deux variables puis en effectuant différents types de substitutions.
1 2 3 4 5 6 7 8 9 10 11 | from sympy import symbols x, y, t = symbols("x y t") expression = x**2 + 2*x*y + y**2 print("Expression :", expression) print("x = 2 :", expression.subs(x, 2)) print("x = 2 et y = 3 :", expression.subs({x: 2, y: 3})) print("x remplacé par t :", expression.subs(x, t)) print("x remplacé par t + 1 :", expression.subs(x, t + 1)) print("Expression originale :", expression) |
Sortie :
1 2 3 4 5 6 | Expression : x**2 + 2*x*y + y**2 x = 2 : y**2 + 4*y + 4 x = 2 et y = 3 : 25 x remplacé par t : t**2 + 2*t*y + y**2 x remplacé par t + 1 : y**2 + 2*y*(t + 1) + (t + 1)**2 Expression originale : x**2 + 2*x*y + y**2 |
Auteur : Younes Derfoufi
Lieu de travail : CRMEF OUJDA
Site Web : www.tresfacile.net
Chaine YouTube : https://www.youtube.com/user/InformatiquesFacile
Me contacter : https://www.tresfacile.net/me-contacter/
