- À propos de la factorisation avec SymPy
- Factoriser une expression avec factor()
- Mettre un facteur commun en évidence
- Factoriser les identités remarquables
- Factoriser des polynômes de degré supérieur
- Factoriser des expressions à plusieurs variables
- Factoriser sur différents domaines
- Utiliser factor() avec simplify() et subs()
- Comparer factor() avec expand()
- À retenir !
1. À propos de la factorisation avec SymPy
La bibliothèque SymPy permet de manipuler des expressions algébriques symboliques et fournit plusieurs outils permettant de modifier leur forme. Parmi ces outils, la fonction factor() permet de rechercher une forme factorisée d'une expression.
La factorisation consiste à transformer une somme ou une différence en un produit de facteurs. Par exemple, le polynôme x² + 3x + 2 peut être écrit sous la forme (x + 1)(x + 2).
Le programme suivant utilise factor() pour effectuer automatiquement cette factorisation.
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) |
SymPy détermine les facteurs du polynôme et retourne directement sa forme factorisée.
2. Factoriser une expression avec factor()
La syntaxe de base de factor() consiste à transmettre l'expression que nous souhaitons factoriser. La fonction retourne une nouvelle expression sans modifier l'expression originale.
Le programme suivant factorise le polynôme x² - 5x + 6.
1 2 3 4 5 6 7 | from sympy import symbols, factor x = symbols("x") expression = x**2 - 5*x + 6 resultat = factor(expression) print(resultat) |
Sortie :
1 | (x - 3)*(x - 2) |
En développant le produit obtenu, nous retrouvons bien x² - 5x + 6.
Nous pouvons conserver simultanément l'expression originale et sa forme factorisée.
1 2 3 4 5 6 7 8 | from sympy import symbols, factor x = symbols("x") expression = x**2 + 7*x + 12 factorisee = factor(expression) print("Expression :", expression) print("Factorisation :", factorisee) |
Sortie :
1 2 | Expression : x**2 + 7*x + 12 Factorisation : (x + 3)*(x + 4) |
Comme les expressions SymPy sont immuables, l'appel à factor() ne remplace pas l'expression initiale.
3. Mettre un facteur commun en évidence
La fonction factor() peut détecter un facteur commun présent dans plusieurs termes d'une expression et le mettre automatiquement en évidence.
Dans l'expression suivante, tous les termes contiennent le facteur x.
1 2 3 4 5 6 7 | from sympy import symbols, factor x = symbols("x") expression = x**3 + 3*x**2 + 2*x resultat = factor(expression) print(resultat) |
Sortie :
1 | x*(x + 1)*(x + 2) |
SymPy commence par mettre x en facteur puis poursuit la factorisation du polynôme restant x² + 3x + 2.
La fonction peut également extraire un facteur numérique commun.
1 2 3 4 5 6 7 | from sympy import symbols, factor x = symbols("x") expression = 6*x**2 + 12*x resultat = factor(expression) print(resultat) |
Sortie :
1 | 6*x*(x + 2) |
Le facteur commun 6x est automatiquement mis en évidence.
4. Factoriser les identités remarquables
La fonction factor() reconnaît naturellement de nombreuses identités remarquables. Elle peut par exemple reconnaître un carré parfait ou une différence de deux carrés.
Le programme suivant factorise l'expression x² + 2x + 1.
1 2 3 4 5 6 7 | from sympy import symbols, factor x = symbols("x") expression = x**2 + 2*x + 1 resultat = factor(expression) print(resultat) |
Sortie :
1 | (x + 1)**2 |
SymPy reconnaît l'identité x² + 2x + 1 = (x + 1)².
La différence de deux carrés peut également être factorisée immédiatement.
1 2 3 4 5 6 7 | from sympy import symbols, factor x = symbols("x") expression = x**2 - 9 resultat = factor(expression) print(resultat) |
Sortie :
1 | (x - 3)*(x + 3) |
SymPy utilise ici l'identité a² - b² = (a - b)(a + b).
Le même principe fonctionne avec des expressions symboliques plus générales.
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) |
5. Factoriser des polynômes de degré supérieur
La fonction factor() ne se limite pas aux polynômes du second degré. Elle peut également factoriser des polynômes de degré supérieur lorsque ceux-ci possèdent une factorisation sur le domaine considéré.
Le programme suivant factorise un polynôme du troisième degré.
1 2 3 4 5 6 7 | from sympy import symbols, factor x = symbols("x") expression = x**3 - 6*x**2 + 11*x - 6 resultat = factor(expression) print(resultat) |
Sortie :
1 | (x - 3)*(x - 2)*(x - 1) |
La forme factorisée fait immédiatement apparaître les trois racines 1, 2 et 3 du polynôme.
La fonction peut également factoriser certaines différences de puissances.
1 2 3 4 5 6 7 | from sympy import symbols, factor x = symbols("x") expression = x**4 - 1 resultat = factor(expression) print(resultat) |
Sortie :
1 | (x - 1)*(x + 1)*(x**2 + 1) |
Sur le domaine rationnel utilisé ici, x² + 1 reste irréductible. La factorisation dépend donc également du domaine dans lequel nous travaillons.
6. Factoriser des expressions à plusieurs variables
La fonction factor() peut être utilisée avec des expressions contenant plusieurs variables symboliques. Elle recherche alors les facteurs communs et les structures algébriques permettant une factorisation.
Le programme suivant factorise une expression à deux variables.
1 2 3 4 5 6 7 | from sympy import symbols, factor x, y = symbols("x y") expression = x**2 + 2*x*y + y**2 resultat = factor(expression) print(resultat) |
Sortie :
1 | (x + y)**2 |
SymPy reconnaît le carré parfait x² + 2xy + y² = (x + y)².
Nous pouvons également factoriser une expression comportant un facteur commun constitué de plusieurs variables.
1 2 3 4 5 6 7 | from sympy import symbols, factor x, y = symbols("x y") expression = x**2*y + x*y**2 resultat = factor(expression) print(resultat) |
Sortie :
1 | x*y*(x + y) |
Le facteur commun xy est automatiquement extrait.
La factorisation fonctionne également avec davantage de variables.
1 2 3 4 5 6 7 | from sympy import symbols, factor x, y, z = symbols("x y z") expression = x*y + x*z + y**2 + y*z resultat = factor(expression) print(resultat) |
Sortie :
1 | (x + y)*(y + z) |
7. Factoriser sur différents domaines
Une expression peut être irréductible sur un ensemble de nombres et factorisable sur un autre. La fonction factor() permet donc de préciser certains domaines de factorisation.
Par exemple, le polynôme x² + 1 ne possède pas de racines réelles et reste irréductible sur les rationnels.
1 2 3 4 5 6 7 | from sympy import symbols, factor x = symbols("x") expression = x**2 + 1 resultat = factor(expression) print(resultat) |
Sortie :
1 | x**2 + 1 |
Aucune factorisation supplémentaire n'est effectuée sur le domaine rationnel par défaut.
Si nous demandons une factorisation sur une extension contenant le nombre imaginaire I, le polynôme peut être décomposé en facteurs linéaires.
1 2 3 4 5 6 7 | from sympy import symbols, factor, I x = symbols("x") expression = x**2 + 1 resultat = factor(expression, extension=I) print(resultat) |
Sortie :
1 | (x - I)*(x + I) |
La factorisation dépend donc du domaine algébrique autorisé. Ce point devient particulièrement important dans l'étude des polynômes et de leurs racines.
8. Utiliser factor() avec simplify() et subs()
La fonction factor() peut être combinée avec d'autres fonctions SymPy. Nous pouvons notamment utiliser simplify() pour simplifier une expression avant sa factorisation et subs() pour remplacer une variable après la factorisation.
Le programme suivant simplifie une expression puis la factorise.
1 2 3 4 5 6 7 8 9 | from sympy import symbols, simplify, factor x = symbols("x") expression = (x**3 - x)/x simplifiee = simplify(expression) factorisee = factor(simplifiee) print("Expression simplifiée :", simplifiee) print("Expression factorisée :", factorisee) |
Sortie :
1 2 | Expression simplifiée : x**2 - 1 Expression factorisée : (x - 1)*(x + 1) |
L'expression originale comporte cependant une division par x et n'est donc pas définie pour x = 0. Cette restriction doit être conservée à l'esprit malgré la simplification.
Nous pouvons ensuite utiliser subs() pour remplacer la variable dans l'expression factorisée.
1 2 3 4 5 6 7 8 9 | from sympy import symbols, factor x = symbols("x") expression = x**2 - 5*x + 6 factorisee = factor(expression) resultat = factorisee.subs(x, 4) print(factorisee) print(resultat) |
Sortie :
1 2 | (x - 3)*(x - 2) 2 |
La forme factorisée reste une expression SymPy normale sur laquelle nous pouvons appliquer les autres opérations symboliques.
9. Comparer factor() avec expand()
Les fonctions factor() et expand() réalisent généralement des transformations opposées. factor() transforme une somme en produit lorsque cela est possible, tandis que expand() transforme un produit en somme développée.
Le programme suivant illustre le passage d'une forme développée à une forme factorisée puis le retour à la forme développée.
1 2 3 4 5 6 7 8 9 10 | from sympy import symbols, factor, expand x = symbols("x") expression = x**2 + 5*x + 6 factorisee = factor(expression) developpee = expand(factorisee) print("Expression initiale :", expression) print("Forme factorisée :", factorisee) print("Forme développée :", developpee) |
Sortie :
1 2 3 | Expression initiale : x**2 + 5*x + 6 Forme factorisée : (x + 2)*(x + 3) Forme développée : x**2 + 5*x + 6 |
Ces deux formes sont mathématiquement équivalentes, mais chacune possède ses avantages. La forme développée facilite notamment la lecture des coefficients, tandis que la forme factorisée facilite souvent l'identification des racines.
Le programme suivant montre comment la factorisation permet de faire apparaître immédiatement les zéros d'un polynôme.
1 2 3 4 5 6 7 | from sympy import symbols, factor x = symbols("x") expression = x**3 - 2*x**2 - 5*x + 6 resultat = factor(expression) print(resultat) |
Sortie :
1 | (x - 3)*(x - 1)*(x + 2) |
La forme factorisée permet de lire directement les racines x = 3, x = 1 et x = -2.
10. À retenir !
La fonction factor() de SymPy permet de rechercher automatiquement une forme factorisée d'une expression algébrique. Elle est particulièrement utile pour l'étude des polynômes, la recherche de facteurs communs et la mise en évidence des racines.
- factor(expression) tente de factoriser une expression symbolique.
- La fonction peut mettre automatiquement un facteur commun en évidence.
- Elle reconnaît de nombreuses identités remarquables.
- Elle permet de factoriser des polynômes de degré supérieur lorsque cela est possible.
- factor() fonctionne également avec des expressions contenant plusieurs variables.
- La factorisation dépend du domaine considéré.
- L'option extension permet notamment d'autoriser certaines extensions algébriques.
- La forme factorisée peut faciliter l'identification des racines d'un polynôme.
- factor() peut être combinée avec simplify(), subs() et les autres outils SymPy.
- factor() et expand() réalisent généralement des transformations inverses.
Le programme suivant rassemble les principales utilisations de factor() en factorisant plusieurs expressions algébriques.
1 2 3 4 5 6 7 8 9 10 11 12 | from sympy import symbols, factor, expand x, y = symbols("x y") expression1 = x**2 + 5*x + 6 expression2 = x**2 - y**2 expression3 = x**3 - x print("Expression 1 :", factor(expression1)) print("Expression 2 :", factor(expression2)) print("Expression 3 :", factor(expression3)) print("Vérification :", expand(factor(expression1))) |
Sortie :
1 2 3 4 | Expression 1 : (x + 2)*(x + 3) Expression 2 : (x - y)*(x + y) Expression 3 : x*(x - 1)*(x + 1) Vérification : x**2 + 5*x + 6 |
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/
