SymPy: guida completa alla matematica simbolica in Python

Se hai mai desiderato che Python eseguisse ed esprimesse operazioni algebriche come un matematico, SymPy è la risposta.

SymPy sta per Symbolic Python ed è una libreria creata per eseguire calcoli simbolici, il che significa che può espandere, semplificare, derivare e risolvere equazioni in modo simbolico, proprio come faresti su carta. Un'estensione importante è che le espressioni matematiche con variabili non valutate rimangono in forma simbolica. Per esempio, la radice quadrata di otto sarà rappresentata come 2*sqrt(2), invece di approssimarla a 2,828.   

Alcuni dei principali vantaggi di SymPy sono che è open source, scritto interamente in Python e offre compatibilità con altre librerie Python. 

Vantaggi principali di Sympy. Fonte: immagine di Napkin AI

Breve storia di SymPy

SymPy è nato da un'idea semplice: rendere il calcolo simbolico accessibile a tutti.

È stato avviato nel 2006 da Ondřej Čertík, uno studente dell'Università del Nevada. Voleva creare una libreria di matematica simbolica leggera e flessibile in puro Python, così che le persone non dovessero affrontare le complessità dei grandi sistemi di algebra computazionale come Maple o Mathematica. 

Tra il 2007 e il 2010, SymPy è cresciuto rapidamente grazie alla partecipazione al Google Summer of Code, durante il quale moduli core come semplificazione, risoluzione e calcolo sono stati notevolmente ampliati. 

Intorno al 2012, SymPy aveva raggiunto una maturità tale da essere integrato in SageMath, segnalandone il riconoscimento come affidabile backend simbolico all'interno del più ampio ecosistema scientifico Python. Oggi SymPy si è evoluto oltre l'algebra, entrando in domini avanzati tra cui fisica, geometria, combinatoria, generazione di codice e strumenti di compilazione orientati alle prestazioni.

Primi passi con SymPy

Prima di esplorare la magia di SymPy, configuriamolo correttamente.

Installazione e configurazione

Il modo più semplice per installare SymPy, nonché quello consigliato, è usare pip:

pip install sympyOfferto da

Se usi Conda, il comando è:

conda install sympyOfferto da

In alternativa, puoi installarlo direttamente dal sorgente (utile per i contributori):

git clone https://github.com/sympy/sympy.gitOfferto da

Se ti stai chiedendo delle dipendenze: SymPy gira interamente in Python e non dipende da librerie esterne. Pacchetti opzionali come mpmath possono essere installati per l'aritmetica a precisione arbitraria:

pip install mpmathOfferto da

Verifica dell'installazione

Per confermare l'installazione, apri Python e digita:

import sympy
print(sympy.__version__)Offerto da

1.14.0Offerto da

L'output mostra la versione installata del pacchetto. Ora puoi testare il pacchetto con una semplice espressione:

from sympy import symbols

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

print((x + 2)**2)Offerto da

(x + 2)**2Offerto da

Per la risoluzione dei problemi:

• Se vedi ModuleNotFoundError, esegui di nuovo pip install sympy.

• Per conflitti di versione, aggiorna pip: pip install --upgrade pip

Inoltre, è utile sapere: se pensi ci sia un bug o vuoi richiedere una funzionalità, puoi anche aprire un ticket. Per un approfondimento sui metodi di installazione, consulta la documentazione ufficiale.

Utilizzo di base

SymPy offre un ambiente interattivo in cui puoi manipolare espressioni algebriche in modo simbolico.

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)Offerto da

x**2 + 2*x*y + y**2Offerto da

L'output stampato sopra x**2 + 2*x*y + y**2 è la forma completamente espansa, che mostra come SymPy esegua algebra simbolica esatta piuttosto che calcolo numerico.

Funzionalità e caratteristiche principali

Le funzionalità principali ruotano attorno al calcolo simbolico — cioè lavorare con funzioni, equazioni ed espressioni come simboli invece che come numeri.

Operazioni aritmetiche

Puoi trattare le variabili simboliche come quelle algebriche. Inoltre, le funzioni possono passare da una forma all'altra come mostrato nel codice seguente. 

Usando expand() per la distribuzione e factor() per la semplificazione inversa, SymPy trasforma tra forme espanse e fattorizzate di un'espressione algebrica.

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)) Offerto da

x**2 + 2*x*y + y**2
(x + y)**2Offerto da

Tecniche di semplificazione

