Operatörler

Operatörler, değerler üzerinde işlem yapan özel sembollerdir. Toplama, çıkarma gibi basit işlemlerden bitwise manipülasyonlara, kimlik kontrolünden walrus operatörüne kadar geniş bir yelpaze var. Bu derste Python'daki tüm operatör ailelerini öğreneceksin.

Operatörleri bir alet çantası gibi düşün. İçinde tornavida, pense, çekiç, anahtar — hepsi var. Her aletin kendine göre bir işi var ve doğru aleti doğru yerde kullanmak işini kolaylaştırır.

Aritmetik Operatörler

Matematiksel hesaplamalar için kullanılan operatörler. Bunları zaten tanıyorsun ama Python'a özgü birkaç incelik var.

a, b = 17, 5

print(f"{a} + {b}  = {a + b}")     # 22
print(f"{a} - {b}  = {a - b}")     # 12
print(f"{a} * {b}  = {a * b}")     # 85
print(f"{a} / {b}  = {a / b}")     # 3.4
print(f"{a} // {b} = {a // b}")    # 3
print(f"{a} % {b}  = {a % b}")     # 2
print(f"{a} ** {b} = {a ** b}")    # 1419857

/ vs // Detay

# / (true division) — her zaman float döner
print(10 / 2)      # 5.0 (tam bölünse bile float)
print(10 / 3)      # 3.3333333333333335

