16  Uygulamalı Özet

Bu sayfa kitaptaki araçları ispatsız ve kısa bir başvuru kartı olarak toplar. Bir işe başlarken önce aşağıdaki tablodan hangi fonksiyonun gerektiğini bul, sonra ilgili bölümdeki kalıbı kopyalayıp kendi verine uyarla. Her bölüm en çok kullanılan çağrıları bir tabloda, kısa ve çalıştırılmış bir kod örneğini çıktısıyla, ardından sık yapılan hataları ve bir iki çözümlü örneği verir. Kodlar kendi başına çalışır; her birinin içe aktarmaları kendi içindedir. Ayrıntı ve gerekçe için her kural kitaptaki tanıma ya da bölüme bağlanmıştır.

16.1 Soru Tipine Göre Yöntem

Bir problemi okuyunca ilk iş, hangi kütüphanenin hangi fonksiyonunun o işi tek satırda yaptığını bulmaktır. Aşağıdaki tablo en sık karşılaşılan işleri araçlarla eşleştirir.

Tablo 16.1: Soru kalıpları ve araçlar
Soruda istenen Yöntem Bu sayfada
Tam sayı, kesir ya da ondalık sayıyla kesin hesap int, Fraction, Decimal Bölüm 16.2
Bir listeyi süzmek, dönüştürmek, saymak comprehension, zip, sorted(key=...) Bölüm 16.2
Hatalı girdiyi yakalamak, dosya okumak ve yazmak try/except, with open(...) Bölüm 16.3
Vektör, matris ya da ızgara kurmak, parçasını seçmek np.array, linspace, dilim, maske Bölüm 16.4
Döngüsüz satır ya da sütun hesabı axis=, broadcasting, np.where Bölüm 16.5
\(Ax = b\), determinant, rank, özdeğer, en küçük kareler np.linalg Bölüm 16.6
Grafik, kontur, histogram, yüzey fig, ax = plt.subplots() Bölüm 16.7
Kesin limit, türev, integral, seri, denklem SymPy Bölüm 16.8
Bir denklemin kökleri, bir fonksiyonun minimumu brentq, fsolve, minimize Bölüm 16.9
Sayısal türev, tablo ya da fonksiyon integrali fark bölümü, simpson, quad, dblquad Bölüm 16.10
Polinom, interpolasyon, spline, eğri uydurma Polynomial, CubicSpline, curve_fit Bölüm 16.11
Başlangıç değer problemi, sistem, olay anı solve_ivp Bölüm 16.12
Simülasyonla olasılık ya da integral kestirmek default_rng, ortalama ve standart hata Bölüm 16.13
Tablo okumak, süzmek, gruplamak pandas Bölüm 16.14

16.2 Python Temelleri

Dilin temel nesneleri sayılar ve kaplardır; işlemlerin çoğu tek bir işleç ya da tek satırlık bir comprehension ile yazılır.

Tablo 16.2: Sayılar, kaplar ve fonksiyonlar
Yazım Anlamı Ayrıntı
a // b, a % b, divmod(a, b) \(\lfloor a/b \rfloor\), kalan, ikisi birlikte Tanım 1.6
a ** b üs alma (^ başka bir işlemdir) Tanım 1.5
math.isclose(a, b, rel_tol=...) iki float’ı toleransla karşılaştır Tanım 1.9
Fraction(p, q), Decimal("0.1") kesin kesir, ondalık hesap Tanım 1.11, Tanım 1.12
3 + 4j, abs(z), z.conjugate() karmaşık sayı Tanım 1.10
f"{x:.4f}", {x:.3e}, {x:>8.2f}, {x:.1%} biçimli yazdırma Tanım 1.3
[f(k) for k in it if koşul], {k: v for ...} liste, sözlük comprehension Tanım 3.10
a[i:j:k], a[::-1] dilim, ters çevirme Tanım 3.2
zip(a, b), enumerate(a) paralel ve indisli dolaşma Tanım 3.11
sorted(a, key=len), max(a, key=f) anahtara göre sıralama, en büyük Tanım 3.12
d.get(k, 0), A & B, A - B, A ^ B sözlükte varsayılan; kesişim, fark, simetrik fark (birleşim için dikey çizgi işleci) Tanım 3.6, Tanım 3.8
lambda x: x**2, def f(x, tol=1e-10) kısa fonksiyon, varsayılan değer Tanım 2.12, Tanım 2.11
Python
import math
from fractions import Fraction

