SymPy: Python’da Sembolik Matematik için Eksiksiz Rehber

Python’ın cebirsel işlemleri bir matematikçi gibi gerçekleştirmesini ve ifade etmesini hiç istediniz mi? SymPy tam da bunun için var.

SymPy, Symbolic Python’ın kısaltmasıdır ve sembolik hesaplamalar yapmak için geliştirilmiş bir kütüphanedir; yani kağıt üzerinde yaptığınız gibi ifadeleri açabilir, sadeleştirebilir, türev alabilir ve denklemleri sembolik olarak çözebilir.  Önemli bir uzantı olarak, değeri henüz atanmamış değişkenler içeren matematiksel ifadeler sembolik biçimde bırakılır. Örneğin, sekizin karekökü 2,828’e yuvarlanmak yerine 2*sqrt(2) olarak temsil edilir.   

SymPy’nin başlıca avantajlarından bazıları açık kaynaklı olması, tamamen Python ile yazılmış olması ve diğer Python kütüphaneleriyle uyumluluk sunmasıdır. 

Sympy’nin başlıca avantajları. Kaynak: Görsel Napkin AI

SymPy’nin Kısa Tarihi

SymPy basit bir fikirle başladı: sembolik hesaplamayı herkes için erişilebilir kılmak.

2006’da Nevada Üniversitesi’nden Ondřej Čertík tarafından başlatıldı. Amacı, Maple veya Mathematica gibi büyük bilgisayar cebiri sistemlerinin karmaşıklıklarıyla uğraşmadan saf Python ile hafif ve esnek bir sembolik matematik kütüphanesi oluşturmaktı. 

2007 ile 2010 arasında, Google Summer of Code katılımlarıyla birlikte sadeleştirme, çözümleme ve kalkülüs gibi çekirdek modüller önemli ölçüde genişletildi ve SymPy hızla büyüdü. 

Yaklaşık 2012’ye gelindiğinde, SymPy olgunlaşarak SageMath’e entegre edildi; bu da daha geniş bilimsel Python ekosistemi içinde güvenilir bir sembolik arka uç olarak tanındığını gösterdi. Bugün SymPy, cebirin ötesine geçerek fizik, geometri, kombinatorik, kod üretimi ve performans odaklı derleme araçları gibi ileri alanlara da evrilmiştir.

SymPy’ye Başlarken

SymPy’nin sihrini keşfetmeden önce, kurulumu doğru yapalım.

Kurulum ve yapılandırma

SymPy’yi kurmanın en kolay ve önerilen yolu pip kullanmaktır:

pip install sympyAltyapı:

Conda kullanıyorsanız komut şudur:

conda install sympyAltyapı:

Alternatif olarak, doğrudan kaynaktan da kurabilirsiniz (katkıda bulunanlar için yararlı):

git clone https://github.com/sympy/sympy.gitAltyapı:

Bağımlılıkları merak ediyorsanız: SymPy tamamen Python içinde çalışır ve harici kütüphanelere bağlı değildir. mpmath gibi isteğe bağlı paketler keyfi hassasiyetli aritmetik için kurulabilir:

pip install mpmathAltyapı:

Kurulumu doğrulama

Kurulumu doğrulamak için Python’u açın ve şunu yazın:

import sympy
print(sympy.__version__)Altyapı:

1.14.0Altyapı:

Çıktı, yüklü paket sürümünü gösterir.  Paketi şimdi basit bir ifadeyle test edebilirsiniz:

from sympy import symbols

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

print((x + 2)**2)Altyapı:

(x + 2)**2Altyapı:

Sorun giderme için:

• ModuleNotFoundError görürseniz, pip install sympy komutunu yeniden çalıştırın.

• Sürüm çakışmaları için pip’i yükseltin: pip install --upgrade pip

Ayrıca bilmenizde fayda var: Eğer bir hata olduğunu düşünüyorsanız ya da bir özellik talep etmek istiyorsanız, bir issue bileti açabilirsiniz. Kurulum yöntemlerini ayrıntılı incelemek için resmi dokümantasyona göz atın.

Temel kullanım

SymPy, cebirsel ifadeleri sembolik olarak işleyebileceğiniz etkileşimli bir ortam sunar.

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)Altyapı:

