SymPy: Een complete gids voor symbolische wiskunde in Python

Als je ooit wilde dat Python algebraïsche bewerkingen uitvoert en weergeeft als een wiskundige, dan is SymPy je antwoord.

SymPy staat voor Symbolic Python en is een bibliotheek die is gebouwd voor symbolische berekeningen. Dat betekent dat het vergelijkingen symbolisch kan uitwerken, vereenvoudigen, differentiëren en oplossen, net zoals je dat op papier zou doen.  Een belangrijk gevolg is dat wiskundige uitdrukkingen met onevaluated variabelen in symbolische vorm blijven. Zo wordt de wortel van acht weergegeven als 2*sqrt(2) in plaats van te benaderen als 2,828.   

Enkele grote voordelen van SymPy zijn dat het open source is, volledig in Python is geschreven en compatibel is met andere Python-bibliotheken. 

Belangrijkste voordelen van Sympy. Bron: Afbeelding door Napkin AI

Korte geschiedenis van SymPy

SymPy begon met een simpel idee: symbolische berekening voor iedereen toegankelijk maken.

Het werd in 2006 gestart door Ondřej Čertík, een student aan de University of Nevada. Hij wilde een lichte, flexibele symbolische wiskundebibliotheek in pure Python maken, zodat mensen niet hoefden te werken met de complexiteit van grote computeralgebrasystemen zoals Maple of Mathematica. 

Tussen 2007 en 2010 groeide SymPy snel dankzij deelname aan Google Summer of Code, waarbij belangrijke kernmodules zoals vereenvoudigen, oplossen en analyse aanzienlijk werden uitgebreid. 

Rond 2012 was SymPy zo ver doorontwikkeld dat het werd geïntegreerd in SageMath, een erkenning als betrouwbare symbolische backend binnen het bredere wetenschappelijke Python-ecosysteem. Vandaag de dag is SymPy verder geëvolueerd dan alleen gebruik in algebra en werkt het ook in geavanceerde domeinen zoals natuurkunde, meetkunde, combinatoriek, codegeneratie en prestatiegerichte compilatietools.

Aan de slag met SymPy

Voordat we SymPy’s magie verkennen, zetten we het eerst goed op.

Installatie en setup

De makkelijkste en aanbevolen manier om SymPy te installeren is met pip:

pip install sympyMogelijk gemaakt door

Gebruik je Conda, dan is het commando:

conda install sympyMogelijk gemaakt door

Je kunt het ook rechtstreeks vanaf de bron installeren (handig voor bijdragers):

git clone https://github.com/sympy/sympy.gitMogelijk gemaakt door

Als je je afvraagt naar afhankelijkheden: SymPy draait volledig in Python en is niet afhankelijk van externe bibliotheken. Optionele pakketten zoals mpmath kun je installeren voor rekenen met willekeurige precisie:

pip install mpmathMogelijk gemaakt door

Installatie verifiëren

Om de installatie te bevestigen, open je Python en typ je:

import sympy
print(sympy.__version__)Mogelijk gemaakt door

1.14.0Mogelijk gemaakt door

De output toont de geïnstalleerde versie van het pakket.  Je kunt het pakket nu testen met een eenvoudige expressie:

from sympy import symbols

# Define x as a symbolic variable
x = symbols('x')

print((x + 2)**2)Mogelijk gemaakt door

(x + 2)**2Mogelijk gemaakt door

Wat betreft probleemoplossing:

• Zie je ModuleNotFoundError, voer dan opnieuw pip install sympy uit.

• Bij versieconflicten: upgrade pip: pip install --upgrade pip

Ook goed om te weten: Als je denkt dat er een bug is of je wilt een feature aanvragen, kun je ook een issue aanmaken. Voor een uitgebreide verkenning van installatiemethoden, bekijk de officiële documentatie.

Basisgebruik

SymPy biedt een interactieve omgeving waarin je algebraïsche uitdrukkingen symbolisch kunt manipuleren.

from sympy import symbols, expand

#define x and y as symbolic variables
x, y = symbols('x y')

# create an algebraic expression
expr = (x + y)**2

expanded = expand(expr)
print(expanded)Mogelijk gemaakt door

x**2 + 2*x*y + y**2Mogelijk gemaakt door

