Programlama dilleri, bilgisayarlara ne yapacaklarını adım adım anlatmamızı sağlayan araçlardır. Bu anlatım sırasında veriler üzerinde çeşitli işlemler yapar, belirli koşullara göre farklı yollar izler ve bazı işlemleri tekrar tekrar gerçekleştiririz. Python’da bu temel eylemleri gerçekleştirmek için operatörler ve kontrol akışı yapıları kullanılır. Bu iki kavram, Python’da (ve çoğu programlama dilinde) programların mantıksal temelini oluşturur.

Bu metinde, Python’daki temel operatör türlerini ve programın akışını yönlendiren kontrol yapılarını (koşullu ifadeler ve döngüler) ayrıntılı bir şekilde inceleyeceğiz. Bu yapıları anlamak, basit script’lerden karmaşık uygulamalara kadar her türlü Python programını yazabilmek için zorunludur.

Bölüm 1: Python Operatörleri
Operatörler, değerler (operands — işlenenler) üzerinde belirli işlemleri gerçekleştirmek için kullanılan özel semboller veya anahtar kelimelerdir. Örneğin, 10 + 5 ifadesinde 10 ve 5 operand, + ise toplama operatörüdür.

Python, farklı amaçlar için çeşitli operatör türleri sunar:

1.1. Aritmetik Operatörler
En temel operatörlerdir ve matematiksel hesaplamalar yapmak için kullanılırlar.