x**2 + 2*x*y + y**2Altyapı:

Yukarıdaki x**2 + 2*x*y + y**2 çıktısı, tam açılmış biçimi gösterir ve SymPy’nin sayısal hesaplama yerine nasıl kesin sembolik cebir yaptığını ortaya koyar.

Çekirdek Özellikler ve İşlevler

Çekirdek işlevler sembolik hesaplama üzerine kuruludur — yani sayılar yerine sembollerle çalışan fonksiyonlar, denklemler ve ifadelerle ilgilenir.

Aritmetik işlemler

Sembolik değişkenleri cebirsel değişkenler gibi ele alabilirsiniz. Ayrıca, aşağıdaki kodda gösterildiği gibi fonksiyonlar bir biçimden diğerine dönüştürülebilir. 

expand() ile dağıtma ve factor() ile tersine sadeleştirme kullanarak, SymPy bir cebirsel ifadeyi açılmış ve çarpanlarına ayrılmış durumlar arasında dönüştürür.

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)) Altyapı:

x**2 + 2*x*y + y**2
(x + y)**2Altyapı:

Sadeleştirme teknikleri

Sadeleştirme, sembolik hesaplamanın merkezindedir. Sympy’de simplify() adlı genel bir fonksiyon vardır; rasyonel, trigonometrik veya cebirsel ifadeleri kolayca sadeleştirmek için kullanılır.

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)) Altyapı:

Yukarıda simplify() ve trigsimp() fonksiyonlarının her ikisinin çıktısı da birdir. 

Kalkülüs işlemleri

SymPy, kalkülüs için harikadır; çünkü türev alma, integral, limit ve hatta seri açılımlarını, elde çözer gibi ama mükemmel doğrulukla sembolik olarak yapmanızı sağlar.

Türev alma

Türev almak için diff() fonksiyonunu kullanın.

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)Altyapı:

3*x**2 + 4*x + 1Altyapı:

İntegral

Aşağıdaki kod, f sembolik ifadesinin x değişkenine göre belirsiz integralini SymPy’nin integrate() fonksiyonuyla hesaplar. Ortaya çıkan antitürev daha sonra yazdırılır.

from sympy import integrate

# Compute the indefinite integral of the expression f with respect to x
integral = integrate(f, x)
print(integral)Altyapı:

x**4/4 + 2*x**3/3 + x**2/2Altyapı:

Limitler

Limit hesabı klasik bir kalkülüs işlemidir ve SymPy’nin limit() fonksiyonu ile yapılabilir. Söz dizimi: limit(f(x), x, x0).  Örneğin, aşağıdaki kod sin(x)/x ifadesinin x sıfıra yaklaşırken limitini hesaplar ve tam sonucu, one, yazdırır. 

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) Altyapı:

Seri açılımı

series() fonksiyonu bir matematiksel ifadenin belirli bir nokta etrafındaki Taylor ya da kuvvet serisi açılımını hesaplamak için kullanılabilir.

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))Altyapı:

1 + x + x**2/2 + x**3/6 + x**4/24 + O(x**5)Altyapı:

Toplamalar

SymPy’deki summation() fonksiyonu, matematikteki sigma gösteriminde olduğu gibi belirli bir aralıkta tam sembolik toplam alır.

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)))  Altyapı:

5269/3600Altyapı:

Denklem çözme

SymPy, sembolik denklemleri çözmeyi kolaylaştırır — yalnızca basit cebirsel olanları değil, denklem sistemlerini, diferansiyel denklemleri ve yalnızca tamsayı çözümleri olan Diofant denklemlerini de. 

Şu güçlü çözücülere sahiptir: 

• solve() cebirsel denklemler için, 

• linsolve() doğrusal sistemler için ve 

• dsolve() mümkün olduğunda tam çözümler veren diferansiyel denklemler için. 

Cebirsel denklemler

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)) Altyapı:

[-2, 2]Altyapı:

Denklem sistemleri

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)Altyapı:

{(3, 2)}Altyapı:

Diferansiyel denklemler

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))Altyapı:

Eq(y(x), C1*exp(-x) + C2*exp(x))Altyapı:

Matris işlemleri