De bovenstaande uitvoer x**2 + 2*x*y + y**2 is de volledig uitgewerkte vorm en laat zien hoe SymPy exacte symbolische algebra uitvoert in plaats van numerieke berekening.

Kernfuncties en functionaliteiten

De kernfunctionaliteit draait om symbolische berekening — werken met functies, vergelijkingen en uitdrukkingen als symbolen in plaats van als getallen.

Rekenkundige bewerkingen

Je kunt symbolische variabelen behandelen als algebraïsche variabelen. Ook kunnen functies van de ene naar de andere vorm gaan, zoals gedemonstreerd in de onderstaande code. 

Met expand() voor distributie en factor() voor de omgekeerde vereenvoudiging transformeert SymPy tussen uitgewerkte en gefactoriseerde vormen van een algebraïsche uitdrukking.

from sympy import symbols, expand, factor

# Define symbolic variables x and y
x, y = symbols('x y')

# Create an algebraic expression
expr = (x + y)**2

# Expand the expression to its full polynomial form
print(expand(expr))  

# Factor the expanded polynomial back into its compact form
print(factor(x**2 + 2*x*y + y**2)) Mogelijk gemaakt door

x**2 + 2*x*y + y**2
(x + y)**2Mogelijk gemaakt door

Vereenvoudigingstechnieken

Vereenvoudigen is centraal bij symbolische berekening. Er is een algemene functie in SymPy, genaamd simplify(), die rationele, trigonometrische of algebraïsche uitdrukkingen eenvoudig vereenvoudigt.

from sympy import simplify, trigsimp, sin, cos

# Create a trigonometric expression
expr = sin(x)**2 + cos(x)**2

# General simplification — recognizes that sin²x + cos²x = 1
print(simplify(expr)) 

# Trigonometric-specific simplification — also simplifies to 1
print(trigsimp(expr)) Mogelijk gemaakt door

De uitvoer is in zowel de functies simplify() als trigsimp() gelijk aan één. 

Analyse (calculus)

SymPy is geweldig voor analyse omdat je er differentiëren, integreren, limieten en zelfs reeksontwikkelingen volledig symbolisch mee kunt doen, net zoals met de hand, maar dan met perfecte nauwkeurigheid.

Differentieren

Voor afgeleiden gebruik je de functie diff().

from sympy import diff

# Define a symbolic polynomial expression
f = x**3 + 2*x**2 + x

# Compute the derivative of the expression with respect to x
df = diff(f, x)
print(df)Mogelijk gemaakt door

3*x**2 + 4*x + 1Mogelijk gemaakt door

Integreren

De onderstaande code berekent de onbepaalde integraal van de symbolische uitdrukking f naar de variabele x met behulp van SymPy’s functie integrate(). De resulterende primitieve wordt vervolgens geprint.

from sympy import integrate

# Compute the indefinite integral of the expression f with respect to x
integral = integrate(f, x)
print(integral)Mogelijk gemaakt door

x**4/4 + 2*x**3/3 + x**2/2Mogelijk gemaakt door

Limieten

Het berekenen van een limiet is een klassieke analysebewerking, die je kunt uitvoeren met de functie limit() van SymPy. De syntaxis is: limit(f(x), x, x0).  Bijvoorbeeld, de code hieronder berekent de limiet van de uitdrukking sin(x)/x als x naar nul nadert en print het exacte resultaat, één. 

from sympy import limit, sin

# Compute the limit of sin(x)/x as x approaches 0 
limit_expr = limit(sin(x)/x, x, 0)
print(limit_expr) Mogelijk gemaakt door

Reeksontwikkeling

De functie series() kan worden gebruikt om de Taylor- of machtreeksontwikkeling van een wiskundige uitdrukking rond een opgegeven punt te berekenen.

from sympy import series, exp

# Generate the Taylor series expansion of e^x around 0 up to 5 terms
print(series(exp(x), x, 0, 5))Mogelijk gemaakt door

1 + x + x**2/2 + x**3/6 + x**4/24 + O(x**5)Mogelijk gemaakt door

Sommaties

De functie summation() in SymPy voert exacte symbolische sommatie uit over een bepaald bereik, net als de sigma-notatie in de wiskunde.

from sympy import summation, symbols

