Skip to content

complex Sayılar: Python'da '3 + 4j' Built-in — Sinyal İşlemeden Quantum'a Köprü

Java/C# karmaşık sayı için kütüphane gerektirir; Python `j` syntax'iyle dilin parçası yapmış. Bu ders: complex'in matematiksel altyapısı, polar/kartezyen dönüşüm, cmath modülünün gücü, 2D rotation matrisi yerine complex çarpma kısayolu, sinyal işleme + Mandelbrot fraktalı + AC devre analizi gibi gerçek uygulamalar.

Şükrü Yusuf KAYA
20 min read
Intermediate
complex Sayılar: Python'da '3 + 4j' Built-in — Sinyal İşlemeden Quantum'a Köprü
🔢 Bu ders 'niş' görünüyor ama gizli güçlü
Çoğu Python öğrencisi complex sayıyı 'akademik konu, hayatta lazım olmaz' diye geçer. Yıllar sonra Fourier transform yaparken, AC elektrik devresi simüle ederken, 2D oyun motoru yazarken — birden 'complex bilseydim hayat çok kolay olurdu' diyor. Bu ders bunu erken öğretiyor. Ayrıca Python'un
j
syntax'i (i değil j — neden? — derste!) ile diğer dillerden ayrılan tasarım kararını anlıyoruz.

Karmaşık sayı nedir? — Hızlı hatırlatma#

Lisede gördüğün gibi: i² = -1. Yani
i
(imaginary unit) öyle bir sayı ki karesi negatif.
Karmaşık sayı:
a + bi
formunda.
a
real (gerçek) kısım,
bi
imaginary (sanal) kısım.
Python'da i yerine j kullanılıyor:
>>> z = 3 + 4j
>>> type(z)
<class 'complex'>
>>> z.real
3.0
>>> z.imag
4.0

Neden
j
,
i
değil?#

İki sebep:
  1. Elektrik mühendisliği konvansiyonu:
    i
    zaten "current" (akım) için kullanılıyor. Karışıklık olmasın diye karmaşık sayı için
    j
    tercih ediliyor. Python tasarımcıları (Guido bilim/mühendislik dünyasını okumuş) bu konvansiyonu seçmiş.
  2. Aşağı uyumluluk:
    i
    Python'da çok yaygın bir loop counter (
    for i in range(10)
    ).
    i = 5
    ile
    5j
    karışmasın diye
    j
    daha güvenli.
Java'nın aksine kütüphane gerekmiyor. Direkt:
>>> 3 + 4j
(3+4j)
>>> 1j * 1j
(-1+0j)         # i² = -1 doğrulandı
>>> (1+2j) * (3+4j)
(-5+10j)
Bu özellik akademik değil pratik fayda: matematik ve mühendislik kodları doğal yazılıyor.

Complex sayı oluşturmanın yolları#

# 1. Literal syntax (en doğal)
z1 = 3 + 4j
z2 = 0 + 1j      # = 1j (saf imaginary)
z3 = -2.5 + 1.7j

# Sadece imaginary kısım
z4 = 5j           # 0 + 5j

# 2. complex() constructor
z5 = complex(3, 4)        # 3 + 4j
z6 = complex(0, 1)        # 1j
z7 = complex("3+4j")      # string'den parse

# 3. Real sayıdan
z8 = complex(5)           # 5 + 0j (real → complex)

# Erişim
z = 3 + 4j
z.real          # 3.0 (her zaman float dönüyor)
z.imag          # 4.0
z.conjugate()   # (3-4j) — sanal kısımın işaretini değiştirir

# Modulus (magnitude / absolute value) — vektör uzunluğu
abs(z)          # 5.0 (Pisagor: √(3² + 4²) = 5)
Tip ile ilgili önemli not:
z.real
ve
z.imag
her zaman float. Bu kararla komplex sayı her zaman float-bazlı; integer karmaşık sayı yok.
>>> type((3 + 4j).real)
<class 'float'>

Karmaşık aritmetik — kuralları#

Karmaşık sayılarda + - * / kuralları:
a = 3 + 4j
b = 1 + 2j

# Toplama: real + real, imag + imag
a + b        # (3+1) + (4+2)j = 4 + 6j

# Çıkarma
a - b        # 2 + 2j

# Çarpma: (3+4j)(1+2j) = 3*1 + 3*2j + 4j*1 + 4j*2j
#                     = 3 + 6j + 4j + 8j²
#                     = 3 + 10j + 8(-1)
#                     = -5 + 10j
a * b        # (-5+10j)

# Bölme — biraz daha kompleks (matematiksel olarak)
a / b        # (2.2-0.4j)
# Aslında: a/b = a * (1/b) = a * conj(b) / |b|²