SymPy, sembolik matrisleri desteklediği için lineer cebir için harika bir araçtır. Matrislerle kolayca çalışabilir ve tıpkı klasik cebirde olduğu gibi toplama ve çarpma gibi işlemleri yapabilirsiniz. 

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)Altyapı:

Matrix([[x + 8], [x**2 + 12]])Altyapı:

İleri düzey işlemler

SymPy, determinant, ters, özdeğerler ve özvektörler gibi önemli matris özelliklerini de sembolik olarak hesaplamanıza olanak tanır ve size tam sonuçlar verir. 

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

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

# Compute the eigenvalues of matrix A
A.eigenvals() Altyapı:

{2 - sqrt(2*x + 1): 1, sqrt(2*x + 1) + 2: 1}Altyapı:

Grafik çizim yetenekleri

SymPy yalnızca sembolik hesaplamayla sınırlı değildir — matematiksel ifadelerin görselleştirilmesini de destekler. Yerleşik çizim araçlarını kullanarak, birkaç satır kodla sembolik fonksiyonların 2B ve hatta 3B grafiklerini üretebilirsiniz. 

Örneğin, aşağıdaki kod 2B bir grafik üretir:  

from sympy.plotting import plot


# Plot the function x^2 over the range -5 to 5
plot(x**2, (x, -5, 5))Altyapı:

SymPy kullanılarak oluşturulan 2B grafik. 

3B grafik oluşturmak için aşağıda gösterildiği gibi plot3d() fonksiyonunu kullanabilirsiniz.

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))Altyapı:

SymPy’nin 3B Grafik Çizim Yeteneği

Daha fazla kontrol veya stil ihtiyacınız varsa, SymPy Matplotlib ile de entegre olabilir ve tamamen özelleştirilebilir görselleştirmeler sağlar. Daha ileri düzey görselleştirmeler için, Plotly Shapes eğitimimize göz atın.

İleri Düzey Yetenekler

SymPy temel cebirin çok ötesine geçer — polinomlar, kombinatorik ve hatta fiziğe kadar uzanır.

Polinom işlemleri

Polinomları kolayca tanımlayabilir ve işleyebilirsiniz. Aşağıdaki kod, ifadeden bir polinom nesnesi oluşturur; ardından derecesini ve SymPy’nin Poly() fonksiyonunu kullanarak katsayılarıyla birlikte çarpanlarına ayrılmış hâlini yazdırır. 

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())  Altyapı:

3
(1, [(Poly(x - 3, x, domain='ZZ'), 1), (Poly(x**2 + 1, x, domain='ZZ'), 1)])Altyapı:

Karmaşık polinom sistemleri için Gröbner tabanları desteklenir; bu, polinom denklem sisteminin çözmeyi kolaylaştıran sadeleştirilmiş ve standartlaştırılmış bir sürümüdür. 

Örneğin, aşağıdaki kod [x*y - 1, y - x] polinom sistemi için Gröbner tabanını hesaplar; yani denklemleri çözmeyi kolaylaştıran, daha düzenli bir biçimde yeniden yazar. Çıktı, sistemin x = y ve y² = 1 gibi daha temiz denklemlerle eşdeğer olduğunu ve artık doğrudan çözülebileceğini gösterir.

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))Altyapı:

GroebnerBasis([x - y, y**2 - 1], x, y, domain='ZZ', order='lex')Altyapı:

Kombinatorik, ayrık matematik ve sayı kuramı

SymPy, kombinatorik ve sayı kuramı problemlerini ele almasını sağlayan çeşitli araçlara sahiptir. 

Örneğin, aşağıdaki kodda:

• binomial(5, 2) 5 öğeden 2’sinin seçilme sayısını (bir kombinasyon problemi) hesaplar, 

• factorial(6) 6! hesaplar; bu, permütasyonlarda yaygın bir işlemdir. 

• isprime(19) 19’un asal olup olmadığını kontrol eder ve 

• factorint(100) sayının tam asal çarpanlarına ayrımını {2: 2, 5: 2} olarak döndürür. 

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}Altyapı:

10
720
True
{2: 2, 5: 2}Altyapı:

10
720
True
{2: 2, 5: 2}Altyapı:

Birlikte ele alındığında, bu fonksiyonlar SymPy’nin ayrık matematiği ne kadar kolay ve doğru bir şekilde ele aldığını gösterir. Doğrudan bölmeler, permütasyonlar ve kombinasyonlarla da çalışabilirsiniz.

Geometri ve fizik uygulamaları

SymPy yalnızca cebir ve kalkülüs için değildir; geometri ve fizik için de özel modüller sunar. 

Geometri modülünde, nokta, doğru, çember ve çokgen gibi matematiksel nesneleri tanımlayabilirsiniz. Semboller kullanarak doğruların denklemlerini, kesişimleri, uzaklıkları ve orta noktaları da elde edebilirsiniz. 

Örneğin, iki nokta oluşturmak ve aralarından bir doğru geçirmek için şunu yapmanız yeterli:

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())  Altyapı:

-x + yAltyapı:

Geometri yeteneklerine ek olarak, SymPy çok kullanışlı bir fizik modülü de sağlar. Bu modülle klasik mekaniği, kuantum sistemlerini, birimleri ve büyüklükleri modelleyebilirsiniz.  İster hız bulmak için metre/saniye kullanın ister hareket denklemlerini sembollerle çözün, geçerlidir. 

from sympy.physics.units import meter, second

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

10*meter/secondAltyapı:

Yazdırma ve LaTeX çıktısı

SymPy, sembolik ifadeleri şu formatlar dahil olmak üzere birden çok biçimde yazdırmanıza olanak tanır:

• İnsan dostu güzel yazdırma 
• Unicode tabanlı çıktı ve 
• Araştırma makaleleri ve bilimsel dokümantasyonda standart biçimlendirme dili olan LaTeX. 

Jupyter defterinde ya da bir rapor üretirken denklemlerinizi düzenli ve profesyonel göstermek için pprint() gibi fonksiyonları kullanabilirsiniz. Hatta latex() ile araştırma makalesine hazır hâle getirebilirsiniz. Her şeyi kendiniz biçimlendirme zahmetinden kurtarır.

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))Altyapı:

     3
(x + y) 
\left(x + y\right)^{3}Altyapı:

Kod Üretimi ve Performans İyileştirme

SymPy sembolik hesaplamada mükemmel olsa da, sembolik ifadeleri yüksek performanslı sayısal kullanım için optimize edilmiş yürütülebilir koda dönüştürmenize de olanak tanır.

Aşağıdaki kod, SymPy’nin codegen() aracını kullanarak sembolik bir ifadeden otomatik olarak C dili kodu üretir; gömülü uygulamalarda kullanıma hazır hâle getirir.

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")Altyapı:

[('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")]Altyapı:

Lambdify

lambdify() fonksiyonu, sembolik ifadeleri hızlı sayısal Python fonksiyonlarına dönüştürür. Örneğin, aşağıdaki kod lambdify kullanarak f nesnesinde saklanan sembolik ifadeyi hızlı, NumPy uyumlu bir Python fonksiyonuna çevirir. [1, 2, 3] dizisi üzerinde değerlendirildiğinde [4, 9, 16] döndürür. 

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])))Altyapı:

[ 4  9 16]Altyapı:

Performansla ilgili hususlar

SymPy sembolik doğruluğa odaklandığından, sayısal hesaplamalara göre daha yavaş olabilir. Bununla birlikte, büyük veya karmaşık ifadelerle çalışırken performansı artırmanın çeşitli yolları vardır. 

Örneğin, lambdify() kullanarak sembolik ifadeleri NumPy ile iyi çalışan hızlı sayısal fonksiyonlara dönüştürebilir veya değerlendirmeden önce sadeleştirebilirsiniz. 

Ortak alt ifade yok etme, otomatik kod derleme ve Numba veya Cython gibi harici araçlarla entegrasyon gibi teknikleri kullanarak ağır hesaplamaları daha da hızlandırabilirsiniz.

Python Ekosisteminde SymPy

SymPy tek başına çalışmaz — veri bilimi, eğitim ve araştırmada kullanılan diğer popüler araçlarla iyi entegre olur ve daha geniş bilimsel Python ekosistemine sorunsuz uyum sağlar.

Diğer kütüphanelerle entegrasyon