# Compute the symbolic sum of 1/n^2 from n = 1 to 5
n = symbols('n')
print(summation(1/n**2, (n, 1, 5)))  Mogelijk gemaakt door

5269/3600Mogelijk gemaakt door

Vergelijkingen oplossen

SymPy maakt het gemakkelijk om symbolische vergelijkingen op te lossen — niet alleen de eenvoudige algebraïsche, maar ook stelsels van vergelijkingen, differentiaalvergelijkingen en zelfs Diophantische vergelijkingen, die alleen gehele oplossingen hebben. 

Het heeft krachtige oplossers zoals 

• solve() voor algebraïsche vergelijkingen, 

• linsolve() voor lineaire stelsels, en 

• dsolve() voor differentiaalvergelijkingen die waar mogelijk exacte oplossingen geven. 

Algebraïsche vergelijkingen

from sympy import Eq, solve
# Define and solve the equation x^2 - 4 = 0 symbolically
eq = Eq(x**2 - 4, 0)

print(solve(eq, x)) Mogelijk gemaakt door

[-2, 2]Mogelijk gemaakt door

Stelsels van vergelijkingen

from sympy import linsolve, symbols

# Solve a system of linear equations:
# x + y = 5  and  x - y = 1
x, y = symbols('x y')
sol = linsolve([x + y - 5, x - y - 1], (x, y))

print(sol) # Outputs the solution as a set (x, y)Mogelijk gemaakt door

{(3, 2)}Mogelijk gemaakt door

Differentiaalvergelijkingen

from sympy import Function, dsolve

# Define y as a symbolic function of x
y = Function('y')

# Define a second-order differential equation
diff_eq = Eq(y(x).diff(x, 2) - y(x), 0)

# Solve the differential equation symbolically
print(dsolve(diff_eq))Mogelijk gemaakt door

Eq(y(x), C1*exp(-x) + C2*exp(x))Mogelijk gemaakt door

Matrixbewerkingen

SymPy is een uitstekend hulpmiddel voor lineaire algebra, omdat het symbolische matrices ondersteunt. Je kunt eenvoudig met matrices werken en wiskundige bewerkingen uitvoeren zoals optellen en vermenigvuldigen, net als in de reguliere algebra. 

from sympy import Matrix

# Define symbolic matrices A and B
A = Matrix([[1, 2], [x, 3]])
B = Matrix([[x], [4]])

# Perform matrix multiplication
print(A * B)Mogelijk gemaakt door

Matrix([[x + 8], [x**2 + 12]])Mogelijk gemaakt door

Geavanceerde operaties

SymPy laat je ook belangrijke matrixeigenschappen berekenen, zoals determinanten, inversen, eigenwaarden en eigenvectoren, en dat alles symbolisch, zodat je exacte antwoorden krijgt. 

# Compute the determinant of matrix A
A.det()      

# Compute the inverse of matrix A
A.inv()      

# Compute the eigenvalues of matrix A
A.eigenvals() Mogelijk gemaakt door

{2 - sqrt(2*x + 1): 1, sqrt(2*x + 1) + 2: 1}Mogelijk gemaakt door

Plotmogelijkheden

SymPy is niet beperkt tot symbolische berekening — het ondersteunt ook visualisatie van wiskundige uitdrukkingen. Met de ingebouwde plotfuncties kun je met weinig code 2D- en zelfs 3D-plots van symbolische functies genereren. 

Zo genereert de code hieronder een 2D-plot:  

from sympy.plotting import plot


# Plot the function x^2 over the range -5 to 5
plot(x**2, (x, -5, 5))Mogelijk gemaakt door

2D-plot gegenereerd met SymPy. 

Voor het genereren van 3D-plots kun je de functie plot3d() gebruiken, zoals hieronder getoond.

from sympy.plotting import plot3d
from sympy import sin

# Generate a 3D surface plot of the function sin(x*y) over the specified x and y ranges
plot3d(sin(x*y), (x, -5, 5), (y, -5, 5))Mogelijk gemaakt door

3D-plotmogelijkheden van SymPy

En als je meer controle of styling nodig hebt, kan SymPy ook integreren met Matplotlib voor volledig aanpasbare visualisaties. Voor geavanceerdere visualisaties lees je onze tutorial over Plotly Shapes.