# Üs alma (negatif üs ve fraksiyonel destekli)
a ** 2       # ((-7+24j)) — (3+4j)² = 9 + 24j + 16j² = -7 + 24j
a ** 0.5     # complex sayının kare kökü — cmath ile daha iyi

==
ile karşılaştırma#

(1 + 0j) == 1        # True (real karmaşık eşit ediyor)
(0 + 0j) == 0        # True
(3 + 4j) == (3 + 4j) # True

# Ama "<", ">" çalışmıyor
(1 + 2j) < (3 + 4j)  # TypeError: '<' not supported
Sıralama tanımlanmamış (matematiksel olarak da total ordering yok). Magnitude veya real/imag karşılaştırması istiyorsan elin işle:
sorted([3+4j, 1+2j, 5+0j], key=abs)
# [(1+2j), (3+4j), (5+0j)]   — magnitude'a göre

cmath
modülü — karmaşık sayı için math#

math
modülü real sayılarla çalışıyor; karmaşık sayılarda
math.sqrt(-1)
hata verir.
cmath
 modülü karmaşık değerli versiyonlarını sağlıyor:
import cmath

# Real sayının kare kökü → karmaşık
cmath.sqrt(-1)         # 1j
cmath.sqrt(-4)         # 2j

# Karmaşık sayının kare kökü
cmath.sqrt(3 + 4j)     # (2+1j)   (kontrol: (2+1j)² = 4 + 4j + j² = 3 + 4j ✓)

# Logaritma
cmath.log(1 + 0j)      # 0j
cmath.log(-1 + 0j)     # πj   (π * j ≈ 3.14159j)
cmath.log(1j)          # 1.5707963267948966j   (= π/2 j)

# Trigonometri (genişletilmiş)
cmath.sin(1j)          # 1.1752011936438014j (hyperbolic sin)
cmath.cos(1j)          # 1.5430806348152437

# Üstel
cmath.exp(1j * cmath.pi)   # (-1+1.22e-16j)   ← Euler'in formülü: e^(iπ) = -1
🎯 Euler'in formülü: e^(iθ) = cos(θ) + i·sin(θ).
Matematiğin en zarif denklemlerinden:
import cmath
import math

# Euler's identity: e^(iπ) + 1 = 0
print(cmath.exp(1j * cmath.pi) + 1)
# (1.2246467991473532e-16+0j)
# Yani neredeyse 0 (floating-point precision)

# math.isclose ile doğrula
result = cmath.exp(1j * cmath.pi) + 1
print(abs(result) < 1e-10)   # True
Bu denklemi mucize gibi görenler var. Pratik etkisi: karmaşık sayılarla rotation/oscillation hesabı bu sayede mümkün.

Kutupsal (polar) form#

Bir karmaşık sayıyı iki şekilde gösterebilirsin:
  • Kartezyen:
    a + bi
    (x, y koordinatları)
  • Kutupsal:
    r·e^(iθ)
    (mesafe + açı)
       imag
        ↑
        |    z = 3 + 4j
        |   /
        |  / r
        | /
        |/ θ
        +─────→ real
r
= mesafe (magnitude/modulus),
θ
= açı (radyan).
import cmath

z = 3 + 4j

# Kartezyen → kutupsal
r = abs(z)                    # 5.0
theta = cmath.phase(z)        # 0.9272952180016122 (~53.13°)

# Tek seferde
r, theta = cmath.polar(z)
print(f"r={r}, theta={math.degrees(theta):.2f}°")
# r=5.0, theta=53.13°

# Kutupsal → kartezyen
back = cmath.rect(r, theta)
print(back)                    # (3+4j)
cmath.polar
ve
cmath.rect
birbirinin tersi. Kutupsal form özellikle rotation için pratik.

Rotation matrix yerine complex çarpma#

2D rotation klasik:
# Klasik (matrix-based)
import math

def rotate(x, y, angle_deg):
    a = math.radians(angle_deg)
    cos_a, sin_a = math.cos(a), math.sin(a)
    new_x = x * cos_a - y * sin_a
    new_y = x * sin_a + y * cos_a
    return new_x, new_y

# Test: (1, 0) noktasını 90° döndür → (0, 1)
print(rotate(1, 0, 90))   # (6.12e-17, 1.0) — neredeyse (0, 1)
Aynı işlem complex ile bir satır:
import cmath

def rotate_complex(point, angle_deg):
    rotation = cmath.exp(1j * math.radians(angle_deg))
    return point * rotation