Toplama (+): İki sayıyı toplar. String'leri birleştirmek (concatenation) için de kullanılır.
Çıkarma (-): Bir sayıdan diğerini çıkarır. Tek başına kullanıldığında sayının negatifini alır.
Çarpma (): İki sayıyı çarpar. String'leri veya listeleri tekrarlamak için de kullanılır.
Bölme (/): Bir sayıyı diğerine böler. Sonuç her zaman float (ondalıklı sayı) olur.
Modülüs (Kalan Bulma) (%): Bir sayının diğerine bölümünden kalanı verir.
Üs Alma (): Bir sayının diğerine göre üssünü hesaplar (örn: 2 * 3 = 8).
Tam Bölme (Floor Division) (//): Bölme işleminin sonucundaki tam sayı kısmını verir (aşağı yuvarlar). Sonucun tipi operandların tiplerine bağlıdır (iki int ise int, en az biri float ise float döner).

Aritmetik Operatör Örnekleri

a = 15
b = 4
print(f"{a} + {b} = {a + b}") # 15 + 4 = 19
print(f"{a} - {b} = {a - b}") # 15 - 4 = 11
print(f"{a} * {b} = {a * b}") # 15 * 4 = 60
print(f"{a} / {b} = {a / b}") # 15 / 4 = 3.75 (float sonuç)
print(f"{a} // {b} = {a // b}") # 15 // 4 = 3 (Tam bölme)
print(f"{a} % {b} = {a % b}") # 15 % 4 = 3 (Kalan)
print(f"2 ** 5 = {2 ** 5}") # 2 ** 5 = 32 (Üs alma)

Negatif sayılarda tam bölme ve modülüs

print(f"-15 // 4 = {-15 // 4}") # -15 // 4 = -4 (Sayı doğrusunda sola doğru yuvarlar)
print(f"-15 % 4 = {-15 % 4}") # -15 % 4 = 1 (Kalanın işareti bölenin işaretiyle aynı olur)

String ve Liste ile kullanımı

print("Merhaba" + " " + "Dünya") # Merhaba Dünya (String birleştirme)
print("-" * 20) # -------------------- (String tekrarlama)
print([1, 2] * 3) # 1, 2, 1, 2, 1, 2
1.2. Karşılaştırma (İlişkisel) Operatörleri
İki değeri karşılaştırmak için kullanılırlar ve sonuç olarak her zaman bir boolean (True veya False) değer döndürürler. Bu operatörler genellikle kontrol akışı yapılarında (if, while) koşulları belirlemek için kullanılır.

Eşit mi? (==): İki değer birbirine eşitse True döner.
Eşit değil mi? (!=): İki değer birbirinden farklıysa True döner.
Büyük mü? (>): Soldaki değer sağdakinden büyükse True döner.
Küçük mü? (<): Soldaki değer sağdakinden küçükse True döner.
Büyük veya eşit mi? (>=): Soldaki değer sağdakinden büyük veya ona eşitse True döner.
Küçük veya eşit mi? (<=): Soldaki değer sağdakinden küçük veya ona eşitse True döner.

Karşılaştırma Operatörleri Örnekleri

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

String karşılaştırmaları (alfabetik sıraya göre)

print(f"'elma' == 'armut' : {'elma' == 'armut'}") # 'elma' == 'armut' : False
print(f"'elma' < 'armut' : {'elma' < 'armut'}") # 'elma' < 'armut' : False (e, a'dan sonra gelir)
print(f"'A' < 'a' : {'A' < 'a'}") # 'A' < 'a' : True (Büyük harfler küçük harflerden önce gelir ASCII/Unicode'da)
Not: == operatörü değerlerin eşitliğini kontrol ederken, bir sonraki bölümde göreceğimiz is operatörü nesnelerin kimliklerinin (bellekteki yerlerinin) aynı olup olmadığını kontrol eder. Bu ikisi sıklıkla karıştırılır.

1.3. Mantıksal Operatörler
Boolean ifadeleri (veya doğruluk değeri olan ifadeleri) birleştirmek veya tersine çevirmek için kullanılırlar. Genellikle birden fazla koşulu birleştirmek için if ifadelerinde kullanılırlar.

and (VE): Her iki tarafındaki ifade de True ise True döner, aksi halde False döner.
or (VEYA): Taraflardan en az biri True ise True döner, her ikisi de False ise False döner.
not (DEĞİL): İfadenin boolean değerini tersine çevirir (True ise False, False ise True yapar).
Kısa Devre (Short-circuiting) Davranışı:

and operatörü: Sol taraf False ise sağ tarafı hiç değerlendirmez (çünkü sonuç zaten False olacaktır).
or operatörü: Sol taraf True ise sağ tarafı hiç değerlendirmez (çünkü sonuç zaten True olacaktır).
Bu davranış, özellikle sağ taraftaki ifadenin potansiyel olarak hataya neden olabileceği veya hesaplaması maliyetli olduğu durumlarda önemlidir.

Mantıksal Operatörler Örnekleri

yas = 25
ehliyet_var = True
saglikli = True
yorgun = False

Örnek 1: Araba kullanabilir mi? (Yaş 18+ VE ehliyeti olmalı)

kullanabilir = (yas >= 18) and ehliyet_var
print(f"Araba kullanabilir mi? {kullanabilir}") # True

Örnek 2: Spor yapabilir mi? (Sağlıklı OLMALI VE yorgun OLMAMALI)

spor_yapabilir = saglikli and (not yorgun)
print(f"Spor yapabilir mi? {spor_yapabilir}") # True

Örnek 3: Dinlenmeli mi? (Yaş 65+ VEYA yorgun OLMALI)

dinlenmeli = (yas >= 65) or yorgun
print(f"Dinlenmeli mi? {dinlenmeli}") # False

Kısa Devre Örneği

sayi = 0

print(10 / sayi > 5) # Bu satır ZeroDivisionError verir

Kısa devre sayesinde hata almayız:

sayi != 0 False olduğu için 'and' operatörü sağ tarafı (bölmeyi) hiç değerlendirmez.

result = (sayi != 0) and (10 / sayi > 5)
print(f"Kısa devre sonucu (and): {result}") # False

sayi == 0 True olduğu için 'or' operatörü sağ tarafı (bölmeyi) hiç değerlendirmez.

result2 = (sayi == 0) or (10 / sayi > 5)
print(f"Kısa devre sonucu (or): {result2}") # True
1.4. Atama Operatörleri
Bir değişkene değer atamak için kullanılırlar. En temel atama operatörü = işaretidir. Diğerleri, bir aritmetik veya bitwise işlemi yapıp sonucu aynı değişkene atayan kısaltmalardır.

= : Sağdaki değeri soldaki değişkene atar.
+= : Soldaki değişkenin değerine sağdaki değeri ekler ve sonucu soldaki değişkene atar (x += y demek x = x + y demektir).
-= : Soldaki değişkenin değerinden sağdaki değeri çıkarır ve sonucu soldaki değişkene atar (x -= y demek x = x - y demektir).
= : Soldaki değişkenin değerini sağdaki değerle çarpar ve sonucu soldaki değişkene atar (x *= y demek x = x * y demektir).
/= : Soldaki değişkenin değerini sağdaki değere böler ve sonucu (float) soldaki değişkene atar (x /= y demek x = x / y demektir).
%= : Soldaki değişkenin değerinin sağdaki değere bölümünden kalanı bulur ve sonucu soldaki değişkene atar (x %= y demek x = x % y demektir).
*= : Soldaki değişkenin değerinin sağdaki değere göre üssünü alır ve sonucu soldaki değişkene atar (x *= y demek x = x * y demektir).
//= : Soldaki değişkenin değerini sağdaki değere tam böler ve sonucu soldaki değişkene atar (x //= y demek x = x // y demektir).

Atama Operatörleri Örnekleri

sayac = 10
print(f"Başlangıç: {sayac}") # Başlangıç: 10
sayac += 5 # sayac = sayac + 5
print(f"+= 5 sonrası: {sayac}") # += 5 sonrası: 15
sayac -= 3 # sayac = sayac - 3
print(f"-= 3 sonrası: {sayac}") # -= 3 sonrası: 12
sayac = 2 # sayac = sayac * 2
print(f"= 2 sonrası: {sayac}") # = 2 sonrası: 24
sayac //= 5 # sayac = sayac // 5
print(f"//= 5 sonrası: {sayac}") # //= 5 sonrası: 4
sayac *= 3 # sayac = sayac ** 3
print(f"*= 3 sonrası: {sayac}") # *= 3 sonrası: 64
1.5. Bitwise Operatörler (Bit Düzeyinde İşlem Yapan Operatörler)
Bu operatörler sayılar üzerinde doğrudan bit (0 ve 1) düzeyinde işlem yaparlar. Genellikle düşük seviyeli programlama, veri sıkıştırma, şifreleme veya donanım kontrolü gibi özel alanlarda kullanılırlar. Temel seviyede bilinmesi zorunlu olmasa da varlıklarından haberdar olmak faydalıdır.

& (Bitwise AND): İki sayının bitlerini karşılaştırır, her iki bitte de 1 varsa sonuç bitine 1 yazar, aksi halde 0 yazar.
| (Bitwise OR): İki sayının bitlerini karşılaştırır, bitlerden en az birinde 1 varsa sonuç bitine 1 yazar, aksi halde 0 yazar.
^ (Bitwise XOR - Exclusive OR): İki sayının bitlerini karşılaştırır, bitler birbirinden farklıysa (biri 1, diğeri 0) sonuç bitine 1 yazar, aynıysa 0 yazar.
~ (Bitwise NOT - Complement): Sayının bitlerini tersine çevirir (0'ları 1, 1'leri 0 yapar). Genellikle sayının negatifinden bir eksiğini verir (~x = -x - 1).
<< (Bitwise Left Shift - Sola Kaydırma): Sayının bitlerini belirtilen miktarda sola kaydırır. Boşalan sağdaki bitlere 0 eklenir. Sayıyı 2'nin kuvvetleriyle çarpmaya eşdeğerdir (x << n ≈ x * (2**n)).

(Bitwise Right Shift - Sağa Kaydırma): Sayının bitlerini belirtilen miktarda sağa kaydırır. Soldan taşan bitler atılır. Pozitif sayılarda boşalan soldaki bitlere 0 eklenir. Sayıyı 2'nin kuvvetlerine bölmeye eşdeğerdir (x >> n ≈ x // (2**n)).

Bitwise Operatör Örnekleri

m = 10 # İkilik tabanda: 1010
n = 4 # İkilik tabanda: 0100
print(f"{m} & {n} = {m & n}") # 1010 & 0100 = 0000 (Decimal: 0)
print(f"{m} | {n} = {m | n}") # 1010 | 0100 = 1110 (Decimal: 14)
print(f"{m} ^ {n} = {m ^ n}") # 1010 ^ 0100 = 1110 (Decimal: 14)
print(f"~{m} = {~m}") # ~1010 = -(1010 + 1) = -11
print(f"{m} << 2 = {m << 2}") # 1010 << 2 = 101000 (Decimal: 40) (10 * 2*2)
print(f"{m} >> 1 = {m >> 1}") # 1010 >> 1 = 0101 (Decimal: 5) (10 // 2*1)
1.6. Üyelik Operatörleri
Bir değerin bir dizi (sequence — list, tuple, string) veya koleksiyon (set, dict) içinde bulunup bulunmadığını kontrol etmek için kullanılırlar.

in: Soldaki değer, sağdaki dizi/koleksiyon içinde bulunuyorsa True döner.
not in: Soldaki değer, sağdaki dizi/koleksiyon içinde bulunmuyorsa True döner.
Sözlüklerde (dict) kullanıldığında, varsayılan olarak anahtarlar (keys) arasında arama yaparlar.

Üyelik Operatörleri Örnekleri

liste = [1, 2, 3, "elma", "armut"]
metin = "Merhaba dünya"
sozluk = {"ad": "Ali", "yas": 30}

Liste üzerinde

print(f"3 in liste? {3 in liste}") # True
print(f"'muz' in liste? {'muz' in liste}") # False
print(f"'elma' not in liste? {'elma' not in liste}") # False

String üzerinde

print(f"'a' in metin? {'a' in metin}") # True
print(f"'xyz' in metin? {'xyz' in metin}") # False

Sözlük üzerinde (anahtarları kontrol eder)

print(f"'ad' in sozluk? {'ad' in sozluk}") # True
print(f"'Ali' in sozluk? {'Ali' in sozluk}") # False (Değerlerde arama yapmaz)

Değerlerde aramak için .values() kullanılır:

print(f"'Ali' in sozluk.values()? {'Ali' in sozluk.values()}") # True
1.7. Kimlik Operatörleri
İki değişkenin bellekte aynı nesneyi gösterip göstermediğini kontrol ederler. == operatöründen farklıdırlar; == değerlerin eşitliğini kontrol ederken, is kimliklerin (bellek adreslerinin) aynı olup olmadığını kontrol eder.

is: İki değişken aynı nesneyi referans ediyorsa True döner.
is not: İki değişken farklı nesneleri referans ediyorsa True döner.
is operatörü özellikle None değerini kontrol etmek için sıklıkla kullanılır (if x is None: şeklinde).

Python, küçük tam sayılar (-5 ile 256 arası) ve bazı kısa string’ler için optimizasyon yaparak bellekte aynı nesneyi tekrar kullanabilir (interning), bu da bazen is operatörünün beklenmedik sonuçlar vermesine neden olabilirmiş gibi görünse de, temel mantık aynıdır.

Kimlik Operatörleri Örnekleri

a = [1, 2, 3]
b = [1, 2, 3]
c = a
print(f"a == b : {a == b}") # True (Değerler aynı)
print(f"a is b : {a is b}") # False (Farklı nesneler, farklı bellek adresleri)
print(f"a == c : {a == c}") # True (Değerler aynı)
print(f"a is c : {a is c}") # True (Aynı nesneyi referans ediyorlar)

None kontrolü

degisken = None
if degisken is None:
print("Değişken None.")
else:
print("Değişken None değil.")

Küçük tamsayı optimizasyonu (interning)

x = 256
y = 256
print(f"x is y (256): {x is y}") # True (Genellikle -5 ile 256 arası için geçerli)
z = 257
w = 257
print(f"z is w (257): {z is w}") # False (Genellikle bu aralık dışı için farklı nesneler)
1.8. Operatör Önceliği
Bir ifadede birden fazla operatör bulunduğunda, hangi işlemin önce yapılacağını belirleyen kurallardır. Matematikteki işlem sırası (PEMDAS/BODMAS) gibi düşünülebilir.

Python’daki genel öncelik sırası (yüksekten düşüğe):

() : Parantezler (en yüksek öncelik, sırayı değiştirmek için kullanılır)
** : Üs alma
~, +x, -x : Bitwise NOT, pozitif/negatif işaretleri (tekli operatörler)
*, /, //, % : Çarpma, bölme, tam bölme, modülüs
+, - : Toplama, çıkarma
<<, >> : Bitwise kaydırma
& : Bitwise AND
^ : Bitwise XOR
| : Bitwise OR
in, not in, is, is not, <, <=, >, >=, !=, == : Karşılaştırma, üyelik, kimlik operatörleri
not : Mantıksal NOT
and : Mantıksal AND
or : Mantıksal OR (en düşük öncelik)
Öncelik sırasını ezberlemek yerine, karmaşık ifadelerde şüpheye düştüğünüzde veya okunabilirliği artırmak istediğinizde parantez () kullanmak en iyi yaklaşımdır.

Operatör Önceliği Örnekleri

sonuc1 = 10 + 5 * 2 # Önce çarpma (5*2=10), sonra toplama (10+10=20)
print(f"10 + 5 * 2 = {sonuc1}")
sonuc2 = (10 + 5) * 2 # Önce parantez içi toplama (10+5=15), sonra çarpma (15*2=30)
print(f"(10 + 5) * 2 = {sonuc2}")
sonuc3 = 10 > 5 and 3 < 1 # Önce karşılaştırmalar, sonra 'and'

(True and False) -> False

print(f"10 > 5 and 3 < 1 = {sonuc3}")
sonuc4 = not 10 > 5 or 3 < 1 # Önce karşılaştırmalar, sonra 'not', sonra 'or'

(not True) or False -> False or False -> False

print(f"not 10 > 5 or 3 < 1 = {sonuc4}")
sonuc5 = 2 ** 3 * 4 # Önce üs alma (2*3=8), sonra çarpma (8*4=32)
print(f"2 * 3 * 4 = {sonuc5}")
Bölüm 2: Kontrol Akışı
Normalde Python kodu yukarıdan aşağıya doğru, satır satır çalıştırılır. Ancak programlarımızın daha dinamik ve akıllı davranabilmesi için bu doğrusal akışı değiştirmemiz gerekir. Kontrol akışı (control flow) ifadeleri, programın belirli koşullara göre farklı kod bloklarını çalıştırmasını veya belirli kod bloklarını tekrar tekrar çalıştırmasını sağlar.

Python’da üç ana kontrol akışı yapısı bulunur:

Koşullu İfadeler: if, elif, else
Döngüler: while, for
Döngü Kontrol İfadeleri: break, continue, pass
Girintileme (Indentation) Çok Önemli! Python’da kod bloklarının sınırları süslü parantezler {} veya anahtar kelimeler yerine girintileme (satır başındaki boşluklar) ile belirlenir. Kontrol akışı ifadelerinden (if, elif, else, while, for gibi : ile bitenler) sonra gelen ve o bloğa ait olan kod satırları mutlaka daha içeriden başlamalıdır. Tutarlı bir şekilde (genellikle 4 boşluk) girintileme yapmak zorunludur, aksi takdirde IndentationError hatası alırsınız.

2.1. Koşullu İfadeler (if, elif, else)
Programın belirli koşullara göre farklı kod yollarını izlemesini sağlar. Bir koşulun doğruluğuna (True) veya yanlışlığına (False) göre hangi kod bloğunun çalışacağına karar verir.

if İfadesi
En basit koşullu ifadedir. Belirtilen koşul True ise, girintili blok içindeki kod çalıştırılır. Koşul False ise, blok atlanır ve program if bloğundan sonraki koddan devam eder.

Sözdizimi:

if koşul:
# Koşul True ise çalışacak kod bloğu (girintili)
# Bu blokta birden fazla satır olabilir

if bloğu bitti, program buradan devam eder

if Örneği

sicaklik = 28
if sicaklik > 25:
print("Hava sıcak!")
print("Klimayı açabilirsiniz.")
print("Program devam ediyor...")
if-else İfadesi
Bir koşul doğru olduğunda bir kod bloğunu, yanlış olduğunda ise başka bir kod bloğunu çalıştırmak için kullanılır.

Sözdizimi:

if koşul:
# Koşul True ise çalışacak kod bloğu
# ...
else:
# Koşul False ise çalışacak kod bloğu
# ...

if-else bloğu bitti

if-else Örneği

puan = 45
if puan >= 50:
print("Tebrikler, geçtiniz!")
else:
print("Üzgünüm, kaldınız.")
print("Daha çok çalışmalısınız.")
if-elif-else Zinciri
Birden fazla koşulu sırayla kontrol etmek için kullanılır. Python, if koşulunu kontrol eder. Eğer True ise ilgili bloğu çalıştırır ve zincirden çıkar. Eğer False ise, sıradaki elif (else if) koşulunu kontrol eder. Bu şekilde devam eder. Hiçbir if veya elif koşulu True olmazsa, varsa else bloğu çalıştırılır. Bir zincirde sadece bir blok (ilk True olan veya else) çalıştırılır.

Sözdizimi:

if koşul_1:
# Koşul 1 True ise çalışacak kod
elif koşul_2:
# Koşul 1 False VE Koşul 2 True ise çalışacak kod
elif koşul_3:
# Önceki koşullar False VE Koşul 3 True ise çalışacak kod

... (istediğiniz kadar elif eklenebilir)

else:
# Yukarıdaki hiçbir koşul True değilse çalışacak kod (opsiyonel)

if-elif-else zinciri bitti

if-elif-else Örneği

not_ortalamasi = 72
if not_ortalamasi >= 85:
harf_notu = "A"
print("Çok iyi!")
elif not_ortalamasi >= 70:
harf_notu = "B"
print("İyi.")
elif not_ortalamasi >= 55:
harf_notu = "C"
print("Orta.")
elif not_ortalamasi >= 45:
harf_notu = "D"
print("Geçer.")
else:
harf_notu = "F"
print("Kaldı.")
print(f"Harf Notunuz: {harf_notu}")
İç İçe if İfadeleri (Nested If)
Bir if, elif veya else bloğunun içine başka bir if yapısı yerleştirilebilir. Bu, daha karmaşık koşul ağaçları oluşturmayı sağlar.

İç içe if Örneği

x = 10
y = 20
if x > 5:
print("x 5'ten büyük.")
if y > 15:
print("y de 15'ten büyük.")
else:
print("Ama y 15'ten büyük veya eşit değil.")
else:
print("x 5'ten büyük değil.")
Tek Satırda Koşullu İfade (Ternary Operator)
Basit if-else yapılarını tek bir satırda yazmak için kullanılır. Özellikle değişken atamalarında kullanışlıdır.

Sözdizimi: deger_eger_dogru if kosul else deger_eger_yanlis

Ternary Operatör Örneği

yas = 15
durum = "Yetişkin" if yas >= 18 else "Çocuk"
print(f"Durum: {durum}") # Durum: Çocuk
sayi = -5
tip = "Pozitif" if sayi > 0 else ("Negatif" if sayi < 0 else "Sıfır")
print(f"Sayı tipi: {tip}") # Sayı tipi: Negatif
2.2. Döngüler (Loops)
Bir kod bloğunu belirli bir koşul sağlandığı sürece veya bir dizi/koleksiyonun her bir elemanı için tekrar tekrar çalıştırmayı sağlarlar.

while Döngüsü
Belirtilen koşul True olduğu sürece girintili kod bloğunu tekrar tekrar çalıştırır. Koşul her döngü başlangıcında kontrol edilir. Eğer koşul başlangıçta False ise, döngü hiç çalışmaz.

Sözdizimi:

while koşul:
# Koşul True olduğu sürece çalışacak kod bloğu
# ...
# ÖNEMLİ: Döngünün bir noktada sona ermesi için
# genellikle koşulu etkileyen bir değişkenin
# döngü içinde güncellenmesi gerekir.

while döngüsü bitti (koşul False olduğunda)

Dikkat: while döngüsünün koşulu her zaman True kalırsa, sonsuz döngü (infinite loop) oluşur ve program takılır. Döngü içindeki bir mekanizmanın (örneğin bir sayaç artışı veya bir break ifadesi) koşulu eninde sonunda False yapacağından emin olunmalıdır.

while Döngüsü Örneği - 1'den 5'e kadar sayma

sayac = 1
while sayac <= 5:
print(f"Sayaç: {sayac}")
sayac += 1 # Koşulu etkileyen değişkeni güncelle!
print("While döngüsü bitti.")

while Döngüsü Örneği - Kullanıcı 'quit' yazana kadar girdi alma

kullanici_girdisi = ""
while kullanici_girdisi.lower() != "quit":
kullanici_girdisi = input("Bir şeyler yazın ('quit' ile çıkış): ")
if kullanici_girdisi.lower() != "quit":
print(f"Yazdınız: {kullanici_girdisi}")
print("Programdan çıkıldı.")
for Döngüsü
Bir yinelenebilir (iterable) nesne (liste, tuple, string, range, set, dict gibi) üzerindeki her bir eleman için kod bloğunu bir kez çalıştırır. Eleman kalmadığında döngü sona erer. while döngüsüne göre genellikle daha basit ve daha az hataya açıktır çünkü sayaç yönetimi gibi detaylarla uğraşmak gerekmez.

Sözdizimi:

for eleman_degiskeni in yinelenebilir_nesne:
# Her bir eleman için çalışacak kod bloğu
# eleman_degiskeni o anki elemanın değerini alır
# ...

for döngüsü bitti (yinelenme tamamlandığında)

range() Fonksiyonu: Belirli bir aralıkta sayı dizisi oluşturmak için for döngülerinde sıklıkla kullanılır.

range(stop): 0'dan başlar, stop değerine kadar (ama stop dahil değil) birer birer artan sayılar üretir.
range(start, stop): start değerinden başlar, stop değerine kadar (ama stop dahil değil) birer birer artan sayılar üretir.
range(start, stop, step): start değerinden başlar, stop değerine kadar step adımıyla artan/azalan sayılar üretir.

for Döngüsü Örnekleri

Liste üzerinde gezinme

meyveler = ["elma", "armut", "kiraz"]
print("Meyveler:")
for meyve in meyveler:
print(f"- {meyve.capitalize()}")

String üzerinde gezinme (karakter karakter)

print("\nMetin Karakterleri:")
for harf in "Python":
print(harf, end=" ") # end=" " ile aynı satıra yazdırır
print() # Yeni satıra geç

range() ile belirli sayıda tekrarlama

print("\nRange ile 0-4 arası sayılar:")
for i in range(5): # 0, 1, 2, 3, 4
print(i)
print("\nRange ile 2-6 arası sayılar:")
for i in range(2, 7): # 2, 3, 4, 5, 6
print(i)
print("\nRange ile 10'dan 0'a 2'şer azalan sayılar:")
for i in range(10, -1, -2): # 10, 8, 6, 4, 2, 0
print(i)

Sözlük üzerinde gezinme

urun_stok = {"kalem": 50, "defter": 25, "silgi": 100}
print("\nÜrünler (Anahtarlar):")
for urun in urun_stok.keys(): # veya sadece 'for urun in urun_stok:' yazılabilir
print(urun)
print("\nStok Miktarları (Değerler):")
for miktar in urun_stok.values():
print(miktar)
print("\nÜrün ve Stok (Anahtar-Değer Çiftleri):")
for urun, miktar in urun_stok.items(): # En yaygın kullanım
print(f"{urun}: {miktar} adet")
else Bloğu ile Döngüler
Hem while hem de for döngülerine isteğe bağlı bir else bloğu eklenebilir. Bu else bloğu, döngü normal bir şekilde tamamlandığında (yani bir break ifadesi ile kesilmeden bittiğinde) çalıştırılır.

Bu özellik, özellikle bir döngüde aranan bir öğenin bulunup bulunmadığını kontrol etmek için kullanışlıdır.

Döngülerde else Kullanımı

Örnek 1: Listede belirli bir sayıyı arama (for ile)

sayilar = [11, 13, 17, 19, 23]
aranan_sayi = 15
for sayi in sayilar:
if sayi == aranan_sayi:
print(f"{aranan_sayi} bulundu!")
break # Sayı bulununca döngüyü kır
else:
# Bu blok sadece döngü 'break' ile kesilmezse çalışır
print(f"{aranan_sayi} listede bulunamadı.")

Örnek 2: Belirli bir koşul sağlanana kadar deneme (while ile)

deneme_sayisi = 0
max_deneme = 3
sifre_dogru_mu = False
while deneme_sayisi < max_deneme:
girilen_sifre = input("Şifreyi girin: ")
if girilen_sifre == "12345":
sifre_dogru_mu = True
print("Giriş başarılı!")
break # Doğru şifre girilince döngüyü kır
else:
deneme_sayisi += 1
print(f"Hatalı şifre. Kalan deneme: {max_deneme - deneme_sayisi}")
else:
# Bu blok sadece döngü 'break' ile kesilmezse (yani max denemeye ulaşılırsa) çalışır
print("Deneme hakkınız bitti!")

Sonucu kontrol edebiliriz

if sifre_dogru_mu:
print("Hoş geldiniz!")
else:
print("Giriş başarısız oldu.")
İç İçe Döngüler (Nested Loops)
Bir döngünün içine başka bir döngü yerleştirilebilir. İçteki döngü, dıştaki döngünün her bir adımı için tamamen baştan sona çalışır. Genellikle matrisler, tablolar veya koordinat sistemleri gibi 2 boyutlu yapılar üzerinde işlem yapmak için kullanılır.

İç İçe Döngü Örneği - Çarpım Tablosu

print("Çarpım Tablosu:")
for i in range(1, 6): # Dıştaki döngü (1'den 5'e kadar)
for j in range(1, 6): # İçteki döngü (1'den 5'e kadar)
print(f"{i} * {j} = {i*j:<3}", end=" | ") # :<3 ile sola yaslı 3 karakterlik alan
print() # Dıştaki döngünün her adımından sonra yeni satıra geç

İç İçe Döngü Örneği - Liste içindeki listeler

matris = [
[1, 2, 3],
[4, 5, 6],
[7, 8, 9]
]
print("\nMatris Elemanları:")
for satir in matris:
for eleman in satir:
print(eleman, end=" ")
print() # Her satırdan sonra yeni satıra geç
2.3. Döngü Kontrol İfadeleri (break, continue, pass)
Döngülerin normal akışını değiştirmek için kullanılırlar.

break
Karşılaşıldığı anda, içinde bulunduğu en içteki for veya while döngüsünü derhal sonlandırır. Program akışı döngüden sonraki ilk satırdan devam eder.

Genellikle belirli bir koşul sağlandığında (örneğin aranan öğe bulunduğunda veya bir hata durumu oluştuğunda) döngüden erken çıkmak için kullanılır.

break Örneği - İlk çift sayıyı bulup durma

sayilar = [1, 3, 5, 8, 9, 10, 12]
ilk_cift_sayi = None
for sayi in sayilar:
print(f"Kontrol edilen: {sayi}")
if sayi % 2 == 0:
ilk_cift_sayi = sayi
print("İlk çift sayı bulundu!")
break # Döngüyü sonlandır
# break çalışmazsa döngü devam eder
if ilk_cift_sayi is not None:
print(f"Bulunan ilk çift sayı: {ilk_cift_sayi}")
else:
print("Listede çift sayı bulunamadı.")
continue
Karşılaşıldığı anda, döngünün mevcut adımının (iteration) geri kalanını atlar ve döngünün bir sonraki adımıyla devam eder. while döngüsünde koşul tekrar kontrol edilir, for döngüsünde bir sonraki elemana geçilir.

Genellikle belirli koşulları sağlayan elemanları işlemek istemediğimizde veya mevcut adım için yapılacak başka bir işlem kalmadığında kullanılır.

continue Örneği - Negatif sayıları atlayıp pozitifleri toplama

toplam = 0
sayilar = [10, -5, 20, 0, -15, 8]
for sayi in sayilar:
if sayi <= 0:
print(f"{sayi} atlanıyor...")
continue # Mevcut adımı atla, bir sonrakine geç
# Bu kısım sadece sayi > 0 ise çalışır
print(f"{sayi} toplama ekleniyor.")
toplam += sayi
print(f"\nPozitif sayıların toplamı: {toplam}") # 10 + 20 + 8 = 38
pass
pass ifadesi aslında bir null (boş) işlemdir; yani hiçbir şey yapmaz. Python'da sözdizimsel olarak bir blok (if, for, while, def, class gövdesi gibi) gerektiği ancak mantıksal olarak o blokta hiçbir işlem yapılmasına gerek olmadığı durumlarda yer tutucu olarak kullanılır. Yorumlayıcının hata vermesini engeller.

Geliştirme aşamasında, daha sonra doldurulacak fonksiyon veya sınıf tanımları için sıklıkla kullanılır.

pass Örneği

Henüz içeriğini yazmadığımız bir fonksiyon

def benim_fonksiyonum():
pass # Sözdizimi hatası almamak için pass kullanıyoruz

Henüz içeriğini yazmadığımız bir sınıf

class BenimSinifim:
pass

Belirli bir koşulda hiçbir şey yapmak istemiyoruz

x = 5
if x > 10:
print("X 10'dan büyük")
elif x == 5:
pass # x 5'e eşitse özel bir şey yapma, devam et
else:
print("X 5'ten küçük")
benim_fonksiyonum() # Hata vermez
nesne = BenimSinifim() # Hata vermez
print("Program bitti.")
Sonuç
Python’da operatörler ve kontrol akışı yapıları, programlarımıza mantık katmamızı, hesaplamalar yapmamızı, kararlar almamızı ve tekrarlayan görevleri otomatikleştirmemizi sağlayan temel araçlardır. Aritmetik, karşılaştırma, mantıksal, atama, üyelik ve kimlik operatörleri veriler üzerinde çeşitli işlemler yapmamıza olanak tanırken; if/elif/else yapıları koşullu mantık kurmamızı, while ve for döngüleri ise kod bloklarını tekrar etmemizi sağlar. break, continue ve pass gibi ifadeler ise döngülerin ve blokların akışını daha hassas bir şekilde kontrol etmemize yardımcı olur.

Bu temel yapıları ve Python’un girintilemeye dayalı sözdizimini sağlam bir şekilde anlamak, etkili ve okunabilir Python kodu yazmanın ilk ve en önemli adımıdır. Bu kavramları pratik örneklerle pekiştirmek, Python programlama becerilerinizi geliştirmenin anahtarıdır.

Abdulkadir Güngör - Kişisel WebSite
Abdulkadir Güngör - Kişisel WebSite
Abdulkadir Güngör - Özgeçmiş
Github
Github
Linkedin