Geavanceerde mogelijkheden

SymPy gaat veel verder dan basisalgebra — het strekt zich uit tot polynomen, combinatoriek en zelfs natuurkunde.

Polynoommanipulatie

Je kunt eenvoudig polynomen definiëren en manipuleren. De code hieronder maakt een polynoomobject van de uitdrukking en print vervolgens de graad en de gefactoriseerde vorm met coëfficiënten met behulp van SymPy’s functie Poly(). 

from sympy import Poly

# Create a symbolic polynomial in variable x
p = Poly(x**3 - 3*x**2 + x - 3, x)

# Print the degree of the polynomial (highest power of x)
print(p.degree())  

# Print the factorized form of the polynomial along with coefficients
print(p.factor_list())  Mogelijk gemaakt door

3
(1, [(Poly(x - 3, x, domain='ZZ'), 1), (Poly(x**2 + 1, x, domain='ZZ'), 1)])Mogelijk gemaakt door

Voor complexe polynoomstelsels worden Gröbner-bases ondersteund. Dat is een vereenvoudigde en gestandaardiseerde versie van een stelsel polynoomvergelijkingen, waardoor ze makkelijker op te lossen zijn. 

Zo berekent de code hieronder de Gröbner-basis voor het polynoomstelsel [x*y - 1, y - x], wat betekent dat de vergelijkingen worden herschreven in een eenvoudigere, meer gestructureerde vorm die makkelijker op te lossen is. De output laat zien dat het stelsel gelijkwaardig is aan de schonere vergelijkingen x = y en y² = 1, die nu direct kunnen worden opgelost.

from sympy import groebner, symbols

# Define x and y as symbolic variables
x, y = symbols('x y')

# Compute the Gröbner basis for the system of polynomial equations
print(groebner([x*y - 1, y - x], x, y))Mogelijk gemaakt door

GroebnerBasis([x - y, y**2 - 1], x, y, domain='ZZ', order='lex')Mogelijk gemaakt door

Combinatoriek, discrete wiskunde en getaltheorie

SymPy heeft verschillende hulpmiddelen waarmee het combinatorische en getaltheoretische problemen aankan. 

In de onderstaande code bijvoorbeeld:

• De functie binomial(5, 2) berekent het aantal manieren om 2 items uit 5 te kiezen (een combinatorisch probleem), 

• factorial(6) berekent 6!, een veelvoorkomende bewerking bij permutaties. 

• isprime(19) controleert of 19 een priemgetal is, en 

• factorint(100) geeft de exacte priemfactorisatie terug als {2: 2, 5: 2}. 

from sympy import binomial, factorial, isprime, factorint
print(binomial(5, 2))   # 10
print(factorial(6))     # 720
print(isprime(19))      # True
print(factorint(100))   # {2: 2, 5: 2}Mogelijk gemaakt door

10
720
True
{2: 2, 5: 2}Mogelijk gemaakt door

10
720
True
{2: 2, 5: 2}Mogelijk gemaakt door

Samen laten deze functies zien hoe SymPy discrete wiskunde moeiteloos en nauwkeurig afhandelt. Je kunt ook direct werken met partities, permutaties en combinaties.

Toepassingen in meetkunde en natuurkunde

SymPy is niet alleen bedoeld voor algebra en analyse; het biedt ook speciale modules voor meetkunde en natuurkunde. 

In de meetkundemodule kun je wiskundige objecten definiëren zoals punten, lijnen, cirkels en veelhoeken. Met symbolen kun je ook vergelijkingen van lijnen, snijpunten, afstanden en middenpunten bepalen. 

Om bijvoorbeeld twee punten te maken en er een lijn doorheen te trekken, doe je dit:

from sympy import Point, Line, Circle

# Define two points and create a line passing through them
A, B = Point(0, 0), Point(1, 1)
L = Line(A, B)

# Print the symbolic equation of the line
print(L.equation())  Mogelijk gemaakt door

-x + yMogelijk gemaakt door

Naast de meetkundecapaciteiten biedt SymPy een zeer bruikbare natuurkundemodule. Met deze module kun je klassieke mechanica, kwantumsystemen, eenheden en grootheden modelleren.  Of je nu meters per seconde gebruikt om snelheid te berekenen of bewegingsvergelijkingen met symbolen oplost — het kan allemaal. 

