Meistere SymPy
Symbolische Mathematik mit Python
Raúl Sierra Sánchez
Kostenlose Leseprobe · Erstes Kapitel
Wenn du Entwickler bist und komplexe mathematische Formeln in deinen Projekten implementieren musstest, weißt du, was passiert: Eine Gleichung, die auf Papier elegant gelöst wird, verwandelt sich in einen Haufen numerischer Approximationen, Rundungsfehler und schwer zu debuggenden Code. SymPy wurde genau geschaffen, um diesen Kampf zu vermeiden.
SymPy ist eine Open-Source-Bibliothek für Python, die symbolische Algebra (oder symbolische Berechnung) ermöglicht. Anstatt mit konkreten Zahlen zu arbeiten, manipuliert SymPy mathematische Ausdrücke als Objekte, die transformiert, vereinfacht, abgeleitet, integriert oder exakt gelöst werden können – genau so, wie du es mit Bleistift und Papier machen würdest, aber automatisiert und reproduzierbar.
Dieses Kapitel vermittelt dir die Grundlagen, die du brauchst, bevor du im Buch weiterkommst. Wir sehen uns genau an, was symbolische Algebra eigentlich ist, worin sie sich vom numerischen Ansatz unterscheidet, den du bereits kennst (NumPy, SciPy usw.), wie man SymPy richtig installiert und wie man es in einem realen Projekt einsetzt. Alles aus der Perspektive eines Programmierers, der leistungsstarke Mathematik in seinen Code integrieren will, ohne selbst professioneller Mathematiker zu werden.
SymPy ist Teil des wissenschaftlichen Python-Ökosystems zusammen mit NumPy, SciPy, Pandas und Matplotlib. Es nimmt jedoch eine eigene Nische ein: Während sich die anderen Bibliotheken auf numerische Berechnungen konzentrieren (Näherungswerte mit Gleitkommazahlen), arbeitet SymPy mit exakten symbolischen Repräsentationen.
Das bedeutet, dass es:
√2 oder π beibehalten kann, ohne sie zu approximieren.(x + 1)² - (x² + 2x + 1) zu 0 vereinfachen kann.x = -b/(2a) statt eines Dezimalwerts zurückgeben kann.Für einen Entwickler ist der Vorteil enorm. Im Machine Learning kannst du Verlustfunktionen symbolisch ableiten. In der Data Science kannst du Ausdrücke vereinfachen, bevor du sie in der Produktion implementierst. In der wissenschaftlichen Entwicklung kannst du validieren, dass deine numerische Implementierung mit der exakten analytischen Lösung übereinstimmt.
SymPy ist vollständig in Python geschrieben, benötigt keine externen Compiler und integriert sich nahtlos in den Rest des Ökosystems. Du kannst symbolische Ausdrücke mit lambdify in schnelle numerische Funktionen umwandeln, LaTeX-Code für die Dokumentation generieren oder Ausdrücke in andere Sprachen exportieren.
Der grundlegende Unterschied zwischen beiden Ansätzen liegt in der Art der Antwort, die sie liefern.
Numerische Berechnung (die du normalerweise verwendest):
PYTHON
import numpy as np
def f(x):
return x**2 - 3*x + 2
x_values = np.linspace(0, 5, 100)
y_values = f(x_values)
root_approx = np.roots([1, -3, 2])
print(root_approx)Dieser Code gibt dir ungefähr [2. 1.] zurück. Das sind nützliche Zahlen für Grafiken oder Simulationen, aber du verlierst Informationen: Du weißt nicht, ob die Wurzel exakt 2 ist oder ob ein Gleitkommafehler vorliegt.
Symbolische Algebra mit SymPy löst dieselbe Gleichung exakt:
PYTHON
import sympy as sp
x = sp.symbols('x')
expr = x**2 - 3*x + 2
roots = sp.solve(expr, x)
print(roots)Dieser Code gibt exakt [1, 2] zurück. Es gibt keine Approximation. Außerdem kannst du SymPy bitten, den Ausdruck zu faktorisieren, abzuleiten, zu integrieren oder unter bestimmten Bedingungen zu vereinfachen.
Der Unterschied wird bei komplexeren Ausdrücken noch deutlicher. Betrachte die Ableitung von sin(x²). Numerisch kannst du nur Werte an konkreten Punkten erhalten. Mit SymPy kannst du den exakten Ausdruck 2*x*cos(x**2) erhalten und dann entscheiden, ob du ihn numerisch auswertest, vereinfachst oder zur Generierung optimierten Codes verwendest.
Ein weiterer wichtiger Vorteil ist der Umgang mit rationalen Zahlen und exakten Ausdrücken. SymPy wandelt 1/3 nicht in 0.3333333333333333 um, es sei denn, du forderst es explizit auf. Das eliminiert eine häufige Quelle subtiler Fehler in wissenschaftlichen Berechnungen.
WICHTIGER UNTERSCHIED BEI DER GENAUIGKEIT
In SymPy bleibt sp.sqrt(8) als 2*sqrt(2) erhalten, bis du dich entscheidest, es numerisch mit .evalf() auszuwerten. Diese Fähigkeit, die Approximation aufzuschieben, ist eines der mächtigsten Merkmale für die Validierung und Vereinfachung mathematischen Codes.
Die üblichste und empfohlene Methode, SymPy zu installieren, ist über pip in einer virtuellen Umgebung.
Zuerst erstellst und aktivierst du eine virtuelle Umgebung (empfohlen für jedes seriöse Projekt):
BASH
python -m venv sympy-env # Unter Windows: sympy-env\Scripts\activate # Unter macOS und Linux: source sympy-env/bin/activate
Dann installierst du SymPy:
BASH
pip install sympy
Wenn du in Data-Science- oder Jupyter-Umgebungen arbeitest, kannst du es auch mit conda installieren:
BASH
conda install -c conda-forge sympy
Für Projekte, die eine schöne Darstellung in Notebooks oder der Konsole benötigen, enthält SymPy Werkzeuge für Pretty Printing, die sich leicht aktivieren lassen.
Nach der Installation überprüfst du, ob alles korrekt funktioniert:
PYTHON
import sympy as sp
print(sp.__version__)
x = sp.symbols('x')
expr = sp.sin(x) + sp.cos(x)
print(expr)Dieses kleine Skript bestätigt dir, dass die Bibliothek verfügbar ist und mit grundlegenden trigonometrischen Ausdrücken arbeiten kann. Die Ausgabe sollte die installierte Version anzeigen (derzeit etwa 1.13) und den Ausdruck sin(x) + cos(x).
ISOLIERTE UMGEBUNG
Obwohl SymPy leichtgewichtig ist, ist es gute Praxis, es in einer virtuellen Umgebung zu isolieren. So vermeidest du Versionskonflikte mit anderen wissenschaftlichen Bibliotheken, die möglicherweise andere Anforderungen haben, besonders wenn du auch NumPy oder SciPy in bestimmten Versionen verwendest.
Die in der Community weit verbreitete Konvention ist, SymPy mit dem Alias sp zu importieren:
PYTHON
import sympy as sp
Diese Praxis verhindert eine Verunreinigung des Namensraums und macht deutlich, wann du symbolische Funktionalität verwendest.
Zur Verbesserung der Benutzererfahrung, besonders in Jupyter Notebook oder JupyterLab, ist es sehr nützlich, das schöne Drucksystem zu initialisieren:
PYTHON
import sympy as sp
sp.init_printing(use_unicode=True)
x = sp.symbols('x')
display(x**2 + 2*x + 1)Die Funktion init_printing() sorgt dafür, dass Ausdrücke mit geeignetem mathematischem Format dargestellt werden (mit Unicode oder LaTeX je nach Umgebung). In Notebooks zeigt display() den gerenderten Ausdruck an.
Das zentrale Konzept von SymPy sind die Symbole. Im Gegensatz zu normalen Python-Variablen repräsentieren Symbole unbekannte mathematische Variablen.
Es gibt zwei Hauptmöglichkeiten, sie zu erstellen:
PYTHON
import sympy as sp
# Empfohlene Form für mehrere Symbole
x, y, z = sp.symbols('x y z')
# Alternative Form für ein einzelnes Symbol mit Eigenschaften
x = sp.Symbol('x', real=True, positive=True)Die erste Form ist pythonischer und die, die du in den meisten Fällen verwenden wirst. Der String 'x y z' sagt SymPy, wie die Symbole heißen.
Sobald du Symbole hast, kannst du auf natürliche Weise Ausdrücke aufbauen:
PYTHON
import sympy as sp
x, y = sp.symbols('x y')
expr1 = x**2 + 3*x + 2
expr2 = sp.sin(x) * sp.exp(y)
expr3 = (x + y) / (x - y)
print(expr1)
print(expr2)
print(expr3)Diese Ausdrücke werden nicht numerisch ausgewertet. Es sind Ausdrucksbäume, die SymPy manipulieren kann.
SymPy bietet klare und beschreibende Funktionen für die häufigsten Operationen:
Vereinfachung und Faktorisierung
PYTHON
import sympy as sp
x = sp.symbols('x')
expr = x**3 - 3*x**2 + 3*x - 1
factored = sp.factor(expr)
simplified = sp.simplify((x**3 + x**2) / x)
print(factored) # (x - 1)**3
print(simplified) # x**2 + xAbleitungen und Integrale
PYTHON
import sympy as sp
x = sp.symbols('x')
f = x**3 + 2*x**2 - 5*x + 1
derivative = sp.diff(f, x)
integral = sp.integrate(f, x)
print(derivative) # 3*x**2 + 4*x - 5
print(integral) # x**4/4 + 2*x**3/3 - 5*x**2/2 + xLösen von Gleichungen
PYTHON
import sympy as sp
x = sp.symbols('x')
equation = sp.Eq(x**2 - 5*x + 6, 0)
solutions = sp.solve(equation, x)
print(solutions) # [2, 3]Diese Operationen bilden die Grundlage, auf der wir in den folgenden Kapiteln alles Weitere aufbauen werden.
Viele Entwickler denken, dass symbolische Algebra nur etwas für akademische Mathematiker ist. Nichts könnte weiter von der Wahrheit entfernt sein.
Im Machine Learning kannst du SymPy verwenden, um Gradienten komplexer Funktionen abzuleiten, bevor du sie in PyTorch oder TensorFlow implementierst. In der Data Science kannst du Wahrscheinlichkeitsausdrücke vereinfachen oder Formeln transformieren, bevor du sie mit NumPy vektorisierst. In der wissenschaftlichen Entwicklung kannst du validieren, dass deine numerische Implementierung einer Methode zur Lösung von Differentialgleichungen in einfachen Fällen mit der analytischen Lösung übereinstimmt.
Die Fähigkeit, von einem symbolischen Ausdruck zu einer schnellen numerischen Funktion mit sp.lambdify() zu wechseln, ist besonders mächtig:
PYTHON
import sympy as sp
import numpy as np
x = sp.symbols('x')
expr = sp.sin(x) / x
# Wir wandeln den symbolischen Ausdruck in eine schnelle numpy-Funktion um
f = sp.lambdify(x, expr, 'numpy')
# Nun können wir sie mit NumPy-Arrays verwenden
x_values = np.linspace(0.1, 10, 1000)
y_values = f(x_values)Diese Kombination aus symbolischer Exaktheit und numerischer Geschwindigkeit ist einer der Gründe, warum SymPy in der Python-Community so beliebt geworden ist.
In diesem Kapitel haben wir die Grundlagen gelegt: Du verstehst den philosophischen Unterschied zwischen symbolischer und numerischer Berechnung, hast SymPy installiert, weißt, wie man Symbole erstellt, und hast die gängigsten Operationen gesehen.
Die folgenden Kapitel werden jede dieser Bereiche vertiefen. Du wirst lernen, komplexe Ausdrücke souverän zu manipulieren, Systeme von Gleichungen zu lösen, mit symbolischen Matrizen zu arbeiten, Grenzwerte, Reihen und Transformationen zu berechnen und SymPy in reale Machine-Learning- und Data-Science-Projekte zu integrieren.
Die Stärke von SymPy liegt nicht darin, alle Funktionen auswendig zu kennen, sondern darin, deine Denkweise zu ändern: Vom „Approximieren, bis es funktioniert“ zum „Genau verstehen, was passiert, und dann optimieren“.
Du bist bereit weiterzumachen.
(Ungefähr 2980 Wörter)
Was ist symbolische Algebra
Die symbolische Algebra ist eine Methode der mathematischen Berechnung, die Ausdrücke als algebraische Objekte behandelt statt als konkrete numerische Werte. Anstatt Variablen sofort durch Zahlen zu ersetzen und ein Dezimalergebnis zu erhalten, behält das System die Variablen als Symbole bei und operiert exakt mit ihnen.
Das bedeutet, dass du den Computer auffordern kannst, abzuleiten, zu integrieren, zu vereinfachen, zu faktorisieren oder Gleichungen zu lösen, während die analytische Form erhalten bleibt. Das Ergebnis ist ein mathematischer Ausdruck, der für beliebige Werte der Variablen gültig bleibt, nicht nur für einen bestimmten Satz von Zahlen.
Die Unterscheidung ist wichtig für jeden Entwickler, der mit mathematischen Modellen arbeitet:
x² - 1 in (x - 1)(x + 1) umwandeln oder die Ableitung von sin(3x) berechnen und 3·cos(3x) als exaktes Ergebnis erhalten.Diese Fähigkeit ist besonders nützlich, wenn du eine Formel nur einmal ableiten und sie danach viele Male wiederverwenden musst oder wenn du komplexe Ausdrücke vereinfachen willst, bevor du sie an numerischen Code übergibst.
PRÄZISION VERSUS GESCHWINDIGKEIT
Die symbolische Algebra ist langsamer als die numerische Berechnung, weil sie Ausdrucksbäume manipuliert statt einfacher Gleitkommaoperationen. Die übliche Strategie besteht darin, SymPy zum Ableiten, Vereinfachen oder Lösen zu verwenden und das Ergebnis anschließend in eine schnelle numerische Funktion umzuwandeln (zum Beispiel mit lambdify).
Sehen wir uns ein einfaches Beispiel an, das beide Ansätze nebeneinander zeigt.
PYTHON
from sympy import symbols, diff, sin, lambdify
import numpy as np
x = symbols('x')
expr = x**2 + sin(x)
# Enfoque simbólico
derivada_simbolica = diff(expr, x)
print(derivada_simbolica)
# Convertimos la expresión simbólica a una función numérica rápida
f_derivada = lambdify(x, derivada_simbolica, 'numpy')
# Evaluación numérica
x_num = np.array([0.0, 1.0, 2.0])
print(f_derivada(x_num))Der erste Teil (diff) gibt exakt 2*x + cos(x) zurück. Der zweite Teil erzeugt eine vektorisierte Funktion mit NumPy, die sich sehr effizient auf großen Arrays auswerten lässt. Dieses Muster – symbolische Entwicklung gefolgt von numerischer Ausführung – ist einer der häufigsten Anwendungsfälle von SymPy in realen Data-Science- und wissenschaftlichen Entwicklungsprojekten.
Die Beherrschung der symbolischen Algebra ermöglicht es dir, manuelle Formelmanipulationen auf Papier oder in Tabellenkalkulationen aufzugeben und diese Arbeit in den Code zu verlagern, wo sie reproduzierbar, überprüfbar und leicht änderbar ist. Das ist genau der Vorteil, den SymPy in das Python-Ökosystem bringt.
Vorteile gegenüber der numerischen Berechnung und ihren Einschränkungen
Wenn du Code schreibst, der mathematische Probleme lösen muss, greifst du normalerweise zuerst auf die numerische Berechnung zurück. Bibliotheken wie NumPy oder SciPy arbeiten mit Gleitkommazahlen und liefern sehr schnell approximative Ergebnisse. Dieser Ansatz eignet sich hervorragend für Simulationen, Grafiken oder Machine-Learning-Modelle, hat aber wichtige Einschränkungen, die sofort deutlich werden, sobald die Genauigkeit oder die analytische Form des Ergebnisses eine Rolle spielen.
Das Hauptproblem der numerischen Berechnung besteht darin, dass sie mit Approximationen arbeitet. Eine Zahl wie 0.1 lässt sich im Binärsystem nicht exakt darstellen, sodass bereits einfache Operationen Fehler anhäufen. Diese Fehler pflanzen sich in iterativen Berechnungen, numerischen Ableitungen oder Lösungen nichtlinearer Gleichungen rasch fort. Außerdem ist das Ergebnis immer ein konkreter Zahlenwert: Du erhältst einen Wert für x = 2.345, aber keinen allgemeinen Ausdruck, den du wiederverwenden oder vereinfachen kannst.
SymPy geht den entgegengesetzten Weg: Es führt symbolische Algebra durch. Anstatt Variablen von Anfang an durch Zahlen zu ersetzen, behält es die Ausdrücke als mathematische Objekte bei und manipuliert sie nach exakten algebraischen Regeln. Das Ergebnis ist ein vereinfachter Ausdruck, eine exakte Lösung oder eine allgemeine Formel.
Sehen wir uns zuerst an, wie sich das Präzisionsproblem in purem Python zeigt:
PYTHON
print(0.1 + 0.2) print(0.1 + 0.2 == 0.3)
Dieser Code gibt 0.30000000000000004 und False aus. Auch wenn der Fehler klein ist, kann er in komplexeren Berechnungen (insbesondere bei numerischen Ableitungen oder Integralen) zu einem schwerwiegenden Problem werden.
SymPy vermeidet diese Art von Fehlern vollständig, indem es mit exakten rationalen Darstellungen arbeitet:
PYTHON
from sympy import Rational, simplify a = Rational(1, 10) b = Rational(1, 5) resultado = a + b print(resultado) print(resultado == Rational(3, 10))
Hier erhalten wir exakt 3/10 und das Ergebnis des Vergleichs ist True. SymPy approximiert nicht: Es behält den Bruch in seiner exakten Form bei, bis wir uns entscheiden, ihn numerisch auszuwerten.
Die relevantesten Vorteile dieses symbolischen Ansatzes für Entwickler sind:
Das bedeutet nicht, dass die numerische Berechnung unterlegen wäre. Jeder Ansatz hat seinen Platz. Wenn du Millionen von Daten verarbeiten oder Echtzeitsimulationen ausführen musst, ist der numerische Ansatz wegen seiner Geschwindigkeit unverzichtbar. SymPy glänzt, wenn du Formeln ableiten, analytische Ergebnisse prüfen, Code aus vereinfachten Ausdrücken generieren oder in Data-Science- und wissenschaftlichen Projekten arbeiten willst, bei denen Exaktheit ebenso wichtig ist wie Performance.
PRAKTISCHE WAHL
In realen Projekten ist die Kombination beider Ansätze üblich: SymPy wird verwendet, um die mathematische Formel abzuleiten und zu vereinfachen, und anschließend in NumPy- oder PyTorch-Code für die schnelle Ausführung umgewandelt. Dies ist eine der leistungsstärksten Techniken, die du in den folgenden Kapiteln kennenlernen wirst.
Sobald wir den Zweck von SymPy und seinen fundamentalen Unterschied zu numerischen Bibliotheken wie NumPy verstanden haben, ist es an der Zeit, ihn in unser Projekt einzubinden. Die Installation ist unkompliziert, doch es empfiehlt sich, sie korrekt durchzuführen, um Konflikte mit anderen Abhängigkeiten zu vermeiden und eine reproduzierbare Umgebung zu gewährleisten.
Die empfohlene und unter Entwicklern üblichste Methode ist die Installation von SymPy über pip. Auch wenn eine direkte Installation im System-Python möglich ist, besteht die Standardpraxis darin, dies innerhalb einer virtuellen Umgebung zu tun.
Bevor Sie einen Installationsbefehl ausführen, erstellen Sie eine isolierte Umgebung. Dies ist besonders bei Projekten nützlich, die symbolische Mathematik mit Machine Learning oder Data Science kombinieren, da die Bibliotheksversionen leicht in Konflikt geraten können.
BASH
# Virtuelle Umgebung erstellen python -m venv sympy-env # Auf macOS / Linux aktivieren source sympy-env/bin/activate # Auf Windows (PowerShell) aktivieren sympy-env\Scripts\Activate.ps1 # SymPy installieren pip install sympy
Dieser Befehl lädt die neueste stabile Version von SymPy sowie alle Abhängigkeiten herunter (hauptsächlich mpmath). Der Vorgang ist in der Regel in weniger als einer Minute abgeschlossen.
BEWÄHRTE VORGEHENSWEISEN BEI DER INSTALLATION
Das Arbeiten innerhalb einer virtuellen Umgebung verhindert, dass SymPy andere Projekte beeinträchtigt, und erleichtert das Teilen der Datei requirements.txt mit dem Team. Sie können diese Datei anschließend mit pip freeze > requirements.txt erzeugen.
Nach der Installation sollten Sie zunächst prüfen, ob alles funktioniert, bevor Sie fortfahren. Erstellen Sie dazu eine Datei test_sympy.py oder öffnen Sie einen interaktiven Interpreter.
PYTHON
import sympy
print("SymPy Version:", sympy.__version__)
print("Installation korrekt verifiziert")Beim Ausführen dieses Codes sollte die SymPy-Versionsnummer erscheinen, ohne dass ein Importfehler auftritt. Damit ist bestätigt, dass die Bibliothek in der aktiven Umgebung verfügbar und einsatzbereit ist.
SymPy funktioniert sofort, doch einige anfängliche Einstellungen verbessern die Nutzung erheblich – besonders wenn Sie in Jupyter Notebooks oder in VS Code mit Notebooks arbeiten.
PYTHON
from sympy import symbols, init_printing
import sympy as sp
# Schöne Ausgabe mathematischer Ausdrücke aktivieren
init_printing(use_unicode=True)
# Einige Symbole definieren, die wir häufig verwenden werden
x, y = symbols('x y')
print("SymPy konfiguriert und bereit zur Verwendung")Die Funktion init_printing() sorgt dafür, dass mathematische Ausdrücke lesbar formatiert dargestellt werden (Brüche, Exponenten und Wurzeln mit passender Typografie). Die Verwendung eines Alias wie sp ist eine weit verbreitete Konvention, die Sie in den meisten realen Projekten antreffen werden.
Mit diesen Schritten haben Sie SymPy installiert, überprüft und konfiguriert. Nun können wir Symbole definieren, Ausdrücke erstellen und symbolische Operationen produktiv ausführen – genau das, was in den folgenden Abschnitten behandelt wird.
Eine sehr praktische Möglichkeit, mit SymPy zu arbeiten, ist die Nutzung seiner interaktiven Konsole. Dieses Werkzeug nimmt den größten Teil der anfänglichen Einrichtung ab und lässt dich sofort mit symbolischen Ausdrücken experimentieren. Das ist besonders hilfreich, wenn du gerade lernst oder Ideen ausprobierst.
Die Konsole basiert auf IPython und ist speziell für symbolische Algebra vorkonfiguriert: Sie importiert automatisch alle zentralen Komponenten von SymPy, definiert gängige Symbole (x, y, z, t usw.) und stellt Funktionen wie diff, integrate, simplify, solve oder expand bereit, ohne dass du die import-Anweisungen schreiben musst.
Sobald SymPy installiert ist, öffne dein Terminal und führe folgenden Befehl aus:
BASH
isympy
Du kannst auch folgenden Befehl verwenden:
BASH
python -m sympy
In beiden Fällen wird eine interaktive Sitzung gestartet, die eine Willkommensmeldung anzeigt und dich am Prompt >>> absetzt. Ab sofort kannst du direkt symbolische Ausdrücke eingeben.
PYTHON
>>> diff(sin(x)**2, x) 2*sin(x)*cos(x)
In diesem Beispiel war weder ein Import noch die Definition der Variable x nötig. Die Konsole hatte die Umgebung bereits vorbereitet. Das Ergebnis ist die vereinfachte Ableitung von sin²(x).
In einem normalen Python-Interpreter müsstest du erst mehrere Zeilen schreiben, bevor du loslegen kannst:
PYTHON
>>> from sympy import *
>>> x = symbols('x')
>>> diff(sin(x)**2, x)
2*sin(x)*cos(x)Die isympy-Konsole entfernt diesen Boilerplate-Code. Dadurch wird die Erkundung deutlich beschleunigt und die Reibung verringert, wenn du verschiedene Ansätze zum Lösen einer Gleichung oder Vereinfachen eines Ausdrucks testest.
SCHNELLES EXPERIMENTIEREN
Die interaktive Konsole eignet sich hervorragend, um Ideen rasch zu prüfen, bevor du sie in ein Skript oder Jupyter Notebook einbaust. Viele Entwickler nutzen sie, um symbolische Manipulationen zu validieren, und übertragen den bereinigten Code anschließend in die Hauptdatei des Projekts.
Auch wenn sie sehr komfortabel ist, ersetzt die Konsole keinen gut strukturierten Code in .py-Dateien oder Notebooks. Sobald die Arbeit komplexer wird – bei wiederverwendbaren Funktionen, Datenverarbeitung oder der Integration mit anderen Bibliotheken –, solltest du normale Skripte mit expliziten Imports schreiben. So bleibt der Code dokumentiert, versionierbar und leichter zu teilen.
Die interaktive Konsole ist daher ein Lern- und Erkundungswerkzeug, das die normale Verwendung von SymPy in Data-Science-, Machine-Learning- oder wissenschaftlichen Projekten ideal ergänzt. Sie ermöglicht es dir, in wenigen Sekunden von der mathematischen Idee zum funktionsfähigen Code zu gelangen.
Der erste echte Schritt mit SymPy besteht darin, nicht mehr in Zahlen zu denken und stattdessen mit mathematischen Ausdrücken als Objekten zu arbeiten. Während in normalem Python x = 5 einen konkreten Wert zuweist, kann x in SymPy eine unbekannte Variable darstellen, mit der wir algebraisch operieren können.
Die am häufigsten verwendete Konvention in realen Projekten ist es, die Bibliothek mit einem kurzen Alias zu importieren:
PYTHON
import sympy as sp sp.init_printing(use_unicode=True)
Die erste Zeile gibt uns Zugriff auf das gesamte Modul unter dem Präfix sp.. Die zweite aktiviert ein besser lesbares Ausgabesystem, das die Ausdrücke in mathematischer Formatierung darstellt (besonders nützlich in Jupyter Notebook, obwohl es auch die Konsolenausgabe verbessert).
Bevor du irgendeinen Ausdruck schreiben kannst, muss SymPy wissen, welche Buchstaben mathematische Variablen repräsentieren. Das geschieht mit der Funktion symbols():
PYTHON
x = sp.symbols('x')Nun ist x ein Objekt vom Typ Symbol, kein numerischer Wert. Du kannst mehrere Symbole auf einmal erstellen, indem du ihre Namen durch Leerzeichen trennst:
PYTHON
x, y = sp.symbols('x y')Mit den definierten Symbolen kannst du Ausdrücke mit der gewohnten mathematischen Python-Syntax aufbauen. Erstellen wir einen einfachen quadratischen Ausdruck:
PYTHON
expr = x**2 - 5*x + 6 print(expr)
SymPy berechnet noch nichts. expr enthält eine exakte Repräsentation des algebraischen Ausdrucks. Wenn du diesen Code ausführst, siehst du x**2 - 5*x + 6 (oder in schöner Formatierung, falls du init_printing aktiviert hast).
Der eigentliche Wert von SymPy zeigt sich, wenn du mathematische Funktionen auf diesen Ausdruck anwendest. Schau dir an, was wir mit nur wenigen Zeilen erreichen können:
PYTHON
faktorisiert = sp.factor(expr)
print("Faktorisiert:", faktorisiert)
wurzeln = sp.solve(expr, x)
print("Wurzeln:", wurzeln)
ableitung = sp.diff(expr, x)
print("Ableitung:", ableitung)Dieses kleine Programm:
(x - 2)*(x - 3)[2, 3] zurück2*x - 5Alles ohne dabei die Exaktheit zu verlieren.
:::tip Gute Gewohnheit von Anfang an
Vermeide from sympy import * in Skripten oder mittelgroßen Projekten. Auch wenn viele Tutorials es zum Tippsparen verwenden, macht das Präfix sp. den Code deutlich lesbarer und verhindert Namenskonflikte mit Funktionen anderer Bibliotheken wie numpy oder den eingebauten Python-Funktionen.
:::
In den folgenden Kapiteln werden wir jede dieser Operationen vertiefen und zeigen, wie man sie kombiniert, um reale Probleme aus Analysis, Optimierung und mathematischer Modellierung zu lösen. Aber du hast bereits das Wesentliche: einen lebendigen symbolischen Ausdruck, mit dem SymPy mathematisch arbeiten kann.