- À propos du regroupement des termes avec SymPy
- Regrouper les termes avec collect()
- Regrouper suivant les puissances d'une variable
- Regrouper suivant plusieurs variables
- Regrouper suivant une expression
- Utiliser collect() avec expand()
- Récupérer les coefficients avec evaluate=False
- Regrouper des termes contenant des fonctions
- Comparer collect() avec simplify() et factor()
- À retenir !
1. À propos du regroupement des termes avec SymPy
Lors de la manipulation d'une expression algébrique, il est souvent utile de regrouper les termes suivant les puissances d'une variable ou suivant une expression particulière. La bibliothèque SymPy fournit pour cela la fonction collect().
Contrairement à simplify(), qui cherche une forme globalement plus simple, ou à factor(), qui cherche une forme factorisée, collect() organise les termes par rapport à un symbole ou une expression spécifiée.
Le programme suivant regroupe les termes contenant x.
1 2 3 4 5 6 7 | from sympy import symbols, collect x, a, b = symbols("x a b") expression = a*x + b*x + 2 resultat = collect(expression, x) print(resultat) |
Sortie :
1 | x*(a + b) + 2 |
Les termes ax et bx ont été regroupés sous la forme x(a + b), tandis que le terme indépendant 2 reste inchangé.
2. Regrouper les termes avec collect()
La syntaxe de base de collect() est collect(expression, variable). Le premier argument représente l'expression à transformer et le second indique le symbole suivant lequel les termes doivent être regroupés.
Le programme suivant regroupe les termes d'une expression suivant la variable x.
1 2 3 4 5 6 7 | from sympy import symbols, collect x, a, b, c = symbols("x a b c") expression = a*x + b*x + c resultat = collect(expression, x) print(resultat) |
Sortie :
1 | c + x*(a + b) |
La fonction identifie les termes ayant le même facteur x et regroupe leurs coefficients.
Le regroupement peut également être effectué lorsque les coefficients sont eux-mêmes des expressions.
1 2 3 4 5 6 7 | from sympy import symbols, collect x, y, z = symbols("x y z") expression = x*y + x*z + 3 resultat = collect(expression, x) print(resultat) |
Sortie :
1 | x*(y + z) + 3 |
Le coefficient de x est maintenant l'expression y + z.
3. Regrouper suivant les puissances d'une variable
La fonction collect() est particulièrement utile pour organiser une expression suivant les différentes puissances d'une variable. Elle permet par exemple de regrouper séparément les termes en x, x², x³, etc.
Dans le programme suivant, plusieurs termes possèdent les mêmes puissances de x.
1 2 3 4 5 6 7 | from sympy import symbols, collect x, a, b, c, d = symbols("x a b c d") expression = a*x**2 + b*x**2 + c*x + d*x + 5 resultat = collect(expression, x) print(resultat) |
Sortie :
1 | x**2*(a + b) + x*(c + d) + 5 |
Les termes en x² sont regroupés ensemble et les termes en x forment un second groupe.
Cette organisation est particulièrement pratique lorsqu'une expression doit être considérée comme un polynôme en x dont les coefficients peuvent dépendre d'autres paramètres.
1 2 3 4 5 6 7 | from sympy import symbols, collect x, a, b = symbols("x a b") expression = 2*a*x**3 + 3*b*x**2 + a*x**3 - b*x**2 + 4*x resultat = collect(expression, x) print(resultat) |
Sortie :
1 | 3*a*x**3 + 2*b*x**2 + 4*x |
SymPy rassemble automatiquement les coefficients correspondant aux mêmes puissances de x.
4. Regrouper suivant plusieurs variables
La fonction collect() peut recevoir une liste de symboles afin d'effectuer un regroupement suivant plusieurs variables. Cette possibilité est utile pour les expressions comportant plusieurs paramètres.
Le programme suivant regroupe les termes suivant x et y.
1 2 3 4 5 6 7 | from sympy import symbols, collect x, y, a, b, c, d = symbols("x y a b c d") expression = a*x + b*x + c*y + d*y resultat = collect(expression, [x, y]) print(resultat) |
Sortie :
1 | x*(a + b) + y*(c + d) |
Les termes contenant x sont regroupés d'un côté et ceux contenant y de l'autre.
Nous pouvons appliquer le même principe à une expression contenant des puissances de plusieurs variables.
1 2 3 4 5 6 7 | from sympy import symbols, collect x, y, a, b, c, d = symbols("x y a b c d") expression = a*x**2 + b*x**2 + c*y**2 + d*y**2 resultat = collect(expression, [x, y]) print(resultat) |
Sortie :
1 | x**2*(a + b) + y**2*(c + d) |
Cette forme facilite la lecture de la structure algébrique de l'expression.
5. Regrouper suivant une expression
Le second argument de collect() ne doit pas nécessairement être une simple variable. Il peut également être une expression symbolique que SymPy recherchera dans les différents termes.
Le programme suivant regroupe les termes suivant l'expression x + y.
1 2 3 4 5 6 7 | from sympy import symbols, collect x, y, a, b = symbols("x y a b") expression = a*(x + y) + b*(x + y) + 3 resultat = collect(expression, x + y) print(resultat) |
Sortie :
1 | (a + b)*(x + y) + 3 |
Les deux termes contenant le facteur x + y sont regroupés sous un même coefficient.
Nous pouvons également regrouper suivant une puissance particulière.
1 2 3 4 5 6 7 | from sympy import symbols, collect x, a, b, c = symbols("x a b c") expression = a*x**2 + b*x**2 + c*x + 1 resultat = collect(expression, x**2) print(resultat) |
Sortie :
1 | c*x + x**2*(a + b) + 1 |
Seuls les termes correspondant au motif x² sont explicitement regroupés.
6. Utiliser collect() avec expand()
La fonction collect() travaille sur la structure actuelle de l'expression. Lorsqu'une expression contient des produits ou des parenthèses, il peut être utile de commencer par utiliser expand() afin de faire apparaître les différents termes avant de les regrouper.
Le programme suivant développe d'abord une expression puis regroupe le résultat suivant x.
1 2 3 4 5 6 7 8 9 | from sympy import symbols, expand, collect x, y, a, b = symbols("x y a b") expression = (a + x)*(b + y) developpee = expand(expression) resultat = collect(developpee, x) print("Forme développée :", developpee) print("Regroupement suivant x :", resultat) |
Sortie :
1 2 | Forme développée : a*b + a*y + b*x + x*y Regroupement suivant x : a*b + a*y + x*(b + y) |
Après le développement, les termes bx et xy peuvent être regroupés sous la forme x(b + y).
Nous pouvons également regrouper successivement une expression développée suivant plusieurs symboles.
1 2 3 4 5 6 7 8 9 | from sympy import symbols, expand, collect x, y, a, b = symbols("x y a b") expression = (x + y)*(a + b) developpee = expand(expression) resultat = collect(developpee, [x, y]) print(developpee) print(resultat) |
Sortie :
1 2 | a*x + a*y + b*x + b*y x*(a + b) + y*(a + b) |
L'association de expand() et collect() permet donc de réorganiser efficacement de nombreuses expressions algébriques.
7. Récupérer les coefficients avec evaluate=False
La fonction collect() possède l'option evaluate=False. Au lieu de reconstruire directement l'expression regroupée, cette option retourne un dictionnaire associant les puissances ou motifs collectés à leurs coefficients.
Le programme suivant utilise cette option pour analyser les coefficients d'un polynôme suivant x.
1 2 3 4 5 6 7 | from sympy import symbols, collect x, a, b, c = symbols("x a b c") expression = a*x**2 + b*x + c resultat = collect(expression, x, evaluate=False) print(resultat) |
Sortie :
1 | {x**2: a, x: b, 1: c} |
La clé x**2 correspond au coefficient a, la clé x au coefficient b et la clé 1 représente la partie indépendante c.
Cette forme permet ensuite d'accéder directement à un coefficient particulier.
1 2 3 4 5 6 7 8 9 | from sympy import symbols, collect x, a, b, c = symbols("x a b c") expression = a*x**2 + b*x + c resultat = collect(expression, x, evaluate=False) print("Coefficient de x² :", resultat[x**2]) print("Coefficient de x :", resultat[x]) print("Terme indépendant :", resultat[1]) |
Sortie :
1 2 3 | Coefficient de x² : a Coefficient de x : b Terme indépendant : c |
L'option evaluate=False est donc particulièrement utile lorsque nous souhaitons analyser programmatiquement la structure d'une expression.
8. Regrouper des termes contenant des fonctions
La fonction collect() peut également regrouper des termes suivant certaines expressions fonctionnelles. Le motif recherché peut par exemple être une fonction trigonométrique.
Le programme suivant regroupe les termes contenant sin(x).
1 2 3 4 5 6 7 | from sympy import symbols, sin, collect x, a, b = symbols("x a b") expression = a*sin(x) + b*sin(x) + 2 resultat = collect(expression, sin(x)) print(resultat) |
Sortie :
1 | (a + b)*sin(x) + 2 |
La fonction sin(x) est ici traitée comme le motif suivant lequel les coefficients doivent être regroupés.
Le même principe peut être utilisé avec une fonction exponentielle.
1 2 3 4 5 6 7 | from sympy import symbols, exp, collect x, a, b, c = symbols("x a b c") expression = a*exp(x) + b*exp(x) + c resultat = collect(expression, exp(x)) print(resultat) |
Sortie :
1 | c + (a + b)*exp(x) |
Cette possibilité rend collect() utile bien au-delà des seuls polynômes.
9. Comparer collect() avec simplify() et factor()
Les fonctions collect(), simplify() et factor() peuvent toutes modifier la présentation d'une expression, mais elles répondent à des objectifs différents. collect() regroupe les termes suivant un motif donné, simplify() recherche une forme globalement plus simple et factor() cherche une factorisation.
Le programme suivant applique ces différentes fonctions à une même expression.
1 2 3 4 5 6 7 8 9 | from sympy import symbols, collect, simplify, factor x, a, b = symbols("x a b") expression = a*x + b*x + a + b print("Expression :", expression) print("collect() :", collect(expression, x)) print("simplify() :", simplify(expression)) print("factor() :", factor(expression)) |
Sortie :
1 2 3 4 | Expression : a*x + a + b*x + b collect() : a + b + x*(a + b) simplify() : a + b + x*(a + b) factor() : (a + b)*(x + 1) |
La fonction collect() met en évidence le coefficient de x, tandis que factor() recherche un facteur commun à l'ensemble de l'expression.
Si notre objectif est précisément d'organiser un polynôme suivant une variable donnée, collect() est généralement plus appropriée qu'une simplification générale.
10. À retenir !
La fonction collect() de SymPy permet de regrouper les termes d'une expression suivant une variable, une puissance ou une expression particulière. Elle est particulièrement utile pour organiser les polynômes et faire apparaître clairement leurs coefficients.
- collect(expression, x) regroupe les termes suivant le symbole x.
- La fonction peut regrouper les différentes puissances d'une variable.
- Une liste comme [x, y] permet d'effectuer un regroupement suivant plusieurs symboles.
- Le motif utilisé par collect() peut être une expression et pas seulement une variable.
- collect() peut être associée à expand() pour regrouper une expression après son développement.
- L'option evaluate=False permet d'obtenir les groupes et leurs coefficients sous forme de dictionnaire.
- La clé 1 du dictionnaire retourné représente les termes indépendants du motif collecté.
- La fonction peut également regrouper des termes contenant des fonctions comme sin(x) ou exp(x).
- collect() organise une expression alors que factor() recherche une factorisation.
- Pour l'étude d'un polynôme suivant une variable particulière, collect() permet de faire apparaître clairement sa structure.
Le programme suivant rassemble plusieurs utilisations importantes de collect() en regroupant une expression suivant différentes puissances de x puis en récupérant ses coefficients.
1 2 3 4 5 6 7 8 9 10 11 12 | from sympy import symbols, collect x, a, b, c, d = symbols("x a b c d") expression = a*x**2 + b*x**2 + c*x + d*x + 5 regroupee = collect(expression, x) coefficients = collect(expression, x, evaluate=False) print("Expression regroupée :", regroupee) print("Coefficient de x² :", coefficients[x**2]) print("Coefficient de x :", coefficients[x]) print("Terme indépendant :", coefficients[1]) |
Sortie :
1 2 3 4 | Expression regroupée : x**2*(a + b) + x*(c + d) + 5 Coefficient de x² : a + b Coefficient de x : c + d Terme indépendant : 5 |
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/