# // (floor division) — aşağıya yuvarlar
print(10 // 3)     # 3
print(10 // 2)     # 5 (int kalır)

# Float'larla da çalışır
print(10.0 // 3)   # 3.0 (sonuç float ama yuvarlanmış)

# ⚠️ Negatif sayılarda dikkat!
print(-7 // 2)     # -4 (eksi sonsuza yuvarlar)
print(7 // -2)     # -4
# -7 / 2 = -3.5, floor(-3.5) = -4

% (Mod) Pratik Kullanımlar

# Çift/tek kontrolü
for i in range(1, 11):
    durum = "Çift" if i % 2 == 0 else "Tek"
    print(f"{i:2d} → {durum}")

# Dairesel indeks (wrap-around)
renkler = ["kırmızı", "yeşil", "mavi"]
for i in range(9):
    print(f"{i}: {renkler[i % len(renkler)]}")

# Her n'inci elemanda işlem yap
for i in range(1, 21):
    if i % 5 == 0:
        print(f"--- {i}. adım tamamlandı ---")

Tekli (Unary) Operatörler

x = 5
print(+x)   # 5 (pozitif — genellikle bir etkisi yok)
print(-x)   # -5 (negatif)

y = -3
print(-y)   # 3 (negatifin negatifi)

Karşılaştırma Operatörleri

İki değeri karşılaştırır ve True veya False döner.

x, y = 10, 20

print(f"{x} == {y}: {x == y}")   # False
print(f"{x} != {y}: {x != y}")   # True
print(f"{x} <  {y}: {x < y}")    # True
print(f"{x} >  {y}: {x > y}")    # False
print(f"{x} <= {y}: {x <= y}")   # True
print(f"{x} >= {y}: {x >= y}")   # False

Farklı Tiplerde Karşılaştırma

# int ve float karşılaştırılabilir
print(1 == 1.0)      # True
print(1 < 1.5)        # True

# bool ve int
print(True == 1)       # True (bool int'in alt sınıfı)
print(False == 0)      # True

# String karşılaştırma (leksikografik — Unicode sırasına göre)
print("apple" < "banana")   # True
print("abc" == "abc")        # True
print("A" < "a")             # True (A=65, a=97)

# String'lerde büyüklük karşılaştırması karakter karakter yapılır
print("abc" < "abd")    # True (3. karakter: c < d)
print("abc" < "abcd")   # True (eşit başlangıç, kısa olan küçük)

Chained Comparison (Zincirleme Karşılaştırma)

Python'un en zarif özelliklerinden biri. Matematik notasyonuna çok yakın:

x = 15

# Aralık kontrolü — matematikteki 10 < x < 20 gibi
print(10 < x < 20)      # True
print(1 <= x <= 100)     # True
print(0 < x < 10)        # False

# Bu, aslında şunun kısaltması:
print(10 < x and x < 20)  # True — aynı sonuç ama daha uzun

# Üçlü zincir
a, b, c = 1, 2, 3
print(a < b < c)          # True (1 < 2 < 3)
print(a < b > c)          # False (1 < 2 ama 2 > 3 değil)

# Eşitlik zinciri
print(1 == 1 == 1)        # True
print(1 == 1 == 2)        # False

# Pratik: Not aralığı kontrolü
not_degeri = 75

if 90 <= not_degeri <= 100:
    harf = "A"
elif 80 <= not_degeri < 90:
    harf = "B"
elif 70 <= not_degeri < 80:
    harf = "C"
elif 60 <= not_degeri < 70:
    harf = "D"
else:
    harf = "F"

print(f"Not: {not_degeri} → Harf: {harf}")  # C

Mantıksal Operatörler: and, or, not

Boolean değerleri birleştiren operatörler.

and — Her İkisi de True

print(True and True)     # True
print(True and False)    # False
print(False and True)    # False
print(False and False)   # False

# Pratik
yas = 25
gelir = 5000
if yas >= 18 and gelir >= 3000:
    print("Kredi uygun")

or — En Az Biri True

print(True or True)      # True
print(True or False)     # True
print(False or True)     # True
print(False or False)    # False

# Pratik
gun = "Cumartesi"
if gun == "Cumartesi" or gun == "Pazar":
    print("Hafta sonu!")

not — Tersine Çevir

print(not True)     # False
print(not False)    # True

# Pratik
aktif = False
if not aktif:
    print("Hesap pasif")

Short-Circuit (Kısa Devre)

Python, sonucu belirleyecek kadar değerlendirir — gerisi atlanır:

# and: İlk False'ta durur
x = 0
if x != 0 and 10 / x > 2:  # 10/0 hatası oluşmaz!
    print("OK")

# or: İlk True'da durur
isim = "" or "Anonim"  # "Anonim"
print(isim)

# and ve or aslında operandlardan birini döner
print(1 and 2 and 3)        # 3 (hepsi truthy → son değer)
print(1 and 0 and 3)        # 0 (ilk falsy)
print(0 or "" or "hello")   # "hello" (ilk truthy)
print(0 or "" or [])         # [] (hepsi falsy → son değer)

Varsayılan Değer Deseni

# or ile varsayılan değer
kullanici_adi = input("Kullanıcı adı: ") or "misafir"

# and ile güvenli erişim
kullanici = {"isim": "Ali"}
isim = kullanici.get("isim") and kullanici["isim"].upper()
print(isim)  # ALI

Atama Operatörleri

Değişkenlere değer atamak ve güncellenmek için kullanılır.

Basit Atama

x = 10
isim = "Ali"
liste = [1, 2, 3]

Bileşik Atama (Augmented Assignment)

x = 10

x += 5     # x = x + 5   → 15
x -= 3     # x = x - 3   → 12
x *= 2     # x = x * 2   → 24
x /= 4     # x = x / 4   → 6.0
x //= 2    # x = x // 2  → 3.0
x %= 2     # x = x % 2   → 1.0
x **= 3    # x = x ** 3  → 1.0

print(x)   # 1.0

# String'lerle de çalışır
mesaj = "Merhaba"
mesaj += " Dünya"
print(mesaj)  # Merhaba Dünya

# Listelerle
liste = [1, 2]
liste += [3, 4]    # liste.extend([3, 4]) ile aynı
print(liste)  # [1, 2, 3, 4]

# *= ile tekrarlama
cizgi = "-"
cizgi *= 40
print(cizgi)  # ----------------------------------------

Mutable Nesnelerde Fark

# Immutable (int, str) — yeni nesne oluşturur
x = 10
print(id(x))    # 140234567890
x += 1
print(id(x))    # 140234567891 — farklı nesne!

# Mutable (list) — aynı nesneyi değiştirir
liste = [1, 2, 3]
print(id(liste))     # 140234999000
liste += [4]
print(id(liste))     # 140234999000 — aynı nesne!

# Ama list için += ve = [...] + [...] farklıdır
a = [1, 2]
b = a
a += [3]         # a'yı yerinde değiştirir, b de etkilenir
print(b)         # [1, 2, 3]

a = [1, 2]
b = a
a = a + [3]      # Yeni liste oluşturur, b etkilenmez
print(b)         # [1, 2]

⚠️ Dikkat: Listeler için += ve = ... + ... farklı davranır! += listeyi yerinde değiştirir (aynı nesne), = ... + ... yeni bir liste oluşturur. Referans paylaşılan listelerde bu fark önemli.

Bitwise (Bit Düzeyinde) Operatörler

Sayıların ikili (binary) gösterimindeki bitler üzerinde işlem yapar. Düşük seviyeli programlama, bayrak yönetimi, şifreleme ve optimizasyon için kullanılır.

a = 0b1100  # 12
b = 0b1010  # 10

print(f"a     = {a:04b} ({a})")          # 1100 (12)
print(f"b     = {b:04b} ({b})")          # 1010 (10)
print(f"a & b = {a & b:04b} ({a & b})")  # 1000 (8)
print(f"a | b = {a | b:04b} ({a | b})")  # 1110 (14)
print(f"a ^ b = {a ^ b:04b} ({a ^ b})")  # 0110 (6)
print(f"~a    = {~a} (bit tersine çevir)")  # -13

Bit Kaydırma

x = 1  # 0001

print(f"{x}  << 1 = {x << 1}")   # 2  (0010) — 2 ile çarpma
print(f"{x}  << 2 = {x << 2}")   # 4  (0100) — 4 ile çarpma
print(f"{x}  << 3 = {x << 3}")   # 8  (1000) — 8 ile çarpma

y = 16  # 10000
print(f"{y} >> 1 = {y >> 1}")   # 8  (01000) — 2'ye bölme
print(f"{y} >> 2 = {y >> 2}")   # 4  (00100) — 4'e bölme
print(f"{y} >> 3 = {y >> 3}")   # 2  (00010) — 8'e bölme

💡 İpucu: << n işlemi sayıyı 2^n ile çarpmakla, >> n işlemi 2^n'e bölmekle aynıdır. Bu, çarpma/bölme yerine kullanıldığında çok daha hızlıdır — ama modern Python'da bu optimizasyona genellikle gerek yoktur. Okunabilirlik daha önemli.

Pratik: Bayrak (Flag) Yönetimi

# Bayraklar — her bit bir özelliği temsil eder
READ    = 0b001  # 1
WRITE   = 0b010  # 2
EXECUTE = 0b100  # 4

# Bayrak birleştirme (OR)
yetki = READ | WRITE  # 0b011 = 3
print(f"Yetki: {yetki:03b}")  # 011

# Bayrak kontrolü (AND)
if yetki & READ:
    print("Okuma yetkisi var")      # ✅
if yetki & WRITE:
    print("Yazma yetkisi var")      # ✅
if yetki & EXECUTE:
    print("Çalıştırma yetkisi var") # Çalışmaz

# Bayrak ekleme (OR)
yetki = yetki | EXECUTE  # veya yetki |= EXECUTE
print(f"Yetki: {yetki:03b}")  # 111 = 7

# Bayrak kaldırma (AND NOT)
yetki = yetki & ~WRITE  # veya yetki &= ~WRITE
print(f"Yetki: {yetki:03b}")  # 101 = 5

# Bayrak değiştirme / toggle (XOR)
yetki = yetki ^ READ  # READ varsa kaldır, yoksa ekle
print(f"Yetki: {yetki:03b}")  # 100 = 4

XOR ile Swap (Ekstra Bilgi)

# XOR ile geçici değişken kullanmadan swap
a = 5  # 0101
b = 3  # 0011

a = a ^ b  # a = 0110 (6)
b = a ^ b  # b = 0101 (5) — orijinal a
a = a ^ b  # a = 0011 (3) — orijinal b

print(f"a = {a}, b = {b}")  # a = 3, b = 5

# Ama Python'da a, b = b, a daha temiz ve okunaklı!

Üyelik Operatörleri: in, not in

Bir değerin bir koleksiyon içinde olup olmadığını kontrol eder.

# Liste
meyveler = ["elma", "armut", "muz"]
print("elma" in meyveler)       # True
print("portakal" in meyveler)   # False
print("portakal" not in meyveler)  # True

# String (alt string arama)
metin = "Python programlama dili"
print("Python" in metin)        # True
print("Java" in metin)          # False

# Tuple
renkler = ("kırmızı", "yeşil", "mavi")
print("yeşil" in renkler)      # True

# Dictionary (key'lerde arar)
notlar = {"Ali": 85, "Veli": 72}
print("Ali" in notlar)          # True (key arar)
print(85 in notlar)             # False (value'da aramaz)
print(85 in notlar.values())    # True (value'da aramak için)

# Set
izinli = {"admin", "moderator", "editor"}
print("admin" in izinli)       # True

# Pratik: Kullanıcı girdisi doğrulama
gecerli_secenekler = ["evet", "hayır", "e", "h"]

cevap = input("Devam? (evet/hayır): ").lower().strip()
if cevap in gecerli_secenekler:
    print(f"Seçiminiz: {cevap}")
else:
    print("Geçersiz seçenek!")

Performans Notu

# in operatörünün hızı veri yapısına göre değişir:
# list/tuple: O(n) — teker teker arar
# set/frozenset: O(1) — hash tablosuyla anında bulur
# dict: O(1) — key hash'iyle anında bulur

# Çok sayıda arama yapacaksan set kullan
# ❌ Yavaş
buyuk_liste = list(range(1000000))
print(999999 in buyuk_liste)  # Yavaş — 1M eleman tarar

# ✅ Hızlı
buyuk_set = set(range(1000000))
print(999999 in buyuk_set)    # Anında — hash ile bulur

Kimlik Operatörleri: is, is not

İki değişkenin aynı nesneye referans verip vermediğini kontrol eder. == değer eşitliği, is kimlik eşitliği.

a = [1, 2, 3]
b = [1, 2, 3]
c = a

# == değer eşitliği
print(a == b)    # True (değerler aynı)
print(a == c)    # True

# is kimlik eşitliği (aynı nesne mi?)
print(a is b)    # False (farklı nesneler)
print(a is c)    # True (aynı nesne)
print(a is not b)  # True

# id() ile doğrula
print(id(a) == id(b))  # False
print(id(a) == id(c))  # True

None Kontrolü

is operatörünün en yaygın kullanımı None kontrolüdür:

x = None

# ✅ Doğru yol
if x is None:
    print("x tanımsız")

if x is not None:
    print("x'in bir değeri var")

# ❌ Yanlış yol (çalışır ama PEP 8'e aykırı)
if x == None:
    print("Bu da çalışır ama önerilmez")

Küçük Tam Sayı Havuzu

# Python -5 ile 256 arasını önbelleğe alır
a = 256
b = 256
print(a is b)   # True — aynı nesne (önbellekten)

a = 257
b = 257
print(a is b)   # False veya True — ortama bağlı

# String interning
a = "hello"
b = "hello"
print(a is b)   # True — Python string'leri de önbelleğe alabilir

# Ama bu her zaman güvenilmez
a = "hello world"
b = "hello world"
print(a is b)   # Genellikle True (aynı scope'ta) ama garanti değil

⚠️ Dikkat: Değer karşılaştırması için her zaman == kullan, is değil. is sadece None kontrolü ve özel durumlar için. is ile True/False kontrolü de yapma — if x is True: yerine if x: yaz.

Walrus Operatörü (:=) — Python 3.8+

"Walrus operatörü" (mors hayvanı gibi göründüğü için bu isim verilmiş: :=), bir ifadeyi değerlendirirken aynı anda değişkene atama yapar.

Temel Kullanım

# Walrus olmadan
n = len("merhaba")
if n > 5:
    print(f"Uzun string: {n} karakter")

# Walrus ile — atama ve kontrol tek satırda
if (n := len("merhaba")) > 5:
    print(f"Uzun string: {n} karakter")

While Döngüsünde

# Walrus olmadan
satir = input("Giriş (q=çıkış): ")
while satir != "q":
    print(f"Yazdığınız: {satir}")
    satir = input("Giriş (q=çıkış): ")

# Walrus ile — daha temiz
while (satir := input("Giriş (q=çıkış): ")) != "q":
    print(f"Yazdığınız: {satir}")

Liste Comprehension'da

# Pahalı fonksiyonu iki kere çağırma
import math

sayilar = [2, 5, 10, 15, 20, 25, 30]

# Walrus olmadan
sonuclar = []
for s in sayilar:
    kok = math.sqrt(s)
    if kok > 3:
        sonuclar.append(kok)

# Walrus ile
sonuclar = [kok for s in sayilar if (kok := math.sqrt(s)) > 3]
print(sonuclar)  # [3.162..., 3.872..., 4.472..., 5.0, 5.477...]

Regex ile

import re

metin = "Sipariş #12345 onaylandı"

# Walrus olmadan
match = re.search(r"#(\d+)", metin)
if match:
    print(f"Sipariş no: {match.group(1)}")

# Walrus ile
if (match := re.search(r"#(\d+)", metin)):
    print(f"Sipariş no: {match.group(1)}")

Ne Zaman Kullanmalı?

# ✅ İyi kullanım — tekrarlanan hesaplamayı önler
if (uzunluk := len(veri)) > MAX_BOYUT:
    print(f"Veri çok büyük: {uzunluk}")

# ✅ İyi kullanım — while döngüsü temizlenir
while (chunk := dosya.read(8192)):
    isleme(chunk)

# ❌ Kötü kullanım — okunabilirliği düşürür
sonuc = (x := 10) + (y := 20) + (z := x + y)
# Bu karmaşık ve zor okunur. Normal atama kullan.

💡 İpucu: Walrus operatörünü aşırı kullanma. Kodun okunabilirliğini artırıyorsa kullan, düşürüyorsa normal atama yap. Basit durumlar için walrus gereksiz karmaşıklık ekler.

Operatör Önceliği (Precedence)

Birden fazla operatör bir ifadede kullanıldığında, hangi operatörün önce değerlendirileceğini belirler. Matematikteki "önce çarpma, sonra toplama" kuralının genişletilmiş hali.

Öncelik Tablosu (Yüksekten Düşüğe)

# Öncelik örnekleri
print(2 + 3 * 4)       # 14 (çarpma önce)
print((2 + 3) * 4)     # 20 (parantez önce)

print(2 ** 3 ** 2)      # 512 (** sağdan sola: 2^(3^2) = 2^9)
print((2 ** 3) ** 2)    # 64

print(not True or False)   # False (not önce: (not True) or False)
print(not (True or False)) # False

print(True or True and False)  # True (and önce: True or (True and False))
print((True or True) and False) # False

Karmaşık İfadeler

x = 5

# Bu neye eşit?
sonuc = x > 3 and x < 10 or x == 0
# Adım 1: (x > 3) and (x < 10) or (x == 0)
# Adım 2: (True and True) or False
# Adım 3: True or False
# Adım 4: True
print(sonuc)  # True

# Parantezle daha okunaklı
sonuc = (x > 3 and x < 10) or (x == 0)

# Veya zincirleme karşılaştırma
sonuc = 3 < x < 10 or x == 0

Tavsiye: Şüphe Duyduğunda Parantez Kullan

# ❌ Belirsiz — okuyucu önceliği hatırlamak zorunda
sonuc = a + b * c ** d // e % f

# ✅ Açık — parantezle niyet belli
sonuc = a + ((b * (c ** d)) // e) % f

# Veya parçalara ayır
us = c ** d
carpim = b * us
bolum = carpim // e
kalan = bolum % f
sonuc = a + kalan

Operatör Overloading (Kısa Bir Bakış)

Python'da sınıflar, operatörlerin davranışını özelleştirebilir. Bu sayede + operatörü sayılar için toplama, stringler için birleştirme, listeler için birleştirme yapar.

# + operatörü farklı tiplerde farklı davranır
print(1 + 2)            # 3 (sayı toplama)
print("ab" + "cd")      # abcd (string birleştirme)
print([1, 2] + [3, 4])  # [1, 2, 3, 4] (liste birleştirme)

# * operatörü
print(3 * 4)             # 12 (sayı çarpma)
print("Ha" * 3)          # HaHaHa (string tekrarlama)
print([0] * 5)           # [0, 0, 0, 0, 0] (liste tekrarlama)

Kendi sınıflarında da operatörleri tanımlayabilirsin:

class Vektor:
    def __init__(self, x, y):
        self.x = x
        self.y = y
    
    def __add__(self, other):
        return Vektor(self.x + other.x, self.y + other.y)
    
    def __repr__(self):
        return f"Vektor({self.x}, {self.y})"

v1 = Vektor(1, 2)
v2 = Vektor(3, 4)
v3 = v1 + v2
print(v3)  # Vektor(4, 6)

Bu konuyu "Sınıflar ve OOP" dersinde derinlemesine göreceğiz.

Pratik Örnekler

Yetki Kontrol Sistemi

# Bitwise flags ile yetki sistemi
class Yetki:
    OKUMA    = 1 << 0   # 001 = 1
    YAZMA    = 1 << 1   # 010 = 2
    SILME    = 1 << 2   # 100 = 4
    ADMIN    = OKUMA | YAZMA | SILME  # 111 = 7

def yetki_kontrol(kullanici_yetkisi, gereken_yetki):
    return bool(kullanici_yetkisi & gereken_yetki)

def yetki_goster(yetki):
    yetkiler = []
    if yetki & Yetki.OKUMA:  yetkiler.append("Okuma")
    if yetki & Yetki.YAZMA:  yetkiler.append("Yazma")
    if yetki & Yetki.SILME:  yetkiler.append("Silme")
    return ", ".join(yetkiler) or "Yetki yok"

# Kullanıcılar
editor = Yetki.OKUMA | Yetki.YAZMA     # 011 = 3
okuyucu = Yetki.OKUMA                    # 001 = 1
admin = Yetki.ADMIN                      # 111 = 7

print(f"Editor:  {yetki_goster(editor)}")    # Okuma, Yazma
print(f"Okuyucu: {yetki_goster(okuyucu)}")   # Okuma
print(f"Admin:   {yetki_goster(admin)}")     # Okuma, Yazma, Silme

# Silme yetkisi var mı?
print(yetki_kontrol(editor, Yetki.SILME))   # False
print(yetki_kontrol(admin, Yetki.SILME))    # True

Hesap Makinesi

def hesap_makinesi():
    """Basit ama güvenli hesap makinesi"""
    islemler = {
        '+': lambda a, b: a + b,
        '-': lambda a, b: a - b,
        '*': lambda a, b: a * b,
        '/': lambda a, b: a / b if b != 0 else "Sıfıra bölünemez!",
        '//': lambda a, b: a // b if b != 0 else "Sıfıra bölünemez!",
        '%': lambda a, b: a % b if b != 0 else "Sıfıra bölünemez!",
        '**': lambda a, b: a ** b,
    }
    
    print("Hesap Makinesi")
    print(f"İşlemler: {', '.join(islemler.keys())}")
    
    a = float(input("İlk sayı: "))
    islem = input("İşlem: ")
    b = float(input("İkinci sayı: "))
    
    if islem in islemler:
        sonuc = islemler[islem](a, b)
        print(f"{a} {islem} {b} = {sonuc}")
    else:
        print("Geçersiz işlem!")

# hesap_makinesi()

Özet

• Aritmetik operatörler: +, -, *, / (float döner), // (aşağı yuvarlar), % (kalan), ** (üs).

• Karşılaştırma operatörleri boolean döner; Python zincirleme karşılaştırma destekler: 1 < x < 10.

• Mantıksal operatörler (and, or, not) short-circuit yapar — and ilk falsy'de, or ilk truthy'de durur.

• Bitwise operatörler (&, |, ^, ~, <<, >>) bit düzeyinde çalışır — bayrak yönetimi ve düşük seviye işlemler için.

• Walrus operatörü (:=) atama ve değerlendirmeyi tek ifadede yapar — while döngüleri ve koşullarda kodun temizliğini artırır.

• Operatör önceliği: Şüphe duyduğunda parantez kullan — okunabilirlik her zaman öncelikli.