from sympy.physics.units import meter, second

# Define a symbolic physical quantity: velocity = 10 meters per second
velocity = 10 * meter / second
print(velocity)Mogelijk gemaakt door

10*meter/secondMogelijk gemaakt door

Afdrukken en LaTeX-uitvoer

SymPy laat je symbolische uitdrukkingen afdrukken in meerdere indelingen, waaronder:

• Mensvriendelijke pretty printing 
• Unicode-gebaseerde uitvoer, en 
• LaTeX, de standaard opmaaktaal in publicaties en wetenschappelijke documentatie. 

Met functies zoals pprint() laat je je vergelijkingen er netjes en professioneel uitzien in een Jupyter-notebook of in een rapport. Met latex() maak je ze meteen geschikt voor een paper. Dat scheelt je het handmatig opmaken.

from sympy import pprint, latex, symbols

# Define x and y as symbolic variables
x, y = symbols('x y')

# Now you can perform symbolic math operations
expr = (x+y)**3

# Pretty print to the console
pprint(expr)

# Print the LaTeX string
print(latex(expr))Mogelijk gemaakt door

     3
(x + y) 
\left(x + y\right)^{3}Mogelijk gemaakt door

Codegeneratie en prestatie-optimalisatie

Hoewel SymPy uitblinkt in symbolische berekening, kun je symbolische uitdrukkingen ook omzetten in geoptimaliseerde uitvoerbare code voor numeriek gebruik met hoge prestaties.

De onderstaande code gebruikt SymPy’s hulpprogramma codegen() om automatisch C-code te genereren uit een symbolische uitdrukking, klaar voor gebruik in embedded-toepassingen.

from sympy.utilities.codegen import codegen

# Generate C code for the symbolic function and save it as 'output'
codegen(("f", x**2 + 1), "C", "output")Mogelijk gemaakt door

[('output.c',
  '/******************************************************************************\n *                      Code generated with SymPy 1.14.0                      *\n *                                                                            *\n *              See http://www.sympy.org/ for more information.               *\n *                                                                            *\n *                       This file is part of \'project\'                       *\n ******************************************************************************/\n#include "output.h"\n#include <math.h>\n\ndouble f(double x) {\n\n   double f_result;\n   f_result = pow(x, 2) + 1;\n   return f_result;\n\n}\n'),
 ('output.h',
  "/******************************************************************************\n *                      Code generated with SymPy 1.14.0                      *\n *                                                                            *\n *              See http://www.sympy.org/ for more information.               *\n *                                                                            *\n *                       This file is part of 'project'                       *\n ******************************************************************************/\n\n\n#ifndef PROJECT__OUTPUT__H\n#define PROJECT__OUTPUT__H\n\ndouble f(double x);\n\n#endif\n\n")]Mogelijk gemaakt door

Lambdify

De functie lambdify() zet symbolische uitdrukkingen om naar snelle numerieke Python-functies. In het voorbeeld hieronder wordt lambdify gebruikt om de symbolische uitdrukking opgeslagen in het object f om te zetten naar een snelle, NumPy-compatibele Python-functie. Bij evaluatie op de array [1, 2, 3] geeft die [4, 9, 16] terug. 

from sympy import lambdify
import numpy as np

# Convert the symbolic expression into a fast numerical function using NumPy
f = lambdify(x, x**2 + 2*x + 1, 'numpy')

# Evaluate the function on a NumPy array
print(f(np.array([1, 2, 3])))Mogelijk gemaakt door

[ 4  9 16]Mogelijk gemaakt door

Prestatieoverwegingen

Omdat SymPy gericht is op symbolische nauwkeurigheid, kan het langzamer zijn dan numerieke berekeningen. Toch zijn er verschillende manieren om de prestaties te verbeteren bij grote of complexe uitdrukkingen. 

Zo kun je lambdify() gebruiken om symbolische uitdrukkingen om te zetten in snelle numerieke functies die goed samenwerken met NumPy, of je kunt uitdrukkingen vereenvoudigen vóór evaluatie. 

Je kunt zware berekeningen verder versnellen met technieken zoals common subexpression elimination, automatische codecompilatie en integratie met externe tools zoals Numba of Cython.

