← Kursa Dön
📄 Text · 15 min

Python Söz Dizimi Temelleri

Her dilin bir grameri vardır. Türkçe'de cümle özne ile başlar, fiil sonda gelir. İngilizce'de sıralama farklıdır. Programlama dilleri de böyledir — her birinin kendine özgü söz dizimi (syntax) kuralları vardır.

Python'ın söz dizimi kuralları, onu diğer dillerden ayıran en önemli özelliklerden biridir. Bu derste Python'ın "gramerini" öğreneceksin: girintileme, anahtar kelimeler, isimlendirme kuralları ve dinamik tipleme.

Girintileme (Indentation): Python'ın Olmazsa Olmazı

Python'ın en ayırt edici özelliği girintileme (indentation) kuralıdır. Diğer birçok dilde girintileme sadece güzel görünsün diye yapılır. Python'da ise zorunludur — girintileme yanlışsa kod çalışmaz.

Neden Girintileme?

Çoğu programlama dilinde kod blokları süslü parantezlerle ({}) belirlenir:

// JavaScript örneği
if (yas >= 18) {
    console.log("Yetişkin");
    console.log("Oy kullanabilir");
}

Python'da süslü parantez yoktur. Bunun yerine girintileme (boşluklar) kullanılır:

# Python
if yas >= 18:
    print("Yetişkin")
    print("Oy kullanabilir")

İki nokta (:) bir kod bloğunun başladığını belirtir. Sonraki satırlar girintili yazılır ve aynı girintiye sahip satırlar aynı bloğa ait sayılır.

4 Boşluk Kuralı

Python'da standart girintileme 4 boşluk (space) karakteridir. Tab tuşu da kullanılabilir ama 4 boşluk tercih edilir.

Analoji: Girintileme, bir kitaptaki paragraf girintisi gibidir. Yeni bir paragraf başladığını girintiden anlarsın. Python'da da yeni bir kod bloğunun başladığını girintiden anlarsın.

# Doğru girintileme (4 boşluk)
if True:
    print("Birinci seviye")
    if True:
        print("İkinci seviye")
        if True:
            print("Üçüncü seviye")

IndentationError: En Sık Hata

Girintileme hataları, yeni başlayanların en sık karşılaştığı hatalardır:

# HATALI — girintileme eksik
if True:
print("Merhaba")    # IndentationError!

# HATALI — gereksiz girintileme
x = 5
    print(x)         # IndentationError!

# HATALI — tutarsız girintileme
if True:
    print("Bir")
      print("İki")   # IndentationError! (6 boşluk, 4 olmalıydı)

Doğru kullanım:

# DOĞRU
if True:
    print("Bir")
    print("İki")

x = 5
print(x)

Tab vs Space Savaşı

Python'da tab ve boşluk (space) karıştırılmamalıdır. Aynı dosyada ikisini birden kullanırsan TabError alırsın.

# HATALI — tab ve space karışık
if True:
	print("Tab ile")       # Tab kullanılmış
    print("Space ile")     # Space kullanılmış → TabError!

Kural: Her zaman 4 boşluk kullan, tab kullanma. VS Code'da tab tuşuna bastığında otomatik olarak 4 boşluk eklemesini ayarlayabilirsin (genellikle varsayılan ayar budur).

⚠️ Dikkat: VS Code'un alt çubuğunda "Spaces: 4" yazdığından emin ol. "Tab Size: 4" yazıyorsa, tıklayıp "Indent Using Spaces" seçeneğine geçebilirsin. Bu küçük ayar seni çok fazla hatadan kurtarır.

İç İçe Bloklar (Nested Blocks)

Birden fazla girintileme seviyesi olabilir:

yas = 20
ogrenci = True

if yas >= 18:
    print("Yetişkin")                  # 4 boşluk (1. seviye)
    
    if ogrenci:
        print("Öğrenci indirimi var")  # 8 boşluk (2. seviye)
        indirim = 0.20
        
        if indirim > 0.15:
            print("Yüksek indirim!")   # 12 boşluk (3. seviye)
    
    print("Hoş geldiniz")             # 4 boşluk (tekrar 1. seviye)

print("Program bitti")                 # 0 boşluk (ana seviye)