SymPy’yi şunlarla birleştirebilirsiniz:

• NumPy/SciPy yüksek performanslı sayısal işlemler için
• Matplotlib görselleştirme için
• Pandas sembolik veri analizi için

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)))Altyapı:

[ 0  1  4  9 16]Altyapı:

Eğitsel uygulamalar

SymPy, matematiğin kağıt üzerinde öğretildiği şekli — adım adım ve sembolik olarak — yansıttığı için sınıflarda ve kendi kendine öğrenme ortamlarında yaygın olarak kullanılır. Jupyter Notebook’larda öğrenciler cebir, kalkülüs veya fizik denklemleriyle canlı olarak deney yapabilir ve kaba yaklaşımlar yerine tam sembolik sonuçlar görebilir. Başlamak için Jupyter Notebook Cheat Sheet’ine bakın.

İlgili projeler ve entegrasyonlar

SymPy, şu güçlü matematik araçlarıyla da iyi bağlanır:

• SageMath — SymPy’yi arka uç olarak kullanan kapsamlı bir matematik sistemi.
• SymEngine — SymPy çekirdeğinin daha hızlı, C++ ile yeniden uygulanmış hâli.
• Pyomo — optimizasyon modellemesini entegre eder (bkz. Pyomo ile Optimizasyon).

Topluluk, Katkı ve Geliştirme

SymPy güçlü bir açık kaynak topluluğu sayesinde gelişmektedir. Dünyanın dört bir yanından geliştiriciler, araştırmacılar, öğretmenler ve öğrenciler SymPy üzerinde çalışarak onu günden güne daha iyi ve sağlam hâle getiriyor. Herkes izin ya da kurumsal üyelik gerekmeksizin yardım edebilir, soru sorabilir veya dahil olabilir.

Katkı ve geliştirme

Katkı sağlamak isteyenler genellikle depoyu çatallayıp değişiklik yapar, pytest ile test paketini çalıştırır ve inceleme için bir çekme isteği gönderir.

Her değişikliğin güvenilir olmasını sağlamak için kod inceleme sürecinden geçer. Projenin ayrıca, katılımcıların göndermeden önce kendi makinelerinde testleri çalıştırmasına imkân veren bir test çerçevesi vardır. 

Hata bildirme ve destek alma

Hatalar veya yardım için:

• GitHub’da şu başlık altında kayıt açın: SymPy Issues
• Stack Overflow’da sorun 
• SymPy Gitter veya e-posta listesine katılın

Kodu, beklenen sonucu, gerçekte olanı ve kullandığınız SymPy sürümünü de dahil ederek sorunu ne kadar net anlatırsanız topluluk o kadar hızlı yardımcı olabilir. 

Gelecek yönelimler

SymPy hâlen büyümektedir; özelliklerini genişletmeye, performansını iyileştirmeye ve yapay zekâ araçlarıyla bütünleşmeye yönelik çalışmalar sürmektedir. Kod üretimi, dokümantasyon ve eğitsel kullanımın daha iyi hâle getirilmesi için de çabalar vardır. Yeni katkıcılar özellikle hataları ve konuları tasnif etmeye, dokümantasyonu geliştirmeye ve sembolik matematik için yeni özellikler eklemeye davetlidir.

Sonuç

SymPy, Python’da sembolik matematik kullanmanızı sağlayan güçlü bir kütüphanedir. Bu da onu eğitim, araştırma ve hatta gerçek dünyadaki mühendislik çalışmaları için kullanışlı kılar. Açık kaynaklı bir ekosistem sunar; bu ekosistem içinde çeşitli matematiksel ve cebirsel işlemleri ve dönüşümleri gerçekleştirebilirsiniz. SymPy, öğrencilerin, geliştiricilerin ve araştırmacıların göz atması gereken bir araçtır. Öyleyse başlayın — bir Jupyter defteri açın, sympy’yi içe aktarın ve keşfe çıkın. 

Ayrıca daha fazla okuma için aşağıdaki kaynaklara başvurabilirsiniz:

• SciPy Cheat Sheet: Python’da Lineer Cebir
• SymPy Dokümantasyonu
• Python’da Bir Sayının Karesi Nasıl Alınır