SymPy in het Python-ecosysteem

SymPy staat niet op zichzelf — het integreert goed met andere populaire tools die worden gebruikt in data science, onderwijs en onderzoek en past naadloos in het bredere wetenschappelijke Python-ecosysteem.

Integratie met andere bibliotheken

Je kunt SymPy combineren met:

• NumPy/SciPy voor numeriek rekenwerk met hoge prestaties
• Matplotlib voor visualisatie
• Pandas voor symbolische data-analyse

import numpy as np
from sympy import lambdify

# Convert the symbolic expression x^2 into a fast NumPy-compatible function
f = lambdify(x, x**2, 'numpy')

# Evaluate the function on a NumPy array from 0 to 4
print(f(np.arange(5)))Mogelijk gemaakt door

[ 0  1  4  9 16]Mogelijk gemaakt door

Onderwijstoepassingen

SymPy wordt veel gebruikt in klaslokalen en bij zelfstudie omdat het aansluit bij hoe wiskunde op papier wordt onderwezen — stap voor stap en symbolisch. In Jupyter Notebooks kunnen studenten live experimenteren met algebra-, analyse- of natuurkundevergelijkingen en exacte symbolische resultaten zien in plaats van grove benaderingen. Zie Jupyter Notebook Cheat Sheet om te beginnen.

Gerelateerde projecten en integraties

SymPy sluit ook goed aan op andere krachtige wiskundige tools, zoals:

• SageMath — een grootschalig wiskundesysteem dat SymPy als backend gebruikt.
• SymEngine — een snellere, in C++ herimplementatie van de kern van SymPy.
• Pyomo — integreert optimalisatie-modellering (zie Optimaliseren met Pyomo).

Community, bijdragen en ontwikkeling

SymPy bloeit dankzij een sterke open-sourcegemeenschap. Een wereldwijde groep ontwikkelaars, onderzoekers, docenten en studenten werkt aan SymPy en maakt het dag na dag beter en robuuster. Iedereen kan helpen, vragen stellen of meedoen — zonder toestemming of bedrijfslidmaatschap.

Bijdragen en ontwikkeling

Wie wil bijdragen, forkt doorgaans de repository, brengt wijzigingen aan, draait de testsuite met pytest en stuurt vervolgens een pull request in voor review.

Om ervoor te zorgen dat elke wijziging betrouwbaar is, doorloopt die een code-reviewproces. Het project heeft ook een testframework, zodat bijdragers tests lokaal kunnen draaien voordat ze inzenden. 

Bugs melden en ondersteuning zoeken

Voor bugs of hulp:

• Meld issues op GitHub onder SymPy Issues
• Stel vragen op Stack Overflow 
• Word lid van de SymPy Gitter of mailinglijst

Hoe duidelijker je het probleem uitlegt — inclusief de code, wat je verwachtte, wat er daadwerkelijk gebeurde en welke versie van SymPy je gebruikt — hoe sneller de community kan helpen. 

Toekomstige richting

SymPy blijft groeien, met doorlopend werk aan het uitbreiden van features, het verbeteren van prestaties en integratie met AI-tools. Ook wordt gewerkt aan betere codegeneratie, documentatie en onderwijstoepassingen. Nieuwe bijdragers zijn extra welkom om te helpen met het doorspitten van bugs en issues, het verbeteren van documentatie en het toevoegen van nieuwe features voor symbolische wiskunde.

Conclusie

SymPy is een krachtige bibliotheek waarmee je symbolische wiskunde in Python kunt gebruiken. Dat maakt het nuttig voor onderwijs, onderzoek en zelfs voor toegepaste engineering. Het biedt een open-source-ecosysteem waarin je allerlei wiskundige en algebraïsche bewerkingen en transformaties kunt uitvoeren. SymPy is een tool die studenten, ontwikkelaars en onderzoekers zouden moeten verkennen. Dus ga je gang — open een Jupyter-notebook, importeer sympy en begin met ontdekken. 

Je kunt ook terecht bij de volgende bronnen voor verdere verdieping:

• SciPy Cheat Sheet: Lineaire algebra in Python
• SymPy-documentatie
• Een getal kwadrateren in Python