Her seviye 4 boşluk ekler: 0, 4, 8, 12... Bu yapı, kodun hangi bloğa ait olduğunu görsel olarak çok net gösterir.

Girintileme Gerektiren Yapılar

Hangi durumlarda girintileme gerekir?

# if/elif/else
if kosul:
    # girintili kod

# for döngüsü
for eleman in liste:
    # girintili kod

# while döngüsü
while kosul:
    # girintili kod

# Fonksiyon tanımı
def fonksiyon():
    # girintili kod

# Sınıf tanımı
class Sinif:
    # girintili kod

# try/except
try:
    # girintili kod
except:
    # girintili kod

# with bloğu
with open("dosya.txt") as f:
    # girintili kod

Bu yapıların hepsinde : (iki nokta) ile biten satırın ardından girintili bir blok gelir.

Satır Devamı (Line Continuation)

Bazen bir kod satırı çok uzun olabilir. Python'da uzun satırları bölmenin birkaç yolu var.

Ters Eğik Çizgi (\) ile Satır Devamı

Satır sonuna \ koyarak bir sonraki satırda devam edebilirsin:

# Uzun bir matematiksel ifade
toplam = 1 + 2 + 3 + 4 + 5 + \
         6 + 7 + 8 + 9 + 10

# Uzun bir string
mesaj = "Bu çok uzun bir mesajdır ve " \
        "bir satıra sığmadığı için " \
        "birden fazla satıra bölünmüştür."

# Uzun bir koşul
if (yas >= 18 and \
    vatandas == True and \
    sabika_kaydi == False):
    print("Oy kullanabilir")

Parantez İçinde Otomatik Devam

Parantez (), köşeli parantez [] veya süslü parantez {} içinde satır otomatik olarak devam eder. \ kullanmana gerek kalmaz:

# Parantez içinde — otomatik devam
toplam = (1 + 2 + 3 + 4 + 5 +
          6 + 7 + 8 + 9 + 10)

# Liste tanımı — otomatik devam
meyveler = [
    "elma",
    "armut",
    "portakal",
    "muz",
    "çilek",
]

# Sözlük tanımı — otomatik devam
kisi = {
    "isim": "Ayşe",
    "yas": 25,
    "sehir": "İstanbul",
}

# Fonksiyon çağrısı — otomatik devam
sonuc = print(
    "Birinci parametre",
    "İkinci parametre",
    "Üçüncü parametre",
    sep=" | "
)

💡 İpucu: Mümkün olduğunca \ yerine parantez yöntemini tercih et. Parantez içinde satır devamı daha okunaklı ve hata yapma olasılığı daha düşük. \ sonrasına yanlışlıkla bir boşluk koyarsan (gözle görülmeyen hata!), Python hata verir.

Uzun String'ler

Çok satırlı string'ler için üç tırnak kullanabilirsin:

# Üç tırnak ile çok satırlı string
aciklama = """
Bu çok satırlı bir stringdir.
İçinde istediğin kadar satır olabilir.
Girintileme de korunur.
"""

# veya yan yana string'ler otomatik birleşir
mesaj = ("Bu birinci parça "
         "bu ikinci parça "
         "bu üçüncü parça.")
print(mesaj)
# Çıktı: Bu birinci parça bu ikinci parça bu üçüncü parça.

Bir Satırda Birden Fazla İfade (Statement)

Python'da noktalı virgül (;) ile bir satırda birden fazla ifade yazabilirsin:

# Teknik olarak çalışır
x = 1; y = 2; z = 3
print(x); print(y); print(z)

Ama Yapma!

Bu, Python'ın felsefesine aykırıdır. Okunabilirliği düşürür. PEP 8 (Python'ın stil kılavuzu) bunu tavsiye etmez.

# KÖTÜ — okunması zor
x = 1; y = 2; z = 3; print(x + y + z)

# İYİ — her ifade kendi satırında
x = 1
y = 2
z = 3
print(x + y + z)

Analoji: Bir satıra birden fazla ifade yazmak, bir cümlede hiç nokta kullanmamak gibidir bu cümleyi okuması çok zor değil mi hani nerede bitiyor nerede başlıyor anlamak güç oluyor. Gördün mü? Her ifade kendi satırında olunca, her cümle kendi noktasıyla bitince okunması çok daha kolay.

