- À propos des expressions mathématiques avec SymPy
- Créer une expression mathématique
- Effectuer des opérations sur les expressions
- Développer une expression avec expand()
- Factoriser une expression avec factor()
- Simplifier une expression avec simplify()
- Remplacer les variables avec subs()
- Obtenir les éléments d'une expression
- Transformer et évaluer une expression
- À retenir !
1. À propos des expressions mathématiques avec SymPy
La bibliothèque SymPy permet de créer et de manipuler des expressions mathématiques symboliques avec Python. Une expression symbolique peut contenir des nombres, des variables, des puissances, des fractions et des fonctions mathématiques.
Contrairement à une expression purement numérique, une expression symbolique peut être conservée sous une forme algébrique afin d'être ensuite développée, factorisée, simplifiée, évaluée ou transformée.
Le programme suivant crée la variable symbolique x, puis construit l'expression mathématique x² + 3x + 2.
1 2 3 4 5 | from sympy import symbols x = symbols("x") expression = x**2 + 3*x + 2 print(expression) |
Sortie :
1 | x**2 + 3*x + 2 |
SymPy ne cherche pas ici une valeur particulière de x. Il conserve l'expression sous une forme symbolique afin de pouvoir la manipuler mathématiquement.
2. Créer une expression mathématique
Pour créer une expression symbolique, nous commençons généralement par créer les variables nécessaires avec Symbol ou symbols(). Nous pouvons ensuite utiliser les opérateurs Python habituels pour construire l'expression.
Le programme suivant crée deux variables symboliques x et y, puis construit l'expression x² + 2xy + y².
1 2 3 4 5 | from sympy import symbols x, y = symbols("x y") expression = x**2 + 2*x*y + y**2 print(expression) |
Sortie :
1 | x**2 + 2*x*y + y**2 |
Les principaux opérateurs Python peuvent être utilisés pour construire des expressions SymPy :
- + pour l'addition ;
- - pour la soustraction ;
- * pour la multiplication ;
- / pour la division ;
- ** pour les puissances.
Le programme suivant construit une expression contenant une fraction et une puissance.
1 2 3 4 5 | from sympy import symbols x, y = symbols("x y") expression = x**3 + y/2 - 5*x print(expression) |
Sortie :
1 | x**3 - 5*x + y/2 |
SymPy peut modifier l'ordre d'affichage des termes afin d'utiliser sa représentation canonique de l'expression.
3. Effectuer des opérations sur les expressions
Les expressions SymPy peuvent être combinées entre elles avec les opérateurs arithmétiques habituels. Le résultat obtenu est une nouvelle expression symbolique.
Le programme suivant crée deux expressions puis calcule leur somme.
1 2 3 4 5 6 7 8 | from sympy import symbols x = symbols("x") A = x**2 + 2*x B = 3*x + 5 C = A + B print(C) |
Sortie :
1 | x**2 + 5*x + 5 |
SymPy regroupe automatiquement ici les termes semblables 2*x et 3*x.
Nous pouvons également multiplier deux expressions.
1 2 3 4 5 6 7 8 | from sympy import symbols x = symbols("x") A = x + 1 B = x + 2 C = A*B print(C) |
Sortie :
1 | (x + 1)*(x + 2) |
Une différence importante apparaît ici : SymPy conserve le produit sous sa forme factorisée. Une multiplication symbolique n'entraîne donc pas nécessairement le développement automatique de l'expression.
4. Développer une expression avec expand()
La fonction expand() permet de développer une expression en effectuant notamment les produits et les puissances lorsque cela est approprié.
Le programme suivant développe le produit (x + 1)(x + 2).
1 2 3 4 5 6 7 | from sympy import symbols, expand x = symbols("x") expression = (x + 1)*(x + 2) resultat = expand(expression) print(resultat) |
Sortie :
1 | x**2 + 3*x + 2 |
La fonction expand() retourne une nouvelle expression développée.
Elle peut également développer des expressions contenant plusieurs variables.
1 2 3 4 5 6 7 | from sympy import symbols, expand x, y = symbols("x y") expression = (x + y)**2 resultat = expand(expression) print(resultat) |
Sortie :
1 | x**2 + 2*x*y + y**2 |
L'expression initiale (x + y)**2 est ainsi transformée en sa forme développée.
5. Factoriser une expression avec factor()
La fonction factor() réalise l'opération inverse dans de nombreux cas : elle cherche une factorisation de l'expression dans le domaine utilisé par SymPy.
Le programme suivant factorise le polynôme x² + 3x + 2.
1 2 3 4 5 6 7 | from sympy import symbols, factor x = symbols("x") expression = x**2 + 3*x + 2 resultat = factor(expression) print(resultat) |
Sortie :
1 | (x + 1)*(x + 2) |
Nous pouvons également factoriser des expressions contenant plusieurs variables.
1 2 3 4 5 6 7 | from sympy import symbols, factor x, y = symbols("x y") expression = x**2 - y**2 resultat = factor(expression) print(resultat) |
Sortie :
1 | (x - y)*(x + y) |
SymPy reconnaît ici l'identité remarquable x² - y² = (x - y)(x + y).
6. Simplifier une expression avec simplify()
La fonction simplify() tente de transformer une expression en une forme considérée comme plus simple par les stratégies générales de SymPy. Contrairement à expand() ou factor(), le résultat recherché n'est pas limité à une transformation algébrique unique.
Le programme suivant simplifie une fraction algébrique.
1 2 3 4 5 6 7 | from sympy import symbols, simplify x = symbols("x") expression = (x**2 - 1)/(x - 1) resultat = simplify(expression) print(resultat) |
Sortie :
1 | x + 1 |
Cette simplification algébrique correspond à la réduction de (x - 1)(x + 1)/(x - 1). Il faut toutefois garder à l'esprit que l'expression originale n'est pas définie pour x = 1, tandis que l'expression simplifiée x + 1 l'est.
La fonction simplify() peut également traiter certaines expressions trigonométriques.
1 2 3 4 5 6 7 | from sympy import symbols, sin, cos, simplify x = symbols("x") expression = sin(x)**2 + cos(x)**2 resultat = simplify(expression) print(resultat) |
Sortie :
1 | 1 |
SymPy reconnaît ici l'identité trigonométrique sin²(x) + cos²(x) = 1.
7. Remplacer les variables avec subs()
La méthode subs() permet d'effectuer une substitution dans une expression. Nous pouvons remplacer une variable symbolique par une valeur, par un autre symbole ou par une autre expression.
Le programme suivant remplace x par 2 dans l'expression x² + 3x + 2.
1 2 3 4 5 6 7 | from sympy import symbols x = symbols("x") expression = x**2 + 3*x + 2 resultat = expression.subs(x, 2) print(resultat) |
Sortie :
1 | 12 |
Nous pouvons également effectuer plusieurs substitutions à l'aide d'un dictionnaire.
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 |
La méthode subs() ne modifie pas l'expression originale. Elle retourne une nouvelle expression contenant les substitutions demandées.
8. Obtenir les éléments d'une expression
Une expression SymPy possède une structure interne que nous pouvons examiner. L'attribut free_symbols permet notamment d'obtenir l'ensemble des symboles libres présents dans une expression.
Le programme suivant recherche les variables symboliques utilisées dans une expression.
1 2 3 4 5 6 | from sympy import symbols x, y, z = symbols("x y z") expression = x**2 + 2*x*y + z print(expression.free_symbols) |
Sortie possible :
1 | {x, y, z} |
L'ordre d'affichage d'un ensemble n'est pas garanti. Les symboles peuvent donc apparaître dans un ordre différent.
L'attribut args permet quant à lui d'accéder aux arguments immédiats qui composent une expression.
1 2 3 4 5 6 | from sympy import symbols x, y = symbols("x y") expression = x**2 + 3*x + y print(expression.args) |
Sortie possible :
1 | (y, x**2, 3*x) |
L'ordre interne des arguments est déterminé par SymPy et ne doit pas nécessairement être assimilé à l'ordre dans lequel les termes ont été saisis.
Nous pouvons également utiliser la méthode has() pour savoir si une expression contient un objet donné.
1 2 3 4 5 6 7 | from sympy import symbols x, y, z = symbols("x y z") expression = x**2 + 3*y print(expression.has(x)) print(expression.has(z)) |
Sortie :
1 2 | True False |
9. Transformer et évaluer une expression
Une expression symbolique peut être transformée puis évaluée numériquement. La méthode evalf() permet d'obtenir une approximation numérique d'une expression SymPy.
Le programme suivant calcule une approximation décimale de √2.
1 2 3 4 5 6 | from sympy import sqrt expression = sqrt(2) print(expression) print(expression.evalf()) |
Sortie possible :
1 2 | sqrt(2) 1.41421356237310 |
SymPy conserve d'abord sqrt(2) sous sa forme exacte. L'appel à evalf() produit ensuite une approximation numérique.
Nous pouvons demander davantage de chiffres significatifs en passant le nombre souhaité à evalf().
1 2 3 | from sympy import pi print(pi.evalf(30)) |
Sortie :
1 | 3.14159265358979323846264338328 |
Nous pouvons enfin combiner plusieurs transformations. Le programme suivant développe une expression, remplace x par 2 puis affiche le résultat.
1 2 3 4 5 6 7 8 9 10 11 | from sympy import symbols, expand x = symbols("x") expression = (x + 1)**3 developpee = expand(expression) resultat = developpee.subs(x, 2) print("Expression :", expression) print("Développée :", developpee) print("Pour x = 2 :", resultat) |
Sortie :
1 2 3 | Expression : (x + 1)**3 Développée : x**3 + 3*x**2 + 3*x + 1 Pour x = 2 : 27 |
10. À retenir !
SymPy permet de créer des expressions mathématiques symboliques et de les manipuler directement avec Python. Les expressions obtenues restent des objets mathématiques que SymPy peut transformer sans leur attribuer nécessairement de valeurs numériques.
- symbols() permet de créer les variables utilisées dans une expression.
- Les opérateurs +, -, *, / et ** permettent de construire des expressions.
- SymPy effectue automatiquement certaines simplifications élémentaires comme le regroupement de termes semblables.
- expand() permet de développer une expression.
- factor() permet de factoriser une expression.
- simplify() tente d'obtenir une forme plus simple d'une expression.
- subs() permet de remplacer des symboles par des valeurs ou d'autres expressions.
- free_symbols permet de connaître les symboles libres présents dans une expression.
- args permet d'examiner les arguments immédiats constituant une expression.
- evalf() permet d'obtenir une approximation numérique d'une expression exacte.
Le programme suivant rassemble plusieurs opérations importantes : création d'une expression, développement, factorisation, substitution et évaluation numérique.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 | from sympy import symbols, expand, factor x = symbols("x") expression = (x + 1)*(x + 2) developpee = expand(expression) factorisee = factor(developpee) valeur = expression.subs(x, 3) print("Expression :", expression) print("Développée :", developpee) print("Factorisée :", factorisee) print("Pour x = 3 :", valeur) print("Valeur numérique :", valeur.evalf()) |
Sortie :
1 2 3 4 5 | Expression : (x + 1)*(x + 2) Développée : x**2 + 3*x + 2 Factorisée : (x + 1)*(x + 2) Pour x = 3 : 20 Valeur numérique : 20.0000000000000 |
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/