p = 1 + 0j   # (1, 0) noktası
result = rotate_complex(p, 90)
print(f"Rotated: ({result.real:.0f}, {result.imag:.0f})")   # (0, 1)
Bir noktanın açısıyla
rotation
çarp — bitti. 2D oyun geliştirmede bu pattern kullanışlı (3D'de quaternion var, başka konu).

Animasyon: Saniye akrebi#

import cmath
import math

# Saat akrebinin pozisyonu (her saniye 6° hareket eder)
def second_hand_position(second):
    # Saat 12'den başla, saat yönünde dön
    angle_deg = -90 - second * 6   # -90: 12'ye, -6/sec saat yönü
    angle = math.radians(angle_deg)
    length = 1.0   # akrep uzunluğu
    return cmath.rect(length, angle)

# 0, 15, 30, 45 saniye pozisyonları
for s in [0, 15, 30, 45]:
    p = second_hand_position(s)
    print(f"{s:2d}sec: ({p.real:+.2f}, {p.imag:+.2f})")
# 0sec: (+0.00, +1.00)   ← saat 12
# 15sec: (+1.00, +0.00)   ← saat 3
# 30sec: (-0.00, -1.00)  ← saat 6
# 45sec: (-1.00, -0.00)  ← saat 9
Saat akrebinin pozisyonu — tek satır complex matematik. Vektör/matrix gerek yok.

Gerçek dünya uygulamaları#

1. Sinyal işleme — Fourier Transform#

Karmaşık sayı sinyal işlemenin kalbi. Fourier transform'un içsel temsil olarak
e^(iωt)
kullanıyor — frekans + faz aynı sayıda.
import numpy as np

# Sinyal: 50 Hz + 120 Hz karışım
fs = 1000     # sample rate
t = np.linspace(0, 1, fs, endpoint=False)
signal = 2 * np.sin(2 * np.pi * 50 * t) + 0.5 * np.sin(2 * np.pi * 120 * t)

# FFT — sinyali frekans bileşenlerine ayır (karmaşık sayı çıkıyor)
fft_result = np.fft.fft(signal)
freqs = np.fft.fftfreq(len(signal), 1/fs)

# Magnitude spektrumu
magnitude = np.abs(fft_result)

# 50 Hz ve 120 Hz'in pikleri net
# (Plot için matplotlib lazım — Modül 22'de göreceğiz)
Bu kod sinyalin frekanslarını ayırıyor. Ses tanıma, müzik analizi, telekomünikasyon — hepsi bu kapsayıcı.

2. AC elektrik devresi#

AC akımda gerilim ve akım kompleks sayı (impedans). Direnç R, kondansatör C, indüktör L'yi tek Z impedans olarak yazarsın:
import cmath

# RC alçak geçiren filtre, 1 kHz frekansta
R = 1000      # 1 kΩ
C = 1e-6      # 1 µF
freq = 1000   # 1 kHz

omega = 2 * cmath.pi * freq
Z_R = R                          # rezistör — saf real
Z_C = 1 / (1j * omega * C)       # kapasitör — saf imaginary

# Voltage divider transfer function
H = Z_C / (Z_R + Z_C)
gain = abs(H)            # gain (0-1 arası)
phase = cmath.phase(H)   # faz kayması (radyan)

print(f"Gain at {freq}Hz: {gain:.3f}")
print(f"Phase: {math.degrees(phase):.1f}°")
Elektrik mühendisliği derslerinin temel hesabı — Python complex ile tek satır.

3. Mandelbrot fractal#

Karmaşık sayıların ünlü görsel uygulaması. Her noktada
z = z² + c
iterasyonu yap, kaçtığı hızla görselleştir:
def mandelbrot(c, max_iter=100):
    """Mandelbrot setinde mi? Kaç iterasyonda kaçtı?"""
    z = 0
    for n in range(max_iter):
        if abs(z) > 2:
            return n
        z = z * z + c
    return max_iter

# Test: birkaç nokta
print(mandelbrot(0))           # 100 (sette — hiç kaçmaz)
print(mandelbrot(1))           # 3 (hızla kaçar)
print(mandelbrot(-0.5))        # 100 (sette)
print(mandelbrot(0.5 + 0.5j))  # 5 (kaçıyor)

# Mandelbrot görsel — ASCII art
def mandelbrot_ascii(width=80, height=24):
    chars = " .,-:;+*#@"
    for y in range(height):
        row = ""
        for x in range(width):
            real = (x / width - 0.6) * 3
            imag = (y / height - 0.5) * 2
            c = real + imag * 1j
            iters = mandelbrot(c, max_iter=20)
            row += chars[min(iters * len(chars) // 20, len(chars) - 1)]
        print(row)

mandelbrot_ascii()
# Çıktı: ünlü "elma şekli" fraktal ASCII karakterlerle
Daha güzel görsel için matplotlib + numpy kullanılır (Modül 22). Ama temel mantık 5 satırlık
mandelbrot()
fonksiyonu.

4. Quantum hesaplama#

Quantum mekaniğinde "state vector" karmaşık sayı vektörüdür. Probability amplitudes, gate operations — hepsi karmaşık matrix çarpımı.
import numpy as np

# Qubit |0⟩ ve |1⟩ basis state
zero = np.array([1+0j, 0+0j])    # |0⟩
one = np.array([0+0j, 1+0j])     # |1⟩

# Hadamard gate — superposition yaratır
H = np.array([
    [1, 1],
    [1, -1]
]) / np.sqrt(2)

# |0⟩'a Hadamard uygula
result = H @ zero
print(result)
# [0.7071+0.j 0.7071+0.j]
# Yani 1/√2 (|0⟩ + |1⟩) — superposition!

# Probability of measuring |0⟩
prob_0 = abs(result[0]) ** 2
print(f"P(|0⟩) = {prob_0}")   # 0.5
Quantum SDK'lar (Qiskit, Cirq) bunun üstüne kurulu. Python'un complex desteği quantum computing'de tercih edilme sebeplerinden.
python
# Pratik: 2D oyun karakteri rotation
import cmath
import math
 
class GameObject:
    def __init__(self, x, y, heading_deg=0):
        self.position = complex(x, y)
        self.heading = math.radians(heading_deg)
 
    def move_forward(self, distance):
        """İleri doğru hareket et."""
        direction = cmath.exp(1j * self.heading)
        self.position += direction * distance
 
    def turn(self, angle_deg):
        """Açıyı değiştir."""
        self.heading += math.radians(angle_deg)
 
    def __repr__(self):
        x, y = self.position.real, self.position.imag
        deg = math.degrees(self.heading) % 360
        return f"GameObject(({x:.2f}, {y:.2f}) @ {deg:.0f}°)"
 
 
# Test: kare çiz
player = GameObject(0, 0, heading_deg=90)   # yukarı bakıyor
print(player)   # (0.00, 0.00) @ 90°
 
for _ in range(4):
    player.move_forward(10)
    player.turn(-90)        # sağa dön (saat yönü)
    print(player)
 
# Kare tamamlandı — başlangıca dönmüş olmalı
# (0.00, 0.00) @ 90°
# (0.00, 10.00) @ 90°  → ileri 10
# (10.00, 10.00) @ 0°  → -90° dön, sağa
# (10.00, 0.00) @ -90°
# (0.00, 0.00) @ 180°  → başlangıç
Karakter rotation'ı complex sayıyla — Pygame, Arcade gibi 2D oyun frameworkleri bu pattern'i sıkça kullanır.

Bu derste neler kazandın?#

✓ complex sayının Python'da built-in olduğu, j syntax'i (i değil — neden!)
✓ a.real, a.imag, a.conjugate(), abs(a) — temel attribute'lar.
✓ Karmaşık aritmetik — toplama, çıkarma, çarpma, bölme, üs.
✓
cmath
 modülü — sqrt(-1) gibi normalde hata atan işlemler.
✓ Euler'in formülü — e^(iπ) + 1 = 0, matematiğin en güzel denklemi.
✓ Polar form —
cmath.polar()
ve
cmath.rect()
, magnitude + faz.
✓ 2D rotation — matrix yerine complex çarpma kısayolu (oyun motorlarında pratik).
✓ 4 gerçek uygulama: Fourier transform, AC devre, Mandelbrot fractal, quantum gates.
✓ Hands-on: 2D game object rotation pattern.
Sıradaki ders:
Decimal
modülü. Float'un finansal hesaptaki sınırlarını gördük; şimdi Decimal ile tam hassas finansal aritmetiği öğreniyoruz. Türkiye KDV hesabı, döviz çevirici, sepet toplam — gerçek e-ticaret kodu pattern'leri.

Frequently Asked Questions

Web/backend dev olarak kullanmazsın. Veri analizi/ML — bazen FFT denk gelir, doğal kullanırsın. Sinyal işleme/elektronik/oyun geliştirmede çok kullanırsın. Quantum computing'e geçersen — günlük araç. Genel kural: Python'un ortalama kullanıcısı 1-5 kez bir kariyerde dokunur, ama dokunduğunda Java'dakine göre çok kolay olduğunu fark eder.

Yorumlar & Soru-Cevap

(0)
Yorum yazmak için giriş yap.
Yorumlar yükleniyor...

Related Content

Modül 1: Giriş ve Kurulum

Python Nedir, Neden Bu Kadar Popüler?

Start Learning
Modül 1: Giriş ve Kurulum

Python Sürümlerinin Tarihi: 2'den 3.14'e, AI Winter'lardan 'No-GIL' Devrimine

Start Learning
Modül 1: Giriş ve Kurulum

Python Implementasyonları: CPython, PyPy, MicroPython, Jython, IronPython, Pyodide

Start Learning