İstisna: REPL'de (interaktif kabuk) hızlı denemeler yaparken bazen kullanılabilir. Ama script dosyalarında kullanma.

# REPL'de hızlı deneme — kabul edilebilir
>>> x = 5; print(x * 2)
10

Anahtar Kelimeler (Keywords)

Python'da bazı kelimeler ayrılmış (reserved) olarak işaretlenmiştir. Bu kelimeler Python'ın söz diziminin parçasıdır ve değişken adı olarak kullanamazsın.

Tam Liste

Python 3.12 itibarıyla 35 anahtar kelime var:

import keyword
print(keyword.kwlist)
False      True       None       and        as
assert     async      await      break      class
continue   def        del        elif       else
except     finally    for        from       global
if         import     in         is         lambda
nonlocal   not        or         pass       raise
return     try        while      with       yield

Kategorilere Göre

Mantıksal değerler:

True       # Doğru
False      # Yanlış
None       # Boş/hiçbir şey

Koşul ve döngü:

if         # Eğer
elif       # Değilse eğer
else       # Değilse
for        # Döngü (koleksiyon üzerinde)
while      # Döngü (koşul sağlandığı sürece)
break      # Döngüyü kır
continue   # Sonraki iterasyona geç
pass       # Hiçbir şey yapma (yer tutucu)

Fonksiyon ve sınıf:

def        # Fonksiyon tanımla
return     # Değer döndür
class      # Sınıf tanımla
lambda     # Anonim fonksiyon
yield      # Generator fonksiyon

Hata yönetimi:

try        # Hata olabilecek kod
except     # Hata yakala
finally    # Her durumda çalış
raise      # Hata fırlat
assert     # Doğrulama

Mantıksal operatörler:

and        # Ve
or         # Veya
not        # Değil
is         # Aynı nesne mi
in         # İçinde mi

Diğer:

import     # Modül içe aktar
from       # Modülden belirli bir şey al
as         # Takma ad ver
with       # Context manager
del        # Sil
global     # Global değişken belirt
nonlocal   # Üst scope'taki değişkene eriş
async      # Asenkron fonksiyon
await      # Asenkron bekleme

Anahtar Kelime Kullanamama

# HATALI — anahtar kelimeler değişken adı olamaz
# class = "Matematik"     # SyntaxError!
# for = 10                # SyntaxError!
# if = True               # SyntaxError!

# DOĞRU — alternatif isimler kullan
sinif = "Matematik"
dongu_sayisi = 10
kosul = True

pass: Boş Yer Tutucu

pass özel bir anahtar kelimedir — "hiçbir şey yapma" anlamına gelir. Boş bloklar oluşturmak için kullanılır:

# Henüz yazmadığın bir fonksiyon
def hesapla():
    pass    # TODO: İleride yazılacak

# Boş bir if bloğu
if True:
    pass    # Şimdilik bir şey yapma

# Boş bir sınıf
class Ogrenci:
    pass

pass olmadan boş bir blok bırakırsan IndentationError alırsın. pass, "buraya bir şey gelecek ama henüz yazmadım" demek gibidir.

Identifier Kuralları: İsimlendirme

Identifier (tanımlayıcı), değişkenlere, fonksiyonlara, sınıflara ve modüllere verdiğin isimlerdir. Python'da isimlendirme kuralları şunlardır:

Zorunlu Kurallar

  1. Harf veya alt çizgi ile başlamalı: Sayı ile başlayamaz

# DOĞRU
isim = "Ayşe"
_gizli = "secret"
sayi1 = 42
İsim = "Ahmet"    # Türkçe karakter teknik olarak çalışır