La semplificazione è centrale nel calcolo simbolico. Esiste una funzione generale in Sympy, chiamata simplify(), che viene usata per semplificare facilmente espressioni razionali, trigonometriche o algebriche.

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)) Offerto da

L'output in entrambe le funzioni simplify() e trigsimp() sopra risulta uno. 

Operazioni di calcolo

SymPy è ottimo per il calcolo perché ti permette di eseguire derivazione, integrazione, limiti e persino sviluppi in serie, tutto simbolicamente, proprio come risolvere a mano ma con precisione perfetta.

Derivazione

Per calcolare le derivate, usa la funzione 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)Offerto da

3*x**2 + 4*x + 1Offerto da

Integrazione

Il codice seguente calcola l'integrale indefinito dell'espressione simbolica f rispetto alla variabile x usando la funzione integrate() di SymPy. L'anti-derivata risultante viene quindi stampata.

from sympy import integrate

# Compute the indefinite integral of the expression f with respect to x
integral = integrate(f, x)
print(integral)Offerto da

x**4/4 + 2*x**3/3 + x**2/2Offerto da

Limiti

Il calcolo del limite è un'operazione classica del calcolo, che può essere eseguita con la funzione limit() di SymPy. La sintassi è: limit(f(x), x, x0).  Per esempio, il codice seguente calcola il limite dell'espressione sin(x)/x quando x tende a zero e stampa il risultato esatto, uno. 

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) Offerto da

Sviluppo in serie

La funzione series() può essere usata per calcolare lo sviluppo in serie di Taylor o di potenze di un'espressione matematica attorno a un punto specificato.

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))Offerto da

1 + x + x**2/2 + x**3/6 + x**4/24 + O(x**5)Offerto da

Somme

La funzione summation() in SymPy esegue somme simboliche esatte su un certo intervallo, proprio come la notazione sigma in matematica.

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)))  Offerto da

5269/3600Offerto da

Risoluzione di equazioni

SymPy rende facile risolvere equazioni simboliche — non solo quelle algebriche semplici, ma anche sistemi di equazioni, equazioni differenziali e perfino equazioni diofantee, che hanno solo interi come soluzioni. 

Dispone di potenti solver come 

• solve() per equazioni algebriche, 

• linsolve() per sistemi lineari, e 

• dsolve() per equazioni differenziali che forniscono soluzioni esatte quando possibile. 

Equazioni algebriche

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)) Offerto da

[-2, 2]Offerto da

Sistemi di equazioni

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)Offerto da

{(3, 2)}Offerto da

Equazioni differenziali

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))Offerto da

Eq(y(x), C1*exp(-x) + C2*exp(x))Offerto da

Operazioni con le matrici

SymPy è un ottimo strumento per l'algebra lineare poiché supporta matrici simboliche. Puoi lavorare facilmente con le matrici ed eseguire operazioni matematiche come addizione e moltiplicazione, proprio come in 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)Offerto da

Matrix([[x + 8], [x**2 + 12]])Offerto da

Operazioni avanzate

SymPy ti permette anche di calcolare in modo simbolico proprietà importanti delle matrici come determinanti, inverse, autovalori e autovettori, fornendo risposte esatte. 

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

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

# Compute the eigenvalues of matrix A
A.eigenvals() Offerto da

{2 - sqrt(2*x + 1): 1, sqrt(2*x + 1) + 2: 1}Offerto da

Capacità di plotting

SymPy non è limitato al calcolo simbolico — supporta anche la visualizzazione di espressioni matematiche. Usando le utility di plotting integrate, puoi generare grafici 2D e persino 3D di funzioni simboliche con poche righe di codice. 

Per esempio, il codice seguente genera un grafico 2D:  

from sympy.plotting import plot


# Plot the function x^2 over the range -5 to 5
plot(x**2, (x, -5, 5))Offerto da

Grafico 2D generato con SymPy. 

Per generare grafici 3D, puoi usare la funzione plot3d() come mostrato di seguito.

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))Offerto da

Capacità di plotting 3D di SymPy

E se ti serve più controllo o stile, SymPy può anche integrarsi con Matplotlib per abilitare visualizzazioni completamente personalizzabili. Per visualizzazioni più avanzate, leggi la nostra guida su Plotly Shapes.

Capacità avanzate

SymPy va ben oltre l'algebra di base — si estende ai polinomi, alla combinatoria e persino alla fisica.