print(7 // 2, -7 // 2, 7 % 3, -7 % 3, divmod(23, 4))
print(2**100)
print(0.1 + 0.2 == 0.3, math.isclose(0.1 + 0.2, 0.3))
print(Fraction(1, 3) + Fraction(1, 6), 2 ^ 3, 2 ** 3)
z = 3 + 4j
print(abs(z), z.conjugate())
x = math.pi
print(f"{x:.4f} | {x:.3e} | {x:>8.2f} | {1/8:.1%} | {x = :.2f}")
Çıktı
3 -4 1 2 (5, 3)
1267650600228229401496703205376
False True
1/2 1 8
5.0 (3-4j)
3.1416 | 3.142e+00 |     3.14 | 12.5% | x = 3.14
Python
squares = [k**2 for k in range(1, 8)]
odd = [k for k in squares if k % 2 == 1]
cubes = {k: k**3 for k in range(1, 5)}
print(squares[2:5], squares[::-1][:3], odd)
print(cubes, cubes.get(9, 0))
A, B = {1, 2, 3, 4}, {3, 4, 5}
print(A | B, A & B, A - B, A ^ B)
for i, (c, v) in enumerate(zip("abc", [10, 20, 30])):
    print(i, c, v)
words = ["pi", "e", "phi", "gamma"]
print(sorted(words, key=len), max(words, key=len))
Çıktı
[9, 16, 25] [49, 36, 25] [1, 9, 25, 49]
{1: 1, 2: 8, 3: 27, 4: 64} 0
{1, 2, 3, 4, 5} {3, 4} {1, 2} {1, 2, 5}
0 a 10
1 b 20
2 c 30
['e', 'pi', 'phi', 'gamma'] gamma

Kısa yollar.

  • a, b = b, a % b eşzamanlı atamadır: sağ taraf önce bütünüyle hesaplanır. Öklid algoritması tek satırlık bir while döngüsüdür.
  • Bir fonksiyonun aynı argümanla tekrar tekrar çağrıldığı özyinelemede functools.cache hafızalama yapar (Tanım 2.14).
  • range(a, b) ve dilimler sağ ucu içermez: range(1, n + 1) \(1, \dots, n\)’yi verir.
UyarıSık yapılan hatalar
  • -7 // 2 sonucu -3 değil -4’tür; // daima aşağı yuvarlar.
  • 0.1 + 0.2 == 0.3 yanlıştır. float karşılaştırmasında == değil math.isclose kullanılır.
  • 2 ^ 3 üs alma değildir, değeri 1’dir; üs ** ile alınır.
  • print değer döndürmez. Sonucu kullanılacak bir fonksiyon return ile bitmelidir.
  • b = a listeyi kopyalamaz, aynı listeye ikinci bir ad verir (Tanım 3.4). Kopya için a.copy() yazılır. [[0] * 3] * 2 de iki satırı aynı liste yapar; doğrusu [[0] * 3 for _ in range(2)]’dir.

Örnek 16.1 (Rakamları Toplamı On Olan Sayılar) Rakamları toplamı \(10\) olan üç basamaklı doğal sayıların kaç tane olduğunu bir comprehension ile bulunuz.

Çözüm

Kod. Her sayıyı str ile rakamlarına ayırıp toplarız; koşulu sağlayanları bir listede toplarız.

Python
nums = [n for n in range(100, 1000)
        if sum(int(d) for d in str(n)) == 10]
print(len(nums), nums[:5], nums[-1])
Çıktı
54 [109, 118, 127, 136, 145] 910

Sağlama. Rakamlar \(a \ge 1\), \(b\), \(c\) ise \(a' = a - 1\) için \(a' + b + c = 9\) denkleminin negatif olmayan çözümleri \(\binom{11}{2} = 55\) tanedir. Bunlardan yalnız \(a' = 9\), yani \(a = 10\) olan çözüm geçersizdir; geriye \(54\) sayı kalır. \(\blacksquare\)

16.3 Hatalar, Dosyalar ve Sınıflar

Bir programın kötü girdide anlamlı bir mesajla durması ve verisini dosyadan okuyabilmesi için üç kalıp yeter: try deyimi, raise ve with open(...).

Tablo 16.3: Hata yakalama, dosyalar ve sınıflar
Kalıp Ne zaman Ayrıntı
try: … except ValueError as err: … else: … finally: beklenen bir hatayı yakalamak Tanım 4.2
raise ValueError("mesaj") geçersiz girdiyi bildirmek Tanım 4.3
assert koşul, "mesaj" kendi kodunu denetlemek Tanım 4.4
with open(ad, "w", encoding="utf-8") as f: dosyayı güvenle açıp kapatmak Tanım 4.5
csv.writer(f), csv.reader(f) CSV yazmak ve okumak Tanım 4.6
@dataclass class P: x: float __init__, __repr__, __eq__ hazır gelen sınıf Tanım 4.10
def __add__(self, other): + işlecine anlam vermek Tanım 4.8
Python
import csv

def safe_sqrt(x):
    if x < 0:
        raise ValueError(f"negatif sayı: {x}")
    return x ** 0.5

for v in [9, -4, "a"]:
    try:
        r = safe_sqrt(v)
    except ValueError as err:
        print("ValueError:", err)
    except TypeError:
        print("TypeError: sayı değil")
    else:
        print("kök:", r)

with open("kareler.csv", "w", newline="", encoding="utf-8") as f:
    w = csv.writer(f)
    w.writerow(["n", "n2"])
    w.writerows([n, n**2] for n in range(1, 4))

with open("kareler.csv", encoding="utf-8") as f:
    rows = list(csv.reader(f))
print(rows)
Çıktı
kök: 3.0
ValueError: negatif sayı: -4
TypeError: sayı değil
[['n', 'n2'], ['1', '1'], ['2', '4'], ['3', '9']]
UyarıSık yapılan hatalar
  • csv.reader her alanı str olarak verir; çıktının son satırında sayılar tırnak içindedir. Hesaptan önce int(...) ya da float(...) ile çevir.
  • Yalın except: her hatayı, yazım yanlışlarını da yutar. Yalnız beklediğin türü yakala.
  • Türkçe karakterli dosyalarda encoding="utf-8" verilmezse Windows’ta okuma bozulabilir. CSV yazarken newline="" boş satırları önler.

16.4 NumPy Dizileri

Bilimsel hesabın temel nesnesi ndarray’dir (Tanım 5.1). Aşağıdaki tablo dizi kurmanın ve parça seçmenin bütün sık kalıplarını toplar.

Tablo 16.4: Dizi kurma ve indeksleme
Yazım Sonuç Ayrıntı
np.linspace(a, b, n) \(a\)’dan \(b\)’ye \(n\) nokta, iki uç dahil Tanım 5.4
np.arange(a, b, h) \(a, a + h, \dots\); \(b\) dahil değil Tanım 5.3
np.zeros((m, n)), np.ones(n), np.eye(n, k=1) sıfır, bir, birim (ya da kaydırılmış) matris Tanım 5.1
A.shape, A.ndim, A.dtype şekil, eksen sayısı, veri türü Tanım 5.2, Tanım 5.5
A.reshape(3, 4), A.ravel(), A.T yeniden şekillendirme, düzleştirme, transpoz Tanım 5.6
A[i, j], A[i], A[:, j], A[1:3, ::2] eleman, satır, sütun, alt blok (görünüm) Tanım 5.7
A[[0, 2]], A[np.ix_(r, c)] seçilen satırlar, alt matris (kopya) Tanım 5.9
A[A > 0], A[(A > 1) & (A < 5)] koşulu sağlayan elemanlar Tanım 5.10
np.concatenate, np.vstack, np.column_stack dizileri birleştirme Tanım 5.11
B = A.copy() bağımsız kopya Tanım 5.8
Python
import numpy as np

x = np.linspace(0, 1, 5)      # uçlar dahil, 5 nokta
k = np.arange(0, 10, 3)       # 10 dahil değil
A = np.arange(1, 13).reshape(3, 4)
print(x, k)
print(A.shape, A.ndim, A.dtype)
print(A[1, 2], A[-1], A[:, 1])
print(A[0:2, 1:3])
print(A[np.ix_([0, 2], [0, 3])])
print(A[A % 5 == 0], A[(A > 3) & (A < 7)])
Çıktı
[0.   0.25 0.5  0.75 1.  ] [0 3 6 9]
(3, 4) 2 int64
7 [ 9 10 11 12] [ 2  6 10]
[[2 3]
 [6 7]]
[[ 1  4]
 [ 9 12]]
[ 5 10] [4 5 6]

Kısa yollar.

  • Köşegeninde \(2\), hemen üstünde ve altında \(-1\) olan \(n \times n\) matris döngüsüz kurulur: 2 * np.eye(n) - np.eye(n, k=1) - np.eye(n, k=-1).
  • \((i, j)\) elemanı satır öncelikli sırada A.ravel()[i * n + j]’dir (Önerme 5.1).
  • İki dizinin bellek paylaşıp paylaşmadığını np.shares_memory(a, b) söyler.
UyarıSık yapılan hatalar
  • Ondalık adımla arange fazladan bir nokta verebilir; nokta sayısı belliyse linspace kullan.
  • Dilim bir görünümdür: dilimi değiştirmek asıl diziyi de değiştirir. Fancy ve boolean indeksleme ise kopya verir (Tanım 5.8).
  • Maskelerde and, or, not değil &, |, ~ yazılır ve her koşul paranteze alınır.
  • int64 dizisine yazılan 2.9 sessizce 2 olur; int64 taşması da sessizdir (Tanım 5.5).
Python
import numpy as np

A = np.zeros((2, 3))
row = A[0]          # dilim: görünüm
sel = A[[1]]        # fancy indeksleme: kopya
row[:] = 7
sel[:] = 9
print(A)
print(np.shares_memory(A, row), np.shares_memory(A, A[0].copy()))

a = np.array([1, 2, 3])
a[0] = 2.9          # int64 dizisine yazılan float kesilir
print(a, a.dtype)
Çıktı
[[7. 7. 7.]
 [0. 0. 0.]]
True False
[2 2 3] int64

16.5 Vektörizasyon ve Broadcasting

Döngü yazmak yerine işlemi bütün diziye bir kerede uygularız: evrensel fonksiyonlar (Tanım 6.1) eleman eleman, indirgemeler bir eksen boyunca çalışır.

Tablo 16.5: İndirgeme ve seçim
Yazım Sonuç (\(A\) şekli \((m, n)\)) Ayrıntı
A.sum(), A.mean(), A.max() tek sayı Tanım 6.2
A.sum(axis=0) sütun toplamları, şekil \((n,)\) Tanım 6.2
A.sum(axis=1) satır toplamları, şekil \((m,)\) Tanım 6.2
A.max(axis=1, keepdims=True) şekil \((m, 1)\); A ile doğrudan işleme girer Tanım 6.2
np.where(koşul, a, b) koşula göre eleman eleman seçim Tanım 6.3
np.cumsum(a), np.diff(a) kısmi toplamlar, ardışık farklar Tanım 6.1
x[:, None] - y[None, :] bütün \(x_i - y_j\) farklarının tablosu Tanım 6.4
İpucuÜç adımda sonucun şeklini bulmak
  1. Hizala. İki şekli sağa yaslayarak alt alta yaz; kısa olanın soluna \(1\)’ler ekle.
  2. Karşılaştır. Her eksende uzunluklar ya eşit olmalı ya da biri \(1\) olmalı; değilse işlem ValueError verir.
  3. Büyüğü al. Sonucun her eksendeki uzunluğu iki uzunluğun büyüğüdür (Tanım 6.4).
Python
import numpy as np

A = np.array([[1, 2, 3], [4, 5, 6]])
print(A.sum(), A.sum(axis=0), A.sum(axis=1))
print(A.max(axis=1, keepdims=True).shape)
print(A - A.mean(axis=0))          # (2, 3) - (3,)
col = np.array([[10], [20]])       # (2, 1)
print(A + col)
x = np.linspace(-2, 2, 5)
print(np.where(x > 0, x, 0))
print(np.cumsum([1, 2, 3, 4]), np.diff([1, 4, 9, 16]))
Çıktı
21 [5 7 9] [ 6 15]
(2, 1)
[[-1.5 -1.5 -1.5]
 [ 1.5  1.5  1.5]]
[[11 12 13]
 [24 25 26]]
[0. 0. 0. 1. 2.]
[ 1  3  6 10] [3 5 7]

Kısa yollar. Sütunları ortalamadan çıkarmak A - A.mean(axis=0), satırları ortalamadan çıkarmak A - A.mean(axis=1, keepdims=True) ile yapılır. Bir \(f(x_i, y_j)\) tablosu için x[:, None] ile y yayılır; bu, iç içe iki döngünün yerini tutar.

UyarıSık yapılan hatalar
  • axis=0 “satırları topla” değil, satırlar boyunca, yani sütun sütun topla demektir.
  • \((2, 3)\) şekilli bir diziden satır ortalamalarını çıkarmak için A - A.mean(axis=1) yazmak hata verir: \((2, 3)\) ile \((2,)\) uyumsuzdur. keepdims=True ya da [:, None] gerekir.

Örnek 16.2 (Üç Eksenli Bir Toplamın Şekli) Şekilleri \((5, 1, 3)\) ve \((4, 1)\) olan iki dizinin toplamının şeklini önceden bulunuz ve kodla doğrulayınız.

Çözüm

Hizala. İkinci şeklin soluna bir \(1\) eklenir: \((5, 1, 3)\) ile \((1, 4, 1)\).

Karşılaştır ve büyüğü al. Sağdan sola: \(3\) ile \(1\) uyumludur, sonuç \(3\); \(1\) ile \(4\) uyumludur, sonuç \(4\); \(5\) ile \(1\) uyumludur, sonuç \(5\). Toplamın şekli \((5, 4, 3)\)’tür.

Python
import numpy as np

a = np.ones((5, 1, 3))
b = np.ones((4, 1))
print((a + b).shape, np.broadcast_shapes((5, 1, 3), (4, 1)))
try:
    np.ones((2, 3)) + np.ones(2)
except ValueError as err:
    print("ValueError:", err)
Çıktı
(5, 4, 3) (5, 4, 3)
ValueError: operands could not be broadcast together with shapes (2,3) (2,) 

Son satır karşılaştırma için eklendi: \((2, 3)\) ile \((2,)\) şekillerinin son eksenlerinde \(3\) ile \(2\) çatıştığı için toplam tanımsızdır. \(\blacksquare\)

16.6 Lineer Cebir

Matematikte \(AB\) yazılan her yerde kodda A @ B yazılır (Tanım 7.1); geri kalan işlerin hepsi np.linalg modülündedir.

Tablo 16.6: np.linalg başvuru tablosu
Matematik Kod Not
\(AB\), \(Ax\), \(u \cdot v\) A @ B, A @ x, u @ v * eleman eleman çarpar
\(Ax = b\) np.linalg.solve(A, b) inv(A) @ b’den hızlı ve doğru
\(A^{-1}\), \(\det A\), \(\operatorname{rank} A\) inv(A), det(A), matrix_rank(A) tekilliği det ile sınama
\(A^k\) np.linalg.matrix_power(A, k) A**k eleman eleman kuvvettir
\(\lVert x \rVert_2\), \(\lVert A \rVert_1\), \(\lVert A \rVert_\infty\) norm(x), norm(A, 1), norm(A, np.inf) Tanım 7.2
\(\kappa(A)\) np.linalg.cond(A) yaklaşık \(\log_{10}\kappa\) basamak kaybolur (Tanım 7.4)
özdeğer, özvektör w, V = eig(A); simetrikse eigh(A) özvektörler V’nin sütunlarıdır
en küçük kareler lstsq(M, y, rcond=None) Tanım 7.5
\(A = U \Sigma V^T\) U, s, Vt = np.linalg.svd(A) Tanım 7.6
İpucuÜç adımda bir lineer sistem
  1. A ve b’yi float diziler olarak kur.
  2. x = np.linalg.solve(A, b) ile çöz.
  3. np.allclose(A @ x, b) ile sağla; şüphe varsa cond(A)’ya bak.
UyarıSık yapılan hatalar
  • A * v hata vermez ama \(Av\) değildir; broadcasting ile eleman eleman çarpar.
  • det(A) == 0 sınaması kayan noktalı sayılarla anlamsızdır; matrix_rank ya da cond kullan.
  • eig gerçek bir matriste karmaşık özdeğer döndürebilir; simetrik matriste eigh gerçek ve artan sıralı özdeğer verir (Teorem 7.1).
  • Normal denklemleri \(A^TA\hat x = A^Tb\) elle kurup çözmek basamak kaybettirir; lstsq kullan.

Örnek 16.3 (Simetrik Bir Sistem ve Özdeğerleri) \[4x - 2y + z = 11, \qquad -2x + 4y - 2z = -16, \qquad x - 2y + 4z = 17\] sistemini çözünüz; katsayı matrisinin determinantını, rankını, koşul sayısını ve özdeğerlerini hesaplayınız.

Çözüm
Python
import numpy as np

A = np.array([[4.0, -2.0, 1.0],
              [-2.0, 4.0, -2.0],
              [1.0, -2.0, 4.0]])
b = np.array([11.0, -16.0, 17.0])
x = np.linalg.solve(A, b)
print(x, np.allclose(A @ x, b))
print(np.linalg.det(A), np.linalg.matrix_rank(A), np.linalg.cond(A))
w, V = np.linalg.eigh(A)
print(w)
print(np.allclose(A @ V[:, 2], w[2] * V[:, 2]))
Çıktı
[ 1. -2.  3.] True
36.0 3 4.529210992451762
[1.62771868 3.         7.37228132]
True

Yorum. Çözüm \((x, y, z) = (1, -2, 3)\)’tür. \(\det A = 36 \ne 0\) ve rank \(3\)’tür. \(A\) simetrik olduğundan eigh kullanıldı; özdeğerler \(3\) ve \(\lambda^2 - 9\lambda + 12 = 0\) denkleminin kökleri \(\frac{9 \mp \sqrt{33}}{2}\)’dir. Simetrik matriste 2-normundaki koşul sayısı en büyük ve en küçük özdeğerin oranıdır: \(\kappa(A) = 7{,}3723 / 1{,}6277 \approx 4{,}53\). Matris iyi koşulludur. \(\blacksquare\)

Doğru uydurma kalıbı. \((t_i, y_i)\) verisine \(y = a + bt\) uydurmak için tasarım matrisi M = np.column_stack([np.ones_like(t), t]) kurulur ve coef, res, rank, sv = np.linalg.lstsq(M, y, rcond=None) çağrılır; coef dizisi \((a, b)\)’dir. Örneğin \((0;\ 1{,}1)\), \((1;\ 2{,}9)\), \((2;\ 5{,}2)\), \((3;\ 6{,}8)\) verisi için \(a = 1{,}09\), \(b = 1{,}94\) ve artık kareleri toplamı \(0{,}082\) çıkar.

16.7 Matplotlib ile Grafik

Her grafik aynı iskelete oturur: veri dizilerini hazırla, fig, ax = plt.subplots() ile tuval ve eksen kur (Tanım 8.1), ax üzerinden çiz, kaydet.

Tablo 16.7: Matplotlib komutları
İstenen Komut
eğri, kesikli çizgi, işaretçi ax.plot(x, y, "--", label="..."), ax.plot(x, y, "o")
eksen adı, başlık, lejant, ızgara ax.set_xlabel, ax.set_title, ax.legend(), ax.grid(True)
eksen sınırları, eşit ölçek ax.set_xlim(a, b), ax.set_aspect("equal")
logaritmik eksen (Tanım 8.2) ax.semilogy(...), ax.loglog(...), ax.set_yscale("log")
alt grafikler fig, axs = plt.subplots(2, 2), sonra axs[i, j].plot(...)
saçılım, histogram (Tanım 8.3) ax.scatter(x, y, s=..., c=...), ax.hist(v, bins=30, density=True)
kontur (Tanım 8.4) X, Y = np.meshgrid(x, y), ax.contour(X, Y, Z), ax.contourf(...)
yüzey plt.subplots(subplot_kw={"projection": "3d"}), ax.plot_surface(X, Y, Z)
kaydetme fig.savefig("ad.png", dpi=150) ya da "ad.svg", "ad.pdf"
Python
import matplotlib.pyplot as plt
import numpy as np

x = np.linspace(0, 2 * np.pi, 400)
fig, axs = plt.subplots(1, 2, figsize=(9, 3.5))
axs[0].plot(x, np.sin(x), label="sin x")
axs[0].plot(x, np.cos(x), "--", label="cos x")
axs[0].set_xlabel("x")
axs[0].legend()
axs[0].grid(True)

X, Y = np.meshgrid(np.linspace(-2, 2, 101), np.linspace(-2, 2, 101))
cs = axs[1].contour(X, Y, X**2 - Y**2, levels=9)
axs[1].clabel(cs)
axs[1].set_aspect("equal")
fig.tight_layout()
fig.savefig("grafik.png", dpi=150)
UyarıSık yapılan hatalar
  • plot noktaları sırayla doğru parçalarıyla birleştirir. Süreksizlik noktasında dikey bir çizgi belirir; orada değeri np.nan yap. Hızlı salınan bir fonksiyonda nokta sayısını artır.
  • Parametrik ve kutupsal eğrilerde set_aspect("equal") unutulursa çember elips görünür. Negatif yarıçap alan kutupsal eğriyi \(x = r\cos\theta\), \(y = r\sin\theta\) ile düzlemde çiz.
  • meshgrid(x, y) dizileri \((n, m)\) şeklindedir: satır indisi \(y\)’ye, sütun indisi \(x\)’e karşılık gelir.

16.8 SymPy ile Sembolik Hesap

Kesin sonuç gerektiğinde semboller tanımlanır (Tanım 9.2) ve hesap SymPy fonksiyonlarıyla yapılır; sayısal hesaba geçmek için lambdify kullanılır.

Tablo 16.8: SymPy komutları
İş Kod
sembol, varsayım (Tanım 9.4) x = sp.symbols("x"), n = sp.symbols("n", positive=True, integer=True)
kesin sayı sp.Rational(1, 3), sp.sqrt(8), sp.pi, sp.E, sp.oo
sadeleştirme sp.simplify, sp.expand, sp.factor, sp.trigsimp
limit sp.limit(f, x, 0), tek yönlü: sp.limit(f, x, 0, "+")
türev sp.diff(f, x), ikinci türev: sp.diff(f, x, 2)
integral sp.integrate(f, x), belirli: sp.integrate(f, (x, a, b))
Taylor serisi, toplam sp.series(f, x, 0, n).removeO(), sp.summation(a, (k, 1, sp.oo))
denklem sp.solve(f, x), sp.solveset(f, x, sp.S.Reals), sayısal: sp.nsolve(f, x, x0)
diferansiyel denklem sp.dsolve(sp.Eq(y(x).diff(x), y(x)), y(x), ics={y(0): 1})
matris M = sp.Matrix([[...]]), M.det(), M.inv(), M.eigenvals()
ondalık değer sp.N(expr, 20), expr.evalf()
NumPy fonksiyonuna çevirme (Tanım 9.6) g = sp.lambdify(x, expr, "numpy")
Python
import sympy as sp

x = sp.symbols("x")
n = sp.symbols("n", positive=True, integer=True)
print(sp.limit(sp.sin(x) / x, x, 0), sp.limit((1 + 1/n)**n, n, sp.oo))
print(sp.diff(x**3 * sp.exp(-x), x))
print(sp.integrate(1 / (1 + x**2), (x, 0, 1)))
print(sp.series(sp.cos(x), x, 0, 6))
print(sp.factor(x**3 - x), sp.expand((x + 1)**3))
print(sp.solve(x**2 - 5*x + 6, x))
print(sp.simplify(sp.sin(x)**2 + sp.cos(x)**2))
g = sp.lambdify(x, sp.exp(-x**2), "numpy")
print(g(0.5))
Çıktı
1 E
-x**3*exp(-x) + 3*x**2*exp(-x)
pi/4
1 - x**2/2 + x**4/24 + O(x**6)
x*(x - 1)*(x + 1) x**3 + 3*x**2 + 3*x + 1
[2, 3]
1
0.7788007830714049
UyarıSık yapılan hatalar
  • x + 1/3 yazınca Python önce 1/3’ü float yapar; kesin kesir için sp.Rational(1, 3) yaz.
  • Varsayımsız bir sembolde \(\sqrt{x^2}\) sadeleşmez, çünkü \(x\) negatif ya da karmaşık olabilir. positive=True gibi varsayımlar bu kuralları açar.
  • == yapısal eşitliği sınar (Tanım 9.5); iki ifadenin matematiksel eşitliği için sp.simplify(a - b) == 0 bakılır.
  • math.sin(x) bir sembolle çalışmaz; sembolik ifadelerde sp.sin, dizilerde np.sin kullanılır.

Örnek 16.4 (Bir Fonksiyonun Mutlak Maksimumu) \(f(x) = x^2 e^{-x}\) fonksiyonunun \([0, \infty)\) aralığındaki en büyük değerini SymPy ile bulunuz.

Çözüm

Kritik noktalar. \(f'(x) = 0\) denklemini çözüp kritik noktalardaki değerlere ve sonsuzdaki limite bakarız. Sembolü nonnegative=True ile tanımlamak çözümleri aralığa sınırlar.

Python
import sympy as sp

x = sp.symbols("x", nonnegative=True)
f = x**2 * sp.exp(-x)
crit = sp.solve(sp.diff(f, x), x)
print(crit, [f.subs(x, c) for c in crit])
print(sp.limit(f, x, sp.oo), sp.N(f.subs(x, 2)))
Çıktı
[0, 2] [0, 4*exp(-2)]
0 0.541341132946451

Sonuç. \(f'(x) = (2x - x^2)e^{-x}\) yalnız \(x = 0\) ve \(x = 2\)’de sıfırdır. \(f(0) = 0\), \(f(2) = 4e^{-2}\) ve \(x \to \infty\) iken \(f(x) \to 0\) olduğundan en büyük değer \(f(2) = 4e^{-2} \approx 0{,}5413\)’tür. \(\blacksquare\)

16.9 Kök Bulma ve Optimizasyon

scipy.optimize modülündeki araçlar iki soruya yanıt verir: \(f(x) = 0\) nerede ve \(f\) nerede en küçük? Doğru aracı, elimizdeki bilgi (parantez, başlangıç noktası, türev) belirler.

Tablo 16.9: Kök bulma ve optimizasyon araçları
Problem Araç Gereken
tek değişkenli kök, parantez belli (Tanım 10.1) brentq(f, a, b) \(f(a) f(b) < 0\)
tek değişkenli kök, yöntem seçerek root_scalar(f, method=..., bracket=... / x0=...) yönteme göre
birçok başlangıçtan Newton newton(f, x0_dizisi, fprime=df) x0 bir dizi
denklem sistemi \(F(\mathbf{x}) = 0\) fsolve(F, x0) ya da root(F, x0, jac=J) iyi bir x0
tek değişkenli minimum minimize_scalar(f, bounds=(a, b), method="bounded") aralık
çok değişkenli minimum minimize(f, x0, method="BFGS", jac=grad) x0, varsa gradyan
kısıtlı minimum (Tanım 10.3) minimize(..., method="SLSQP", bounds=..., constraints=...) "ineq" için \(g \ge 0\)
İpucuDört adımda bir denklemin bütün kökleri
  1. Tara. x = np.linspace(a, b, n) ızgarasında y = f(x) hesapla.
  2. Ayır. i = np.nonzero(y[:-1] * y[1:] < 0)[0] işaretin değiştiği hücreleri verir.
  3. Daralt. Her hücrede brentq(f, x[k], x[k + 1]) çağır.
  4. Sağla. Her kökte \(f(r)\)’yi yazdır; kutup ya da süreksizlik varsa işaret değişimi kök demek değildir.

Örnek 16.5 (Bir Kübik Denklemin Üç Kökü) \(x^3 - 4x + 1 = 0\) denkleminin bütün reel köklerini bulunuz.

Çözüm

Tarama aralığı. \(|x| \ge 3\) için \(|x^3| \ge 9|x| > |4x - 1|\) olduğundan bütün reel kökler \((-3, 3)\) içindedir. Bu aralığı \(0{,}5\) adımla tarayıp her işaret değişiminde brentq çağırırız.

Python
import numpy as np
from scipy.optimize import brentq

def f(x):
    return x**3 - 4*x + 1

x = np.linspace(-3, 3, 13)
y = f(x)
i = np.nonzero(y[:-1] * y[1:] < 0)[0]
roots = [brentq(f, x[k], x[k + 1]) for k in i]
for r in roots:
    print(f"{r:.12f}   f = {f(r):.1e}")
print("toplam:", sum(roots), "çarpım:", np.prod(roots))
Çıktı
-2.114907541477   f = -1.8e-15
0.254101688365   f = 0.0e+00
1.860805853112   f = 0.0e+00
toplam: -2.220446049250313e-16 çarpım: -1.0000000000000002

Sağlama. Kübik denklemin en çok üç kökü vardır ve üçü de bulundu. Vieta formüllerine göre köklerin toplamı \(0\), çarpımı \(-1\) olmalıdır; son satır bunu yuvarlama hatası düzeyinde doğrular. \(\blacksquare\)

Örnek 16.6 (Bir Kısıt Altında Çarpımın Maksimumu) \(x, y \ge 0\) ve \(x + 2y \le 8\) koşulları altında \(xy\) çarpımının en büyük değerini minimize ile bulunuz.

Çözüm

Problemi kurmak. SciPy yalnız minimum arar; \(xy\)’nin maksimumu \(-xy\)’nin minimumudur. "ineq" kısıtı \(g \ge 0\) demek olduğundan \(x + 2y \le 8\) kısıtı \(8 - x - 2y \ge 0\) biçiminde yazılır.

Python
from scipy.optimize import minimize

def neg_area(v):
    return -v[0] * v[1]          # maksimum için -f'yi küçült

cons = [{"type": "ineq", "fun": lambda v: 8 - v[0] - 2 * v[1]}]
res = minimize(neg_area, x0=[1.0, 1.0], method="SLSQP",
               bounds=[(0, None), (0, None)], constraints=cons)
print(res.success, res.x, -res.fun)
Çıktı
True [4.00000004 1.99999998] 8.00000000024745

Sağlama. Maksimum kısıt doğrusu üzerindedir: \(x = 8 - 2y\) için \(xy = 8y - 2y^2\) ve türevi \(8 - 4y = 0\)’dan \(y = 2\), \(x = 4\), en büyük değer \(8\) bulunur. \(\blacksquare\)

UyarıSık yapılan hatalar
  • İşaret değişimi olmayan çift katlı kökler ve aynı hücreye düşen iki kök taramada kaçar; ızgarayı sıklaştır ve grafiğe bak.
  • Newton yöntemi yalnız köke yakın başlarsa yakınsar (Teorem 10.1); güvenli yol parantezli brentq’dur.
  • minimize yerel minimum bulur; birkaç x0’dan başlatıp en iyisini seç.
  • "ineq" kısıtının yönünü ters yazmak hata vermez, başka bir problemi çözer.

16.10 Sayısal Türev ve İntegral

Türevde adım seçimi, integralde ise elde fonksiyon mu yoksa yalnız bir değer tablosu mu olduğu doğru aracı belirler.

Tablo 16.10: Sayısal türev ve integral araçları
Yöntem Kod Hata Ayrıntı
ileri fark \(D_h^{+} f(x)\) (f(x + h) - f(x)) / h \(O(h)\), en iyi \(h \approx 10^{-8}\) Tanım 11.1
merkezi fark \(D_h f(x)\) (f(x + h) - f(x - h)) / (2 * h) \(O(h^2)\), en iyi \(h \approx 10^{-5}\) Önerme 11.2
ızgarada türev np.gradient(y, x) iç noktalarda \(O(h^2)\) Tanım 11.3
bileşik yamuk \(T_n\) np.trapezoid(y, x) \(O(h^2)\) Önerme 11.3
bileşik Simpson \(S_n\) scipy.integrate.simpson(y, x=x) \(O(h^4)\) Tanım 11.6
fonksiyon integrali val, err = quad(f, a, b) uyarlamalı; sınır np.inf olabilir Tanım 11.7
iki katlı dblquad(lambda y, x: ..., a, b, g, h) iç değişken önce Tanım 11.8
üç katlı tplquad(lambda z, y, x: ..., a, b, g, h, q, r) sıra \(z, y, x\) Tanım 11.9
Python
import numpy as np
from scipy.integrate import quad, simpson

f, x0 = np.exp, 1.0
for h in [1e-2, 1e-5, 1e-8]:
    fwd = (f(x0 + h) - f(x0)) / h
    cen = (f(x0 + h) - f(x0 - h)) / (2 * h)
    print(f"h = {h:.0e}: ileri hata {abs(fwd - np.e):.1e}, "
          f"merkezi hata {abs(cen - np.e):.1e}")

x = np.linspace(0, np.pi, 11)
y = np.sin(x)
print(np.trapezoid(y, x), simpson(y, x=x))
val, err = quad(lambda t: np.exp(-t**2), 0, np.inf)
print(val, err, np.sqrt(np.pi) / 2)
Çıktı
h = 1e-02: ileri hata 1.4e-02, merkezi hata 4.5e-05
h = 1e-05: ileri hata 1.4e-05, merkezi hata 5.9e-11
h = 1e-08: ileri hata 6.6e-09, merkezi hata 6.6e-09
1.9835235375094544 2.0001095173150043
0.8862269254527579 7.101318390472462e-09 0.8862269254527579

Tabloyu çıktı doğrular: merkezi farkta \(h\) yüz kat küçülünce hata kabaca on bin kat küçülür, ama \(h = 10^{-8}\)’de yuvarlama hatası öne geçer. On alt aralıkla \(\int_0^\pi \sin x\,dx = 2\) için yamuk kuralının hatası yaklaşık \(0{,}017\), Simpson kuralınınki \(0{,}0001\)’dir.

Kısa yollar. quad bir ikili döndürür; yalnız değer için quad(f, a, b)[0] yazılır. Aralığın içindeki bir tekil ya da kırık noktayı points=[c] ile bildir. \(e^x - 1\) ve \(\ln(1 + x)\) ifadeleri küçük \(x\)’te np.expm1(x) ve np.log1p(x) ile basamak kaybetmeden hesaplanır.

Örnek 16.7 (dblquad’da Argüman Sırası) \(0 \le x \le 1\) ve \(0 \le y \le x\) eşitsizlikleriyle verilen \(D\) bölgesinde \(\iint_D x y^2\,dA\) integralini dblquad ile hesaplayınız ve integrandı lambda x, y sırasıyla yazmanın ne verdiğini gösteriniz.

Çözüm

Elle. İç integral \(\int_0^x x y^2\,dy = \frac{x^4}{3}\), dış integral \(\int_0^1 \frac{x^4}{3}\,dx = \frac{1}{15}\)’tir.

Python
from scipy.integrate import dblquad

right, _ = dblquad(lambda y, x: x * y**2, 0, 1, 0, lambda x: x)
wrong, _ = dblquad(lambda x, y: x * y**2, 0, 1, 0, lambda x: x)
print(right, 1 / 15)
print(wrong, 1 / 10)
Çıktı
0.06666666666666668 0.06666666666666667
0.1 0.1

Yorum. dblquad integrandın ilk argümanını iç değişken \(y\) olarak kullanır. lambda x, y: x * y**2 yazılınca ilk argüman adı x olsa da iç değişkendir; hesaplanan integral \[\int_0^1 \!\! \int_0^x y\,x^2\,dy\,dx = \int_0^1 \frac{x^4}{2}\,dx = \frac{1}{10}\] olur. Hata mesajı çıkmaz, yalnız sonuç yanlıştır. \(\blacksquare\)

16.11 Polinomlar, İnterpolasyon ve Eğri Uydurma

Polinom için numpy.polynomial.Polynomial (Tanım 12.1), noktalardan geçen bir eğri için interpolasyon ya da spline, gürültülü veri için en küçük kareler kullanılır.

Tablo 16.11: Polinom ve eğri uydurma araçları
İş Kod Not
\(c_0 + c_1x + c_2x^2\) p = Polynomial([c0, c1, c2]) katsayılar artan sırada
değer, kök, türev, integral p(x), p.roots(), p.deriv(), p.integ() np.polyval ve np.polyfit azalan sıra ister
\(n + 1\) noktadan interpolasyon Polynomial.fit(x, y, deg=n).convert() tek polinom (Teorem 12.1)
en küçük kareler polinomu p = Polynomial.fit(x, y, deg) katsayılar için p.convert().coef
kübik spline (Tanım 12.6) S = CubicSpline(x, y, bc_type=...) S(t), S(t, 1), S.integrate(a, b)
parametreleri doğrusal olmayan model popt, pcov = curve_fit(model, t, y, p0=...) standart hata np.sqrt(np.diag(pcov))
Çebişev düğümleri (Tanım 12.5) np.cos((2 * np.arange(n + 1) + 1) * np.pi / (2 * n + 2)) Runge olayına karşı
Python
import numpy as np
from numpy.polynomial import Polynomial
from scipy.interpolate import CubicSpline

p = Polynomial([2, -3, 1])          # 2 - 3x + x^2: artan sıra
print(p(4), np.polyval([1, -3, 2], 4))
print(p.roots(), p.deriv(), p.integ())

x = np.array([0.0, 1.0, 2.0, 3.0])
S = CubicSpline(x, x**3)            # varsayılan: "not-a-knot"
print(S(1.5), S(1.5, 1), S.integrate(0, 3))
Çıktı
6.0 6
[1. 2.] -3.0 + 2.0 x 0.0 + 2.0 x - 1.5 x**2 + 0.33333333 x**3
3.375000000000001 6.75 20.25

Varsayılan "not-a-knot" koşullu spline kübik polinomları tam verir: \(1{,}5^3 = 3{,}375\), \(3 \cdot 1{,}5^2 = 6{,}75\) ve \(\int_0^3 x^3\,dx = 20{,}25\).

UyarıSık yapılan hatalar
  • Aynı katsayı listesini Polynomial’a ve np.polyval’a vermek: biri artan, öteki azalan sıra okur ve hata mesajı çıkmaz.
  • Polynomial.fit sonucunun coef niteliği ölçeklenmiş değişkene göredir; alışılmış katsayılar için convert() gerekir.
  • Eşit aralıklı çok sayıda düğümde yüksek dereceli interpolasyon uçlarda salınır (Tanım 12.4); Çebişev düğümleri ya da spline kullan.
  • En küçük karelerde derece artırmak artıkları hep küçültür; dereceyi artık grafiğine (Tanım 12.10) ya da test noktalarına göre seç. curve_fit için p0 verilmezse yanlış yerel minimuma gidebilir.

Örnek 16.8 (Üç Noktadan Geçen Parabol) \((-1, 4)\), \((1, 2)\) ve \((2, 7)\) noktalarından geçen ikinci dereceden polinomu bulunuz.

Çözüm

Kod. Üç noktaya derecesi \(2\) olan bir polinom uydurmak tam interpolasyondur.

Python
import numpy as np
from numpy.polynomial import Polynomial

x = np.array([-1.0, 1.0, 2.0])
y = np.array([4.0, 2.0, 7.0])
p = Polynomial.fit(x, y, deg=len(x) - 1).convert()
print(p.coef.round(12), round(p(0.5), 12))
Çıktı
[ 1. -1.  2.] 1.0

Sağlama. \(p(x) = 1 - x + 2x^2\) için \(p(-1) = 1 + 1 + 2 = 4\), \(p(1) = 1 - 1 + 2 = 2\), \(p(2) = 1 - 2 + 8 = 7\)’dir. Ayrıca \(p(0{,}5) = 1 - 0{,}5 + 0{,}5 = 1\). \(\blacksquare\)

16.12 Diferansiyel Denklemler

Bir başlangıç değer problemi solve_ivp ile çözülür; yöntemin kendisini görmek için Euler (Tanım 13.2) ve RK4 (Tanım 13.3) birkaç satırda yazılır.

Tablo 16.12: Elle yazılan yöntemler
Yöntem Bir adım (\(t_{i+1} = t_i + h\)) Global hata (Teorem 13.1)
Euler \(y_{i+1} = y_i + h\,f(t_i, y_i)\) \(O(h)\)
RK4 \(y_{i+1} = y_i + \frac{h}{6}(k_1 + 2k_2 + 2k_3 + k_4)\) \(O(h^4)\)
Tablo 16.13: solve_ivp başvuru tablosu
solve_ivp parametresi ya da alanı Anlamı
fun(t, y) sağ taraf; önce zaman, sonra bilinmeyen vektörü
t_span=(t0, T), y0=[...] aralık, başlangıç değeri (tek denklemde bile liste)
rtol, atol varsayılan 1e-3, 1e-6; gerçek işte sıkılaştır
method="RK45" (varsayılan), "DOP853" açık yöntemler
method="Radau", "BDF", "LSODA" katı denklemler için (Tanım 13.7)
t_eval=..., dense_output=True istenen anlarda değer, sol.sol(t) ile ara değer
events=g, g.terminal = True, g.direction = -1 \(g(t, y) = 0\) anını bulma, durma (Tanım 13.6)
sol.t, sol.y, sol.success, sol.t_events zamanlar, çözüm (her satır bir bilinmeyen), durum, olay anları
İpucuÜç adımda yüksek mertebeden denklemi sisteme çevirmek
  1. \(u_1 = y\), \(u_2 = y'\), …, \(u_m = y^{(m-1)}\) yeni bilinmeyenlerini tanımla (Tanım 13.8).
  2. \(u_1' = u_2\), …, \(u_m' = g(t, u_1, \dots, u_m)\) sistemini fun(t, u) olarak yaz.
  3. y0 = [y(t0), y'(t0), ...] vektörünü kur; çözüm sol.y[0]’dadır.

Örnek 16.9 (İkinci Mertebeden Bir Başlangıç Değer Problemi) \(y'' + 4y = 0\), \(y(0) = 0\), \(y'(0) = 2\) problemini solve_ivp ile çözüp \(y(\pi/4)\) değerini tam çözümle karşılaştırınız.

Çözüm

Sistem. \(u = (y, y')\) için \(u_1' = u_2\), \(u_2' = -4u_1\) ve \(u(0) = (0, 2)\)’dir. Tam çözüm \(y = \sin 2t\)’dir, dolayısıyla \(y(\pi/4) = 1\) olmalıdır.

Python
import numpy as np
from scipy.integrate import solve_ivp

def rhs(t, u):
    y, v = u                 # u = (y, y')
    return [v, -4 * y]

sol = solve_ivp(rhs, (0, np.pi / 4), [0.0, 2.0], rtol=1e-10, atol=1e-12)
yT = sol.y[0, -1]
print(sol.success, yT, abs(yT - 1))
Çıktı
True 0.9999999999811358 1.8864243500615885e-11

Yorum. Sıkı hata paylarıyla sonuç tam değere \(2 \cdot 10^{-11}\) kadar yakındır. Varsayılan rtol=1e-3 ile yalnız üç dört basamak beklenebilirdi. \(\blacksquare\)

Örnek 16.10 (Yukarı Atılan Taşın Yere Düştüğü An) \(10\) m yükseklikten \(20\) m/s hızla yukarı atılan bir taşın yüksekliği \(y'' = -9{,}81\) denklemine uyar. Taşın yere düştüğü anı bir olay fonksiyonuyla bulunuz.

Çözüm

Kurulum. \(u = (y, v)\) ve \(u' = (v, -g)\)’dir. Olay fonksiyonu yüksekliğin kendisidir; terminal = True çözümü yere değince durdurur, direction = -1 yalnız yukarıdan aşağı geçişi sayar.

Python
import numpy as np
from scipy.integrate import solve_ivp

g = 9.81

def rhs(t, u):
    return [u[1], -g]        # u = (yükseklik, hız)

def ground(t, u):
    return u[0]

ground.terminal = True       # sıfır olunca dur
ground.direction = -1        # yalnız yukarıdan aşağı geçişte

sol = solve_ivp(rhs, (0, 10), [10.0, 20.0], events=ground,
                rtol=1e-10, atol=1e-12)
T = sol.t_events[0][0]
print(sol.status, T, (20 + np.sqrt(20**2 + 2 * g * 10)) / g)
Çıktı
1 4.527747915136608 4.5277479151366045

Sağlama. Düşme anı, \(10 + 20t - \frac{g}{2}t^2 = 0\) denkleminin pozitif köküdür: \[t = \frac{20 + \sqrt{400 + 2g \cdot 10}}{g} \approx 4{,}5277 \text{ s}.\] status değerinin \(1\) olması çözümün bir terminal olayla durduğunu gösterir. \(\blacksquare\)

UyarıSık yapılan hatalar
  • solve_ivp sağ tarafı fun(t, y) sırasıyla ister; eski odeint için yazılmış fun(y, t) sessizce yanlış sonuç verir.
  • solve_ivp başarısız olunca istisna fırlatmaz; sol.success ve sol.message’ı denetle.
  • sol.y dizisinin satırları bilinmeyenlerdir: \(y\) değerleri sol.y[0], son an sol.y[:, -1]’dir.
  • Açık yöntem çok küçük adımlar atıyor ve yavaşlıyorsa denklem katı olabilir; Radau ya da BDF dene.

16.13 Rastgele Sayılar ve Monte Carlo

Bütün rastgelelik tohumu sabit bir üreteçten gelir: rng = np.random.default_rng(tohum) (Tanım 14.2). Bir olasılık ya da beklenen değer, örneklem ortalamasıyla kestirilir (Tanım 14.3).

Tablo 16.14: Rastgele sayı ve Monte Carlo kalıpları
İstenen Kod Dikkat
\([0, 1)\)’de düzgün rng.random(n)
\([a, b)\)’de düzgün rng.uniform(a, b, n)
zar rng.integers(1, 7, n) üst sınır dahil değil
\(N(\mu, \sigma^2)\) rng.normal(mu, sigma, n) ikinci parametre \(\sigma\)
\(\operatorname{Üstel}(\lambda)\) rng.exponential(1 / lam, n) parametre ortalama \(1/\lambda\)
sonlu dağılım rng.choice(degerler, n, p=olasiliklar) replace=False ile tekrarsız
ters dönüşüm (Önerme 14.1) X = Finv(rng.random(n)) \(F^{-1}\) açıkça yazılabilmeli
olasılık kestirimi p = (olay).mean() standart hata \(\sqrt{p(1-p)/N}\)
integral (Tanım 14.4) vol * f(U).mean() standart hata vol * f(U).std(ddof=1) / np.sqrt(N)

Monte Carlo hatası \(1/\sqrt{N}\) hızıyla küçülür (Önerme 14.2): bir basamak daha doğruluk için \(100\) kat fazla nokta gerekir. Sonuç her zaman “kestirim \(\pm\ 1{,}96 \cdot\) standart hata” biçiminde bildirilir.

Python
import numpy as np

rng = np.random.default_rng(11)
N = 100_000
vol = np.pi                          # [0, π] aralığının uzunluğu
vals = np.sin(rng.uniform(0, np.pi, N))
est = vol * vals.mean()
se = vol * vals.std(ddof=1) / np.sqrt(N)
print(f"{est:.4f} ± {1.96 * se:.4f}")
Çıktı
1.9985 ± 0.0060

Kod \(\int_0^\pi \sin x\,dx = 2\) integralini kestirir; gerçek değer aralığın içindedir.

Örnek 16.11 (Üç Zarın Toplamının En Az On Beş Olması) Üç zar atıldığında toplamın en az \(15\) olma olasılığını \(200\,000\) atışlık bir simülasyonla kestiriniz ve tam değerle karşılaştırınız.

Çözüm

Kod. Atışları \((N, 3)\) şekilli bir dizide üretip satır toplamlarını alırız; olayın göstergesinin ortalaması olasılığın kestirimidir.

Python
import numpy as np

rng = np.random.default_rng(7)
N = 200_000
s = rng.integers(1, 7, size=(N, 3)).sum(axis=1)
p = (s >= 15).mean()
se = np.sqrt(p * (1 - p) / N)
print(f"kestirim = {p:.4f} ± {1.96 * se:.4f}, tam değer = {20 / 216:.4f}")
Çıktı
kestirim = 0.0929 ± 0.0013, tam değer = 0.0926

Tam değer. \(216\) eşit olası sonuçtan toplamı \(15\) olan \(10\), \(16\) olan \(6\), \(17\) olan \(3\), \(18\) olan \(1\) tane vardır; olasılık \(\frac{20}{216} = \frac{5}{54} \approx 0{,}0926\)’dır ve kestirim aralığının içindedir. \(\blacksquare\)

UyarıSık yapılan hatalar
  • Tohum verilmezse her çalıştırma farklı sonuç verir; eski np.random.seed ve np.random.rand yerine default_rng kullan.
  • rng.integers(1, 6) zar değildir, \(6\)’yı hiç üretmez.
  • Bir kestirimi standart hatasız vermek: tek başına bir sayı ne kadar güvenilir olduğunu söylemez.

16.14 Pandas ile Veri Analizi

Etiketli tablolarla çalışırken Series (Tanım 15.1) ve DataFrame (Tanım 15.3) kullanılır; işlemlerin çoğu tek bir metot çağrısıdır.

Tablo 16.15: pandas başvuru tablosu
İş Kod Ayrıntı
Türkçe biçimli CSV okumak pd.read_csv(ad, sep=";", decimal=",", na_values="-") parse_dates, date_format
ilk bakış df.head(), df.shape, df.dtypes, df.describe()
etiketle ve konumla seçim df.loc[satır, sütun], df.iloc[i, j] loc dilimi iki ucu içerir (Tanım 15.4)
koşulla seçim df[(df["x"] > 0) & (df["y"] < 5)] her koşul parantez içinde
eksik değer (Tanım 15.5) isna().sum(), dropna(), fillna(v), interpolate() ortalamalar NaN’ı atlar
sıklık, yüzdelik value_counts(), quantile(0.25) Tanım 15.6
gruplama (Tanım 15.7) df.groupby("k")["v"].agg(["mean", "count"]) transform aynı şekli korur
birleştirme (Tanım 15.8) pd.merge(a, b, on="k", how="left", indicator=True)
zaman serisi s.resample("ME").mean(), s.rolling(7, center=True).mean() Tanım 15.9
Python
import pandas as pd

df = pd.DataFrame({"grup": ["A", "B", "A", "B", "A"],
                   "x": [2.0, 5.0, None, 7.0, 4.0]},
                  index=[10, 20, 30, 40, 50])
print(df.loc[20:40, "x"].tolist(), df.iloc[1:3]["x"].tolist())
print(df["x"].isna().sum(), df["x"].mean(), df["x"].fillna(0).mean())
print(df.groupby("grup")["x"].agg(["mean", "count"]))
Çıktı
[5.0, nan, 7.0] [5.0, nan]
1 4.5 3.6
      mean  count
grup             
A      3.0      2
B      6.0      2

loc[20:40] üç satır, iloc[1:3] iki satır verdi. Ortalama eksik değeri atlar (\(18/4 = 4{,}5\)); eksik değer \(0\) ile doldurulunca \(18/5 = 3{,}6\) olur. count da eksik değeri saymaz.

UyarıSık yapılan hatalar
  • s[0] “ilk eleman” değil “etiketi 0 olan eleman”dır; konum için s.iloc[0] yaz.
  • df[maske]["y"] = 0 zincirleme atamadır ve df’yi değiştirmez; doğrusu df.loc[maske, "y"] = 0’dır.
  • pandas’ın std metodu ddof=1, NumPy’ın np.std fonksiyonu ddof=0 kullanır; aynı veride farklı sonuç verirler.
  • Eksik değer giren tamsayı sütunu float64 olur; tamsayı kalması gerekiyorsa dtype="Int64" kullan.

Örnek 16.12 (Noktalı Virgüllü Bir Dosyadan Grup Ortalamaları) Aşağıdaki veride alanlar noktalı virgülle ayrılmış, ondalıklar virgülle yazılmış ve ölçülemeyen değer - ile gösterilmiştir. Veriyi okuyup her istasyonun ortalama sıcaklığını bulunuz.

istasyon;gün;sıcaklık
Kars;1;-4,5
Kars;2;-
Kars;3;-2,5
Rize;1;8,0
Rize;2;9,5
Rize;3;7,5
Çözüm

Okuma. sep, decimal ve na_values parametreleri dosyanın üç özelliğine karşılık gelir. Kodda veri bir dosya yerine StringIO ile okunuyor; gerçek bir dosyada yalnız dosya adı yazılır.

Python
from io import StringIO

import pandas as pd

text = """istasyon;gün;sıcaklık
Kars;1;-4,5
Kars;2;-
Kars;3;-2,5
Rize;1;8,0
Rize;2;9,5
Rize;3;7,5
"""
df = pd.read_csv(StringIO(text), sep=";", decimal=",", na_values="-")
print(df.dtypes["sıcaklık"], df["sıcaklık"].isna().sum())
print(df.groupby("istasyon")["sıcaklık"].agg(["mean", "count"]))
Çıktı
float64 1
              mean  count
istasyon                 
Kars     -3.500000      2
Rize      8.333333      3

Sağlama. Sütun float64 türünde okundu, yani ondalık virgül doğru çözüldü; tek eksik değer Kars’ın ikinci günüdür. Kars için \(\frac{-4{,}5 - 2{,}5}{2} = -3{,}5\), Rize için \(\frac{8 + 9{,}5 + 7{,}5}{3} = \frac{25}{3} \approx 8{,}33\) bulunur. \(\blacksquare\)

16.15 Son Kontrol Listesi

Bir kodu bitmiş saymadan önce şu soruları sor:

  1. Sonucu bağımsız bir yolla sağladın mı: elle bir değer, bilinen bir formül, np.allclose(A @ x, b) ya da \(f(r) \approx 0\)?
  2. float sonuçları == ile değil toleransla karşılaştırdın mı?
  3. Bir diziyi değiştirirken onun bir görünüm mü kopya mı olduğunu biliyor musun?
  4. axis parametresini ve broadcasting sonucunun şeklini önceden kestirdin mi?
  5. * yerine @, inv yerine solve, det == 0 yerine cond kullandın mı?
  6. Polinom katsayılarının sırası (artan ya da azalan) kullandığın fonksiyona uyuyor mu?
  7. dblquad ve tplquad’da iç değişkeni önce yazdın mı? solve_ivp’de fun(t, y) sırasını ve sol.success değerini denetledin mi?
  8. Hata paylarını (rtol, atol, xtol) gereken doğruluğa göre seçtin mi?
  9. Rastgele hesapta tohumu sabitledin mi ve sonucu standart hatasıyla verdin mi?
  10. pandas’ta eksik değerleri ve sütun türlerini okuduktan hemen sonra denetledin mi?

Kuralların gerekçeleri ve daha çok çözümlü örnek için her bölümün alıştırmalarına, kitabın tamamı için Müfredat ve Giriş sayfasına dönebilirsin.