# HATALI
# 1sayi = 42       # SyntaxError! Sayı ile başlayamaz
# my-var = 10      # SyntaxError! Tire kullanılamaz
# my var = 10      # SyntaxError! Boşluk kullanılamaz

  1. Sadece harf, sayı ve alt çizgi: Özel karakterler (@, #, $, -, boşluk) kullanılamaz

# DOĞRU
ogrenci_adi = "Ayşe"
sayi_2 = 100
_ozel_degisken = True

# HATALI
# ogrenci-adi = "Ayşe"    # Tire kullanılamaz
# ogrenci adi = "Ayşe"    # Boşluk kullanılamaz
# ogrenci@adi = "Ayşe"    # @ kullanılamaz

  1. Anahtar kelime olamaz: if, for, class gibi anahtar kelimeler değişken adı olarak kullanılamaz

Konvansiyonlar (Önerilen Kurallar)

Zorunlu olmayan ama Python topluluğunun benimsediği isimlendirme kuralları:

# snake_case — değişkenler ve fonksiyonlar için
kullanici_adi = "ahmet"
dogum_tarihi = "1999-05-15"

def toplam_hesapla(a, b):
    return a + b

# PascalCase — sınıflar için
class OgrenciBilgisi:
    pass

class HttpSunucu:
    pass

# UPPER_CASE — sabitler için
PI = 3.14159
MAX_DENEME = 3
VERITABANI_URL = "localhost:5432"

# _tek_alt_cizgi — "özel" (internal) değişkenler
_dahili_sayac = 0

# __cift_alt_cizgi — name mangling (ileri seviye)
__gizli = "çok özel"

snake_case Nedir?

Python'da değişken ve fonksiyon isimleri snake_case ile yazılır: kelimeler küçük harfle, aralarına alt çizgi (_) konur.

# snake_case (Python standardı) ✅
kullanici_adi = "ahmet"
toplam_fiyat = 150.0
ogrenci_sayisi = 42

# camelCase (Java/JavaScript standardı) ❌
# Python'da kullanılmaz ama çalışır
kullaniciAdi = "ahmet"
toplamFiyat = 150.0

Kural: Python'da her zaman snake_case kullan. camelCase teknik olarak çalışır ama Python topluluğunda garip karşılanır.

İyi İsim Seçimi

İsimlendirme, programlamanın en zor yanlarından biridir. İyi bir isim, kodu belge (documentation) olmadan anlaşılır kılar.

# KÖTÜ — ne olduğu anlaşılmıyor
x = 25
y = "İstanbul"
z = True

# İYİ — anlamlı isimler
yas = 25
sehir = "İstanbul"
ogrenci_mi = True

# KÖTÜ — çok kısa veya çok uzun
a = 3.14
b = kullanicinin_en_son_giris_yaptigi_tarih_ve_saat_bilgisi

# İYİ — dengeli
pi = 3.14
son_giris = "2024-01-15 14:30"

💡 İpucu: Değişken isimlendirirken kendine sor: "6 ay sonra bu koda baktığımda, bu değişkenin ne olduğunu anlayabilir miyim?" Cevap "evet" ise iyi bir isim seçmişsin demektir.

Büyük/Küçük Harf Duyarlılığı (Case Sensitivity)

Python, büyük ve küçük harfleri farklı kabul eder. Yani isim, Isim ve ISIM üç farklı değişkendir.

isim = "Ayşe"
Isim = "Mehmet"
ISIM = "Ali"

print(isim)    # Ayşe
print(Isim)    # Mehmet
print(ISIM)    # Ali

Bu üç değişken birbirinden tamamen bağımsızdır. Ama pratikte bu şekilde kullanmak çok kötü bir pratiktir — okuyucunun kafasını karıştırır.

Sık Yapılan Hatalar

# HATALI — büyük/küçük harf uyumsuzluğu
isim = "Ayşe"
print(Isim)     # NameError! 'Isim' tanımlı değil, 'isim' tanımlı

# HATALI — fonksiyon adı yanlış
Print("Merhaba")  # NameError! 'Print' değil 'print'

# HATALI — anahtar kelime büyük harfle
If True:           # SyntaxError! 'If' değil 'if'
    pass

Standart Kurallar

# Değişkenler ve fonksiyonlar: küçük harf + snake_case
kullanici_adi = "ahmet"

def fiyat_hesapla():
    pass

# Sınıflar: PascalCase (her kelimenin ilk harfi büyük)
class KullaniciBilgisi:
    pass

# Sabitler: TAMAMI BÜYÜK HARF
MAX_DENEME_SAYISI = 5
PI = 3.14159

Bu kurallar konvansiyondur (zorunlu değil) ama Python topluluğunda herkes bunlara uyar.

Dinamik Tipleme (Dynamic Typing)

Python dinamik tipli (dynamically typed) bir dildir. Bu ne demek? Bir değişken tanımlarken onun tipini belirtmene gerek yok. Python, değişkenin tipini değerine bakarak otomatik olarak belirler.

Statik vs Dinamik Tipleme

Statik tipli diller (Java, C, C++):

// Java — tip belirtilmek ZORUNDA
int yas = 25;
String isim = "Ayşe";
double boy = 1.72;

Dinamik tipli diller (Python, JavaScript, Ruby):

# Python — tip belirtmeye GEREK YOK
yas = 25         # Python bilir: bu int
isim = "Ayşe"    # Python bilir: bu str
boy = 1.72       # Python bilir: bu float

Python'da int yas = 25 yazmana gerek yok. Sadece yas = 25 yaz, Python tipi otomatik anlar.

Tip Değişebilir

Dinamik tiplemede bir değişkenin tipi sonradan değişebilir:

x = 42          # x şu an int
print(type(x))  # <class 'int'>

x = "Merhaba"   # x artık str
print(type(x))  # <class 'str'>

x = [1, 2, 3]   # x artık list
print(type(x))  # <class 'list'>

x = True         # x artık bool
print(type(x))  # <class 'bool'>

Bu esneklik geliştirme hızını artırır ama dikkatli olmayı gerektirir.

Analoji: Statik tipleme, etiketli kutular gibidir — "Oyuncaklar" yazan kutuya sadece oyuncak koyabilirsin. Dinamik tipleme ise etiketsiz kutular gibidir — herhangi bir kutuya istediğin şeyi koyabilirsin. Esneklik var ama "bu kutuda ne vardı?" diye karıştırma riski de var.

type() Fonksiyonu

Bir değişkenin tipini öğrenmek için type() fonksiyonunu kullanırsın:

a = 42
b = 3.14
c = "Python"
d = True
e = [1, 2, 3]
f = None

print(type(a))   # <class 'int'>
print(type(b))   # <class 'float'>
print(type(c))   # <class 'str'>
print(type(d))   # <class 'bool'>
print(type(e))   # <class 'list'>
print(type(f))   # <class 'NoneType'>

isinstance() ile Tip Kontrolü

Bir değişkenin belirli bir tipte olup olmadığını kontrol etmek için isinstance() kullanılır:

yas = 25
isim = "Ayşe"

print(isinstance(yas, int))     # True
print(isinstance(yas, str))     # False
print(isinstance(isim, str))    # True

# Birden fazla tip kontrolü
sayi = 3.14
print(isinstance(sayi, (int, float)))  # True

Dikkat: Tip Hataları

Dinamik tipleme kolaylık sağlar ama hataya açık kapı bırakır:

# Tehlikeli durum
fiyat = "100"      # Bu bir string!
kdv = fiyat * 0.20  # TypeError! String ile float çarpılamaz

# Güvenli yol
fiyat = 100         # Bu bir int
kdv = fiyat * 0.20  # 20.0 — doğru!

# veya dönüştür
fiyat = "100"
kdv = int(fiyat) * 0.20  # 20.0 — doğru!

⚠️ Dikkat: Python'ın dinamik tipleme özelliği, hataların derleme zamanında değil çalışma zamanında (runtime) ortaya çıkmasına neden olur. Kod çalışana kadar hatayı göremeyebilirsin. Bu nedenle değişken isimlendirmesine ve tip kontrolüne dikkat et. İleride "type hints" ile bu soruna çözüm getirmeyi de öğreneceğiz.

Değişken Atama (Assignment)

Python'da değişken atamak çok basittir:

# Temel atama
x = 10

# Çoklu atama (aynı satırda)
a, b, c = 1, 2, 3
print(a, b, c)    # 1 2 3

# Aynı değeri birden fazla değişkene atama
x = y = z = 0
print(x, y, z)    # 0 0 0

# Değer değiştirme (swap)
a = 1
b = 2
a, b = b, a       # Pythonic swap!
print(a, b)        # 2 1

Artırılmış 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 **= 3    # x = x ** 3 → 27.0
x %= 5     # x = x % 5  → 2.0

x++ Python'da Yok!

C, Java, JavaScript gibi dillerde x++ veya ++x ile değişkeni 1 artırabilirsin. Python'da bu operatör yoktur.

# HATALI (Python'da yok)
# x++       # SyntaxError!
# ++x       # Hata vermez ama istediğini yapmaz!

# DOĞRU
x += 1     # x'i 1 artır

++x yazarsan Python hata vermez ama +(+x) olarak yorumlar — yani hiçbir şey yapmaz. Bu sinsi bir hata olabilir!

Satır Numaralama ve Hata Mesajları

Python hata verdiğinde, hatanın hangi satırda olduğunu söyler. Bu bilgi hata ayıklama (debugging) için çok değerli.

# hata_ornegi.py
isim = "Ayşe"      # Satır 1
yas = 25            # Satır 2
print(Isim)         # Satır 3 — HATA! (büyük 'I')

Hata mesajı:

Traceback (most recent call last):
  File "hata_ornegi.py", line 3, in <module>
    print(Isim)
          ^^^^
NameError: name 'Isim' is not defined. Did you mean: 'isim'?

Hata mesajını okumayı öğrenmek çok önemli:

  1. Traceback: Hatanın izini gösterir

  2. File ve line: Hangi dosya, hangi satır

  3. Hatalı kod: Sorunlu satır gösterilir

  4. Hata tipi ve açıklama: NameError — Isim tanımlı değil, isim mi demek istedin?

Python 3.10+ sürümlerde hata mesajları çok daha yardımcı hale geldi. Hatta "bunu mu demek istedin?" diye öneri bile sunuyor.

Boş Satırlar ve Kod Organizasyonu

Python'da boş satırlar (blank lines) kodun organizasyonu için kullanılır. Python bunları görmezden gelir ama insan gözü için önemlidirler.

# İyi organize edilmiş kod
import math

PI = 3.14159
YARICAP = 5

def cevre_hesapla(r):
    return 2 * PI * r

def alan_hesapla(r):
    return PI * r ** 2


# Ana program
cevre = cevre_hesapla(YARICAP)
alan = alan_hesapla(YARICAP)

print(f"Çevre: {cevre:.2f}")
print(f"Alan: {alan:.2f}")

Genel kurallar:

  • Fonksiyonlar arasında 2 boş satır

  • Fonksiyon içinde mantıksal bölümler arasında 1 boş satır

  • Import'lardan sonra 2 boş satır

  • Dosya sonunda 1 boş satır

Bu kuralları ileride PEP 8 dersinde detaylı göreceğiz.

Pratik: Söz Dizimi Kontrol Listesi

Bir Python kodu yazarken kontrol etmen gerekenler:

# ✅ Doğru girintileme (4 boşluk)
if True:
    print("OK")

# ✅ İki nokta (:) unutulmamalı
for i in range(5):
    print(i)

# ✅ Anlamlı değişken isimleri (snake_case)
kullanici_adi = "ahmet"

# ✅ Parantezler eşleşmeli
sonuc = (10 + 20) * 3

# ✅ String tırnakları eşleşmeli
mesaj = "Merhaba Dünya"

# ✅ Büyük/küçük harf duyarlılığına dikkat
Print("x")  # ❌ HATA — print olmalı

Özet

  • 📏 Girintileme Python'ın en önemli söz dizimi kuralıdır. Kod blokları 4 boşluk girintileme ile belirlenir — süslü parantez yoktur.

  • ↩️ Satır devamı için \ kullanılabilir ama parantez içinde otomatik devam tercih edilmelidir.

  • 🚫 Bir satırda birden fazla ifade (; ile) teknik olarak mümkün ama okunabilirlik için kaçınılmalıdır.

  • 🔑 Python'da 35 anahtar kelime vardır (if, for, def, class vb.) ve bunlar değişken adı olarak kullanılamaz.

  • 🏷️ Değişken isimleri harf veya alt çizgi ile başlamalı, snake_case konvansiyonuna uymalıdır. Python büyük/küçük harf duyarlıdır.

  • 🔄 Python dinamik tipli bir dildir: değişken tanımlarken tip belirtmeye gerek yoktur, Python tipi otomatik anlar. Ama bu esneklik dikkatli kullanılmalıdır.

*Bir sonraki derste PEP 8 stil kılavuzunu öğreneceksin: profesyonel Python kodu nasıl yazılır, hangi kurallar takip edilir ve kod kalitesini artıran araçlar nelerdir.* 📖