Manipolazione di polinomi

Puoi definire e manipolare polinomi facilmente. Il codice seguente crea un oggetto polinomiale dall'espressione e poi ne stampa il grado, la forma fattorizzata con coefficienti usando la funzione Poly() di SymPy. 

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())  Offerto da

3
(1, [(Poly(x - 3, x, domain='ZZ'), 1), (Poly(x**2 + 1, x, domain='ZZ'), 1)])Offerto da

Per sistemi polinomiali complessi, sono supportate le basi di Gröbner, che sono una versione semplificata e standardizzata di un sistema di equazioni polinomiali, rendendole più facili da risolvere. 

Per esempio, il codice seguente calcola la base di Gröbner per il sistema polinomiale [x*y - 1, y - x], cioè riscrive le equazioni in una forma più semplice e strutturata che è più facile da risolvere. L'output mostra che il sistema è equivalente alle equazioni più pulite x = y e y² = 1, che ora possono essere risolte direttamente.

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))Offerto da

GroebnerBasis([x - y, y**2 - 1], x, y, domain='ZZ', order='lex')Offerto da

Combinatoria, matematica discreta e teoria dei numeri

SymPy ha diverse utility che gli permettono di gestire problemi combinatori e di teoria dei numeri. 

Per esempio, nel codice seguente:

• La funzione binomial(5, 2) calcola in quanti modi si possono scegliere 2 elementi da 5 (un problema di combinazioni), 

• factorial(6) calcola 6!, un'operazione comune nelle permutazioni. 

• isprime(19) verifica se 19 è un numero primo, e 

• factorint(100) restituisce la sua fattorizzazione prima esatta come {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}Offerto da

10
720
True
{2: 2, 5: 2}Offerto da

10
720
True
{2: 2, 5: 2}Offerto da

Insieme, queste funzioni mostrano come SymPy gestisca con facilità e precisione la matematica discreta. Puoi anche lavorare direttamente con partizioni, permutazioni e combinazioni.

Applicazioni in geometria e fisica

SymPy non è pensato solo per algebra e calcolo; offre anche moduli speciali per geometria e fisica. 

Nel modulo di geometria, puoi definire oggetti matematici come punti, linee, circonferenze e poligoni. Usando i simboli, puoi anche ottenere equazioni di rette, intersezioni, distanze e punti medi. 

Per esempio, per creare due punti e tracciare una retta tra di essi, fai così:

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())  Offerto da

-x + yOfferto da

Oltre alle funzionalità di geometria, SymPy fornisce un modulo di fisica molto utile. Con questo modulo puoi modellare meccanica classica, sistemi quantistici, unità e dimensioni.  Vale sia che tu stia usando metri al secondo per trovare la velocità sia che tu stia risolvendo equazioni del moto con simboli. 

from sympy.physics.units import meter, second

# Define a symbolic physical quantity: velocity = 10 meters per second
velocity = 10 * meter / second
print(velocity)Offerto da

10*meter/secondOfferto da

Stampa e output LaTeX

SymPy ti permette di stampare espressioni simboliche in più formati, tra cui:

• Pretty printing leggibile per l'uomo 
• Output basato su Unicode, e 
• LaTeX, che è il linguaggio di formattazione standard usato negli articoli di ricerca e nella documentazione scientifica. 

Puoi usare funzioni come pprint() per far apparire le tue equazioni ordinate e professionali in un Jupyter notebook o mentre prepari un report. Puoi anche usare latex() per renderle pronte per un articolo scientifico. Ti evita la fatica di dover formattare tutto a mano.

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))Offerto da

     3
(x + y) 
\left(x + y\right)^{3}Offerto da

Generazione di codice e ottimizzazione delle prestazioni

Pur eccellendo nel calcolo simbolico, SymPy ti permette anche di convertire espressioni simboliche in codice eseguibile ottimizzato per un uso numerico ad alte prestazioni.

Il codice seguente usa l'utility codegen() di SymPy per generare automaticamente codice in linguaggio C da un'espressione simbolica, rendendolo pronto per l'uso in applicazioni embedded.

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")Offerto da

[('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")]Offerto da

Lambdify

La funzione lambdify() converte espressioni simboliche in funzioni Python numeriche veloci. Per esempio, il codice qui sotto usa lambdify per convertire l'espressione simbolica memorizzata nell'oggetto f in una funzione Python compatibile con NumPy. Quando valutata sull'array [1, 2, 3], restituisce [4, 9, 16]. 

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])))Offerto da

