- À propos du développement d'expressions avec SymPy
- Développer une expression avec expand()
- Développer un produit de plusieurs facteurs
- Développer les puissances d'une somme
- Développer une expression à plusieurs variables
- Développer seulement certaines parties d'une expression
- Développer les fonctions trigonométriques et complexes
- Utiliser expand() avec subs() et simplify()
- Comparer expand() avec factor()
- À retenir !
1. À propos du développement d'expressions avec SymPy
La bibliothèque SymPy permet de manipuler des expressions algébriques symboliques. Une expression peut être écrite sous une forme factorisée, par exemple (x + 1)(x + 2), ou sous une forme développée, par exemple x² + 3x + 2.
La fonction expand() permet de développer une expression en distribuant les produits, en développant certaines puissances et en appliquant différentes règles algébriques.
Le programme suivant présente un premier exemple de développement.
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() applique la distributivité et transforme l'expression factorisée en une expression polynomiale développée.
2. Développer une expression avec expand()
La syntaxe de base consiste à transmettre une expression SymPy à la fonction expand(). La fonction retourne une nouvelle expression développée sans modifier l'expression originale.
Le programme suivant développe le produit 3(x + 2).
1 2 3 4 5 6 7 | from sympy import symbols, expand x = symbols("x") expression = 3*(x + 2) resultat = expand(expression) print(resultat) |
Sortie :
1 | 3*x + 6 |
Le facteur 3 est distribué sur les deux termes de la parenthèse.
Nous pouvons également développer un produit contenant deux expressions plus générales.
1 2 3 4 5 6 7 | from sympy import symbols, expand x = symbols("x") expression = (2*x + 3)*(x - 4) resultat = expand(expression) print(resultat) |
Sortie :
1 | 2*x**2 - 5*x - 12 |
SymPy effectue automatiquement les multiplications puis regroupe les termes semblables.
3. Développer un produit de plusieurs facteurs
La fonction expand() peut développer une expression contenant plusieurs facteurs. SymPy distribue successivement les produits jusqu'à obtenir la forme développée.
Le programme suivant développe un produit de trois facteurs.
1 2 3 4 5 6 7 | from sympy import symbols, expand x = symbols("x") expression = (x + 1)*(x + 2)*(x + 3) resultat = expand(expression) print(resultat) |
Sortie :
1 | x**3 + 6*x**2 + 11*x + 6 |
SymPy effectue l'ensemble des distributions nécessaires et retourne directement le polynôme développé.
Le développement fonctionne également lorsque certains facteurs contiennent des coefficients.
1 2 3 4 5 6 7 | from sympy import symbols, expand x = symbols("x") expression = (2*x - 1)*(x + 2)*(x - 3) resultat = expand(expression) print(resultat) |
Sortie :
1 | 2*x**3 - 3*x**2 - 11*x + 6 |
4. Développer les puissances d'une somme
La fonction expand() permet également de développer les puissances d'une somme. Elle peut donc être utilisée pour retrouver automatiquement les identités remarquables.
Le programme suivant développe (x + 1)².
1 2 3 4 5 6 7 | from sympy import symbols, expand x = symbols("x") expression = (x + 1)**2 resultat = expand(expression) print(resultat) |
Sortie :
1 | x**2 + 2*x + 1 |
Nous retrouvons l'identité remarquable (a + b)² = a² + 2ab + b².
SymPy peut également développer des puissances plus élevées.
1 2 3 4 5 6 7 | from sympy import symbols, expand x = symbols("x") expression = (x + 2)**4 resultat = expand(expression) print(resultat) |
Sortie :
1 | x**4 + 8*x**3 + 24*x**2 + 32*x + 16 |
La fonction expand() évite ainsi d'effectuer manuellement les nombreux produits nécessaires au développement des puissances élevées.
5. Développer une expression à plusieurs variables
La fonction expand() n'est pas limitée aux expressions contenant une seule variable. Elle peut développer des expressions comportant plusieurs symboles.
Le programme suivant développe le carré de la somme x + y.
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 |
SymPy conserve correctement les produits entre les différentes variables.
Nous pouvons également développer une expression contenant trois symboles.
1 2 3 4 5 6 7 | from sympy import symbols, expand x, y, z = symbols("x y z") expression = (x + y)*(x + z) resultat = expand(expression) print(resultat) |
Sortie :
1 | x**2 + x*y + x*z + y*z |
Cette possibilité est particulièrement utile pour les polynômes à plusieurs variables et les calculs algébriques symboliques.
6. Développer seulement certaines parties d'une expression
La fonction expand() possède plusieurs options permettant de contrôler les types de développements effectués. Parmi elles, les options mul et power_base peuvent être utilisées pour agir plus précisément sur les produits et les puissances.
L'option mul=True demande le développement des multiplications. Il s'agit d'un comportement activé par défaut dans expand().
1 2 3 4 5 6 7 | from sympy import symbols, expand x, y = symbols("x y") expression = (x + 1)*(y + 2) resultat = expand(expression, mul=True) print(resultat) |
Sortie :
1 | x*y + 2*x + y + 2 |
À l'inverse, nous pouvons désactiver le développement des produits avec mul=False.
1 2 3 4 5 6 7 | from sympy import symbols, expand x, y = symbols("x y") expression = (x + 1)*(y + 2) resultat = expand(expression, mul=False) print(resultat) |
Sortie :
1 | (x + 1)*(y + 2) |
Ces options deviennent particulièrement utiles dans des expressions complexes lorsque nous souhaitons contrôler précisément les transformations réalisées par SymPy.
7. Développer les fonctions trigonométriques et complexes
La fonction expand() possède également des options permettant de développer certains types particuliers d'expressions. Pour les expressions trigonométriques, nous pouvons utiliser l'option trig=True.
Le programme suivant développe sin(x + y) à l'aide des formules d'addition trigonométriques.
1 2 3 4 5 6 7 | from sympy import symbols, sin, expand x, y = symbols("x y") expression = sin(x + y) resultat = expand(expression, trig=True) print(resultat) |
Sortie :
1 | sin(x)*cos(y) + sin(y)*cos(x) |
SymPy applique ici la formule sin(x + y) = sin(x)cos(y) + cos(x)sin(y).
L'option complex=True permet quant à elle de développer une expression en faisant apparaître ses parties réelle et imaginaire.
1 2 3 4 5 6 | from sympy import symbols, expand z = symbols("z") resultat = expand(z, complex=True) print(resultat) |
Sortie :
1 | re(z) + I*im(z) |
SymPy représente alors le symbole complexe z sous la forme re(z) + I*im(z).
8. Utiliser expand() avec subs() et simplify()
La fonction expand() peut être combinée avec d'autres outils de SymPy, notamment subs() pour effectuer des substitutions et simplify() pour simplifier une expression.
Le programme suivant développe d'abord une expression puis remplace x par 2.
1 2 3 4 5 6 7 8 9 | from sympy import symbols, expand x = symbols("x") expression = (x + 1)*(x + 3) developpee = expand(expression) resultat = developpee.subs(x, 2) print(developpee) print(resultat) |
Sortie :
1 2 | x**2 + 4*x + 3 15 |
Nous pouvons ainsi transformer une expression symbolique puis l'évaluer pour une valeur particulière.
Le programme suivant utilise successivement expand() et simplify().
1 2 3 4 5 6 7 8 9 | from sympy import symbols, expand, simplify x = symbols("x") expression = (x + 1)*(x - 1)/(x - 1) developpee = expand(expression) resultat = simplify(developpee) print(developpee) print(resultat) |
Sortie :
1 2 | (x**2 - 1)/(x - 1) x + 1 |
Il faut toutefois conserver à l'esprit que l'expression originale n'est pas définie pour x = 1, même si la forme simplifiée x + 1 l'est.
9. Comparer expand() avec factor()
Les fonctions expand() et factor() effectuent généralement des transformations opposées. expand() développe les produits et les puissances, tandis que factor() cherche à écrire une expression sous une forme factorisée.
Le programme suivant développe une expression puis la factorise de nouveau.
1 2 3 4 5 6 7 8 9 10 11 | from sympy import symbols, expand, factor x = symbols("x") expression = (x + 1)*(x + 2) developpee = expand(expression) factorisee = factor(developpee) print("Expression initiale :", expression) print("Forme développée :", developpee) print("Forme factorisée :", factorisee) |
Sortie :
1 2 3 | Expression initiale : (x + 1)*(x + 2) Forme développée : x**2 + 3*x + 2 Forme factorisée : (x + 1)*(x + 2) |
La forme développée est souvent pratique pour identifier les coefficients d'un polynôme, tandis que la forme factorisée peut faciliter l'étude des racines et des facteurs.
Le programme suivant montre le même principe avec un polynôme possédant trois facteurs.
1 2 3 4 5 6 7 8 9 10 | from sympy import symbols, expand, factor x = symbols("x") expression = (x - 1)*(x + 2)*(x + 3) developpee = expand(expression) factorisee = factor(developpee) print(developpee) print(factorisee) |
Sortie :
1 2 | x**3 + 4*x**2 + x - 6 (x - 1)*(x + 2)*(x + 3) |
Le choix entre expand() et factor() dépend donc de la forme de l'expression la plus utile pour le calcul que nous souhaitons effectuer.
10. À retenir !
La fonction expand() de SymPy permet de transformer une expression factorisée ou compacte en une forme développée. Elle constitue un outil fondamental pour manipuler les polynômes et de nombreuses autres expressions symboliques.
- expand(expression) développe une expression symbolique.
- expand() distribue les produits sur les sommes.
- La fonction permet de développer des produits comportant plusieurs facteurs.
- Elle permet de développer les puissances d'une somme comme (x + y)**n.
- Elle fonctionne avec les expressions contenant plusieurs variables.
- L'option mul permet de contrôler le développement des multiplications.
- L'option trig=True permet de développer certaines expressions trigonométriques.
- L'option complex=True permet de développer une expression en termes de parties réelle et imaginaire.
- expand() peut être combinée avec subs(), simplify() et d'autres fonctions SymPy.
- factor() effectue généralement l'opération inverse en recherchant une forme factorisée.
Le programme suivant rassemble les principales utilisations de expand() sur une expression algébrique et une expression trigonométrique.
1 2 3 4 5 6 7 8 9 10 11 12 13 | from sympy import symbols, sin, expand, factor x, y = symbols("x y") expression1 = (x + y)**2 expression2 = sin(x + y) developpee1 = expand(expression1) developpee2 = expand(expression2, trig=True) print("Expression algébrique :", developpee1) print("Expression trigonométrique :", developpee2) print("Factorisation :", factor(developpee1)) |
Sortie :
1 2 3 | Expression algébrique : x**2 + 2*x*y + y**2 Expression trigonométrique : sin(x)*cos(y) + sin(y)*cos(x) Factorisation : (x + 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/
