Prise en main de SymPy

SymPy représente symboliquement les expressions mathématiques. Les opérations peuvent ainsi préserver leur structure exacte au lieu de produire immédiatement des approximations flottantes.

from sympy import diff, integrate, simplify, solve, symbols

x = symbols("x", real=True)
expression = (x + 1) ** 2

expanded_derivative = diff(expression, x)
antiderivative = integrate(expression, x)
roots = solve(expression - 4, x)
identity = simplify((x**2 - 1) / (x - 1))

Règles de travail

• Créez les symboles explicitement et n'ajoutez des hypothèses comme real=True que si elles sont justifiées.
• Utilisez Eq(left, right) lorsque la distinction entre équation et expression importe.
• Traitez le résultat de solve() comme des données structurées ; sa forme dépend du problème et des symboles demandés.
• Préférez une transformation précise telle que factor(), expand() ou cancel() lorsque la forme voulue est connue. La fonction générale simplify() est heuristique et ne garantit pas une forme canonique unique.

Commencez par le tutoriel d'introduction officiel, puis consultez la documentation du module pertinent pour les hypothèses ou solveurs avancés.

Entrées exactes et expressions immuables

Cette introduction couvre l’algèbre symbolique scalaire, le calcul élémentaire et les équations à une inconnue avec SymPy 1.x. Elle suppose les expressions Python et le sens mathématique de l’opération demandée. Les pièges du tutoriel commencent par les entrées : Python calcule 1/3 avant SymPy ; utilisez donc Rational(1, 3) pour une fraction exacte. Rational("0.1") représente un dixième ; un flottant binaire ne permet pas de retrouver rétroactivement l’intention décimale.

from sympy import Eq, Rational, S, expand, lambdify, solveset, sqrt

third = Rational(1, 3)
assert 3 * third == 1
assert expanded_derivative == 2*x + 2
assert antiderivative == x**3/3 + x**2 + x
assert roots == [-3, 1]
assert identity == x + 1

value = expression.subs(x, third)
assert value == Rational(16, 9)
print(value.evalf(6))  # 1.77778
assert expression == (x + 1)**2

Les expressions sont immuables : subs, dérivation et transformations renvoient de nouvelles expressions sans modifier expression. integrate renvoie une primitive sans constante d’intégration arbitraire ; ajoutez-la pour écrire l’intégrale indéfinie générale. Ici, integrate(expression, (x, 0, 1)) donne exactement 7/3. Réservez evalf aux approximations numériques ; davantage de chiffres ne répare pas une entrée déjà arrondie en flottant Python.

Égalité, hypothèses et domaine

== teste l’égalité structurelle, pas l’équivalence mathématique générale. expand((x + 1)**2) == (x + 1)**2 est faux alors que leur différence se simplifie en zéro. Utilisez Eq pour construire une équation ; elle peut s’évaluer immédiatement si l’égalité est décidable. Une expression transmise à un solveur signifie qu’elle vaut zéro.

Puisque x est réel, sqrt(x**2) donne Abs(x), pas x. Pour p = symbols("p", positive=True), sqrt(p**2) se simplifie en p. Les hypothèses autorisent uniquement les transformations valables sous ces conditions ; un symbole sans contrainte est généralement complexe.

Une simplification peut masquer le domaine : (x**2 - 1)/(x - 1) est indéfini en 1, contrairement à x + 1. Conservez l’exclusion initiale x != 1 pour les interpréter comme la même fonction. Vérifiez les racines candidates dans l’équation originale, pas seulement dans un numérateur transformé.

real_roots = solveset(Eq(x**2, 2), x, domain=S.Reals)
assert real_roots == {-sqrt(2), sqrt(2)}
assert solveset(x**2 + 1, x, domain=S.Reals) == S.EmptySet
assert solveset(x**2 + 1, x, domain=S.Complexes) == {-S.ImaginaryUnit, S.ImaginaryUnit}

solveset renvoie un ensemble et accepte un domaine explicite ; ne supposez pas que l’hypothèse réelle d’un symbole remplace son domaine complexe par défaut. Un ConditionSet non évalué signifie que le solveur n’a pas déterminé l’ensemble des solutions, pas qu’il est vide. solve(..., dict=True) convient pour obtenir une liste de dictionnaires associant symboles et valeurs.

Passage au calcul numérique

f = lambdify(x, expression, modules="math")
assert f(2) == 9

lambdify traduit une expression en fonction numérique. Le moteur math ci-dessus traite les scalaires ; utilisez modules="numpy" avec des tableaux NumPy pour une évaluation vectorisée, soumise aux domaines numériques et aux règles flottantes. Il génère du code exécutable : ne transmettez pas d’expressions issues d’entrées non fiables. Le calcul symbolique peut rester non évalué ou devenir coûteux ; un objet symbolique ne garantit pas une forme fermée pour toute intégrale ou équation.

Mes lectures · Les notes ouvertes sont mémorisées dans ce navigateur.