[ 4  9 16]Offerto da

Considerazioni sulle prestazioni

Poiché SymPy punta all'accuratezza simbolica, può essere più lento dei calcoli numerici. Detto questo, ci sono diversi modi per migliorare le prestazioni quando si lavora con espressioni grandi o complicate. 

Per esempio, puoi usare lambdify() per trasformare espressioni simboliche in funzioni numeriche veloci che funzionano bene con NumPy, oppure puoi semplificarle prima di valutarle. 

Puoi accelerare ulteriormente i calcoli pesanti usando tecniche come l'eliminazione delle sottoespressioni comuni, la compilazione automatica del codice e l'integrazione con strumenti esterni come Numba o Cython.

SymPy nell'ecosistema Python

SymPy non lavora in isolamento — si integra bene con altri strumenti popolari usati in data science, istruzione e ricerca, e si inserisce perfettamente nel più ampio ecosistema scientifico di Python.

Integrazione con altre librerie

Puoi combinare SymPy con:

• NumPy/SciPy per calcolo numerico ad alte prestazioni
• Matplotlib per la visualizzazione
• Pandas per l'analisi simbolica dei dati

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)))Offerto da

[ 0  1  4  9 16]Offerto da

Applicazioni educative

SymPy è ampiamente usato in aula e in contesti di autoapprendimento perché rispecchia il modo in cui la matematica viene insegnata su carta — passo dopo passo e simbolicamente. In Jupyter Notebook, gli studenti possono sperimentare dal vivo con equazioni di algebra, calcolo o fisica e vedere risultati simbolici esatti invece di approssimazioni grossolane. Vedi Jupyter Notebook Cheat Sheet per iniziare.

Progetti correlati e integrazioni

SymPy si collega bene anche ad altri potenti strumenti matematici, come:

• SageMath — un sistema matematico su larga scala che usa SymPy come backend.
• SymEngine — una reimplementazione più veloce in C++ del core di SymPy.
• Pyomo — integra la modellazione di ottimizzazione (vedi Ottimizzazione con Pyomo).

Community, contributi e sviluppo

SymPy prospera grazie a una forte community open source. Un gruppo mondiale di sviluppatori, ricercatori, insegnanti e studenti lavora su SymPy, rendendolo ogni giorno migliore e più robusto. Chiunque può aiutare, fare domande o partecipare senza bisogno di permessi o appartenenze aziendali.

Contributi e sviluppo

Chi vuole contribuire di solito fa il fork del repository, apporta modifiche, esegue la suite di test con pytest e poi invia una pull request per la revisione.

Per assicurare l'affidabilità di ogni modifica, si passa attraverso un processo di code review. Il progetto ha anche un framework di testing in modo che i contributori possano eseguire i test in locale prima di inviare. 

Segnalazione bug e richiesta di supporto

Per bug o aiuto:

• Apri issue su GitHub sotto SymPy Issues
• Chiedi su Stack Overflow 
• Unisciti al Gitter o alla mailing list di SymPy

Più spieghi chiaramente il problema — includendo il codice, cosa ti aspettavi, cosa è successo davvero e quale versione di SymPy stai usando — più velocemente la community potrà aiutarti. 

Direzioni future

SymPy è ancora in crescita, con lavori in corso per ampliare le funzionalità, migliorarne le prestazioni e integrarsi con strumenti di IA. Ci sono anche sforzi per migliorare la generazione di codice, la documentazione e l'uso didattico. I nuovi contributori sono particolarmente benvenuti per aiutare a smaltire bug e issue, migliorare la documentazione e aggiungere nuove funzionalità per la matematica simbolica.

Conclusione

SymPy è una potente libreria che ti permette di usare la matematica simbolica in Python. Questo la rende utile per l'istruzione, la ricerca e persino per lavori ingegneristici nel mondo reale. Fornisce un ecosistema open source all'interno del quale puoi eseguire varie operazioni e trasformazioni matematiche e algebriche. SymPy è uno strumento che studenti, sviluppatori e ricercatori dovrebbero prendere in considerazione. Quindi avanti — apri un Jupyter notebook, importa sympy e inizia a esplorare. 

Puoi anche consultare le seguenti risorse per approfondire:

• Cheat Sheet di SciPy: Algebra lineare in Python
• Documentazione di SymPy
• Come elevare al quadrato un numero in Python