Giriş

Python, Guido van Rossum tarafından 1990'ların başında geliştirilmeye başlanan, günümüzde dünyanın en popüler programlama dillerinden biri haline gelmiş yüksek seviyeli, yorumlamalı (interpreted), nesne yönelimli ve dinamik tipli bir dildir. Okunabilirliği ve basit sözdizimi sayesinde öğrenmesi nispeten kolaydır, bu da onu programlamaya yeni başlayanlar için mükemmel bir başlangıç noktası yapar. Web geliştirmeden veri bilimine, yapay zekadan otomasyona kadar çok geniş bir yelpazede kullanılmaktadır.

Bir programlama dilini öğrenirken atılacak ilk adım, o dilin kurallarını, yani sözdizimini (syntax) anlamaktır. Sözdizimi, kodun nasıl yazılması gerektiğini belirleyen gramer kurallarıdır. Python’un sözdizimi, okunabilirliği ön planda tutacak şekilde tasarlanmıştır; kodun neredeyse düz İngilizce gibi okunabilmesi hedeflenmiştir.

Python’u diğer birçok popüler dilden (C++, Java, C#, JavaScript gibi) ayıran en temel özelliklerden biri ise kod bloklarını tanımlamak için süslü parantezler {} veya anahtar kelimeler (begin/end) yerine girintileme (indentation) kullanmasıdır. Girintileme, satır başındaki boşluklardır ve Python’da sadece kodun daha düzenli görünmesini sağlamakla kalmaz, aynı zamanda kodun yapısını ve mantıksal akışını belirleyen zorunlu bir sözdizimi kuralıdır.

Bu metinde, Python’un temel sözdizimi öğelerini ayrıntılı bir şekilde inceleyecek ve özellikle girintilemenin Python’daki kritik rolünü, nasıl çalıştığını, neden önemli olduğunu ve yaygın yapılan hataları ele alacağız. Python’a yeni başlayanlar veya bilgilerini tazelemek isteyenler için bu temel kavramları sağlam bir şekilde anlamak, daha karmaşık konulara geçiş yapmadan önce hayati önem taşımaktadır.

Bölüm 1: Python Temel Sözdizimi Öğeleri

Python kodunu oluşturan temel yapı taşlarını anlamak, dilin nasıl çalıştığını kavramanın ilk adımıdır.

1.1. Anahtar Kelimeler (Keywords)

Python’un, dilin yapısı için özel anlamları olan ve değişken, fonksiyon veya başka bir tanımlayıcı adı olarak kullanılamayan ayrılmış kelimeleri vardır. Bunlara anahtar kelimeler denir. Python 3.9 itibarıyla 35 anahtar kelime bulunmaktadır (bu sayı versiyonlara göre küçük değişiklikler gösterebilir). Bazı önemli anahtar kelimeler şunlardır:

Kontrol Akışı: if, elif, else, for, while, break, continue, pass
Fonksiyonlar ve Sınıflar: def, class, return, yield, lambda
Modüller: import, from, as
İstisna Yönetimi: try, except, finally, raise, assert
Değişken Kapsamı: global, nonlocal
Mantıksal Operatörler: and, or, not
Değerler: True, False, None
Diğer: in, is, del, with, async, await
Bu kelimelerin her birinin Python yorumlayıcısı için özel bir anlamı vardır ve kodun mantıksal yapısını oluşturmada kullanılırlar. Örneğin, if bir koşul başlatır, def bir fonksiyon tanımlar, import bir modülü koda dahil eder.

1.2. Tanımlayıcılar (Identifiers)

Tanımlayıcılar; değişkenlere, fonksiyonlara, sınıflara, modüllere veya diğer nesnelere verdiğimiz isimlerdir. Python’da tanımlayıcılar için belirli kurallar vardır:

Bir harf (a-z, A-Z) veya alt çizgi (_) ile başlamalıdır.
Geri kalan karakterler harf, rakam (0–9) veya alt çizgi olabilir.
Python anahtar kelimeleri tanımlayıcı olarak kullanılamaz.
Python büyük/küçük harf duyarlıdır (myVariable ile myvariable farklı tanımlayıcılardır).
Özel semboller (!, @, #, $, % vb.) tanımlayıcı içinde kullanılamaz.
İsimlendirme Konvansiyonları (PEP 8): Python topluluğu, kodun okunabilirliğini artırmak için PEP 8 stil rehberini takip etmeyi önerir. Buna göre:

Değişken ve fonksiyon isimleri küçük harflerle yazılır ve kelimeler alt çizgi ile ayrılır (snake_case): user_name, calculate_tax
Sınıf isimleri her kelimenin baş harfi büyük olacak şekilde yazılır (CamelCase veya PascalCase): UserProfile, DatabaseConnection
Sabitler (değeri değişmemesi beklenen değişkenler) tamamen büyük harflerle yazılır: PI, MAX_CONNECTIONS
1.3. Yorum Satırları (Comments)

Yorum satırları, kodun ne yaptığını açıklamak, notlar almak veya kodun belirli kısımlarını geçici olarak devre dışı bırakmak için kullanılır. Python yorumlayıcısı yorum satırlarını görmezden gelir.

Tek Satırlık Yorumlar: # sembolü ile başlar ve satırın geri kalanını yorum olarak kabul eder.

Bu bir tek satırlık yorumdur x = 10 # Değişkene başlangıç değeri atandı

Çok Satırlık Yorumlar (Docstrings): Python’da resmi olarak çok satırlık yorum bloğu yoktur, ancak üçlü tırnak (“”” veya ‘’’) içine alınan metinler genellikle bu amaçla kullanılır. Bunlar aslında string literalleridir, ancak bir fonksiyonun, sınıfın veya modülün hemen başında kullanıldıklarında docstring (belgelendirme metni) olarak adlandırılırlar ve özel bir doc özniteliği oluştururlar.
""" Bu metin birden fazla satıra yayılabilir ve genellikle fonksiyon veya sınıfları belgelemek için kullanılır. """ def my_function(): '''Bu da tek tırnakla yapılmış bir docstring örneğidir.''' pass # pass anahtar kelimesi hiçbir şey yapma anlamına gelir
1.4. Değişkenler ve Veri Tipleri (Variables and Data Types)

Python’da bir değişkene değer atamak için eşittir = operatörü kullanılır. Python dinamik tipli bir dildir, yani bir değişkenin tipini önceden bildirmeniz gerekmez; değişkenin tipi, ona atanan değere göre otomatik olarak belirlenir ve program çalışırken değişebilir.

message = "Merhaba Dünya!" # message değişkeni şimdi bir string (metin) tipindedir
count = 100 # count değişkeni şimdi bir integer (tam sayı) tipindedir
price = 99.95 # price değişkeni şimdi bir float (ondalıklı sayı) tipindedir
is_active = True # is_active değişkeni şimdi bir boolean (mantıksal) tipindedir
print(type(message)) #
print(type(count)) #
print(type(price)) #
print(type(is_active)) #
count = "Yüz" # count değişkeninin tipi şimdi string oldu
print(type(count)) #
Temel veri tipleri şunlardır:

int: Tam sayılar (ör: 10, -5, 0)
float: Ondalıklı sayılar (ör: 3.14, -0.5, 2.0)
str: Metin dizileri (karakterler), tek (‘) veya çift (“) tırnak içine alınır.
bool: Mantıksal değerler, sadece True veya False olabilir.
NoneType: Özel bir tip, sadece None değerini alır (bir değişkenin değerinin olmadığını belirtir).
Ayrıca daha karmaşık veri yapıları için koleksiyon tipleri de vardır:

list: Sıralı, değiştirilebilir öğeler koleksiyonu. [1, “elma”, True]
tuple: Sıralı, değiştirilemez öğeler koleksiyonu. (1, “elma”, True)
dict: Anahtar-değer çiftlerinden oluşan sırasız (Python 3.7+ sıralı) koleksiyon. {“ad”: “Ali”, “yas”: 30}
set: Sırasız, benzersiz öğeler koleksiyonu. {1, 2, 3}
1.5. Operatörler (Operators)

Operatörler, değerler (operands) üzerinde işlem yapmak için kullanılan özel sembollerdir.

Aritmetik Operatörler: + (toplama), — (çıkarma), * (çarpma), / (bölme — sonuç her zaman float), % (modülüs — kalanı verir), ** (üs alma), // (tam bölme — sonucu tam sayıya yuvarlar).
Karşılaştırma Operatörleri: == (eşit mi?), != (eşit değil mi?), > (büyük mü?), < (küçük mü?), >= (büyük veya eşit mi?), <= (küçük veya eşit mi?). Sonuçları True veya False döner.
Mantıksal Operatörler: and (ve), or (veya), not (değil). Boolean değerler üzerinde işlem yapar.
Atama Operatörleri: = (atama), +=, -=, =, /=, %=, *=, //=. Bir işlem yapıp sonucu aynı değişkene atar (ör: x += 5 demek x = x + 5 demektir).
Üyelik Operatörleri: in (bir öğe koleksiyonda var mı?), not in (bir öğe koleksiyonda yok mu?).
Kimlik Operatörleri: is (iki değişken aynı nesneyi mi referans ediyor?), is not (iki değişken farklı nesneleri mi referans ediyor?). Genellikle None kontrolü için kullanılır (if my_var is None:).
1.6. İfadeler ve Deyimler (Expressions and Statements)

İfade (Expression): Bir değere dönüşen (hesaplanan) kod parçasıdır. Örneğin, 5 + 3, x * 2, name == “Ahmet”, my_function() birer ifadedir.
Deyim (Statement): Bir eylemi gerçekleştiren tam bir kod satırıdır. Bir atama (x = 5), bir if kontrolü, bir for döngüsü, bir fonksiyon tanımı (def …) birer deyimdir. Deyimler genellikle bir veya daha fazla ifade içerir.

Deyimler:

x = 10 # Atama deyimi (içinde '10' ifadesi var)
y = x + 5 # Atama deyimi (içinde 'x + 5' ifadesi var)
print("Merhaba") # Fonksiyon çağırma deyimi (içinde '"Merhaba"' ifadesi var)
if y > 15: # Koşul deyimi (içinde 'y > 15' ifadesi var)
print("Büyük") # print deyimi
1.7. Temel Girdi/Çıktı (Basic Input/Output)

print() Fonksiyonu: Değerleri veya mesajları konsola (standart çıktıya) yazdırmak için kullanılır.
print("Merhaba Python!") name = "Ayşe" age = 25 print("Ad:", name, "Yaş:", age) # Birden fazla argüman virgülle ayrılır print(f"Adı {name}, yaşı {age}.") # f-string (formatlı string) kullanımı (Python 3.6+)
input() Fonksiyonu: Kullanıcıdan konsol aracılığıyla veri almak için kullanılır. Kullanıcıdan alınan her şey string olarak döner, gerekirse tip dönüşümü yapılmalıdır.
user_name = input("Lütfen adınızı girin: ") user_age_str = input("Lütfen yaşınızı girin: ") user_age = int(user_age_str) # Girdiyi tam sayıya çevirme print(f"Hoş geldin, {user_name}! Gelecek yıl {user_age + 1} yaşında olacaksın.")
Bölüm 2: Python’da Girintileme (Indentation)

Gelelim Python’un en karakteristik özelliğine: Girintileme.

2.1. Girintileme Nedir ve Neden Önemlidir?

Çoğu programlama dilinde (C, Java, JavaScript vb.), kod blokları (örneğin bir if koşuluna bağlı çalışacak kodlar, bir döngünün gövdesi, bir fonksiyonun içeriği) süslü parantezler {} içine alınarak veya begin/end gibi anahtar kelimelerle belirtilir. Bu dillerde satır başındaki boşluklar (girintileme) genellikle sadece kodun okunabilirliğini artırmak için kullanılır ve derleyici/yorumlayıcı tarafından göz ardı edilir.

Python ise bu konuda radikal bir yaklaşım benimser: Girintileme, sözdiziminin zorunlu bir parçasıdır ve kod bloklarının sınırlarını belirler. Süslü parantezler yerine, tutarlı bir şekilde kullanılan boşluklar veya tab karakterleri (tab’lar önerilmez, aşağıda değineceğiz) kodun yapısını tanımlar.

Bu tasarım tercihinin temel nedenleri şunlardır:

Okunabilirlik: Zorunlu girintileme, tüm Python kodlarının benzer bir görsel yapıya sahip olmasını sağlar. Bu, başkalarının yazdığı kodları anlamayı veya kendi kodunuzu daha sonra gözden geçirmeyi kolaylaştırır. Kodun mantıksal yapısı, görsel yapısıyla doğrudan eşleşir.
Tutarlılık: Programcıları tutarlı bir kod stili kullanmaya teşvik eder. Farklı girintileme stillerinden kaynaklanabilecek karmaşayı ortadan kaldırır.
Basitlik: Süslü parantez veya end gibi ekstra karakterlere/kelimelere olan ihtiyacı ortadan kaldırarak sözdizimini daha sade hale getirir.
2.2. Girintileme Blokları Nasıl Tanımlar?

Python’da bir kod bloğu başlatan deyimler genellikle iki nokta üst üste (:) ile biter. Bu iki noktadan sonra gelen ve daha içeride (daha fazla girintili) olan tüm satırlar o bloğa ait kabul edilir. Blok, girinti seviyesi önceki seviyeye döndüğünde sona erer.

Girintilemenin kullanıldığı temel yapılar şunlardır:

Koşullu İfadeler (if, elif, else):
x = 10 y = 5 if x > y: print("x, y'den büyüktür.") # Bu satır 'if' bloğuna ait (girintili) print("Bu da if bloğunun parçası.") # Aynı girinti seviyesi elif x < y: print("x, y'den küçüktür.") # Bu satır 'elif' bloğuna ait else: print("x ve y eşittir.") # Bu satır 'else' bloğuna ait print("Bu satır if/elif/else yapısının dışındadır.") # Girinti seviyesi geri döndü
if, elif veya else satırından sonra gelen ve daha içeride olan print satırları, ilgili koşul sağlandığında çalışacak olan bloğu oluşturur.
Döngüler (for, while):

For döngüsü print("For döngüsü başlıyor:") my_list = [1, 2, 3] for item in my_list: print(f"Öğe: {item}") # Bu satır 'for' döngü bloğuna ait print("Döngü içindeyim.") # Bu satır da 'for' döngü bloğuna ait print("For döngüsü bitti.") # Girinti seviyesi geri döndü # While döngüsü print("\nWhile döngüsü başlıyor:") count = 0 while count < 3: print(f"Sayı: {count}") # Bu satır 'while' döngü bloğuna ait count += 1 # Bu satır da 'while' döngü bloğuna ait print("While döngüsü bitti.") # Girinti seviyesi geri döndü

for ve while satırlarından sonra gelen girintili satırlar, döngünün her iterasyonunda çalışacak olan kod bloğunu oluşturur.
Fonksiyon Tanımları (def):
def greet(name): """Bu fonksiyon verilen ismi selamlar.""" # Docstring (bloğun parçası) message = f"Merhaba, {name}!" # Bu satır 'def' bloğuna ait print(message) # Bu satır da 'def' bloğuna ait # Fonksiyon bloğu burada biter # Fonksiyonu çağırma (bloğun dışında) greet("Ahmet") greet("Zeynep") print("Fonksiyon tanımlama ve çağırma bitti.") # Girinti seviyesi geri döndü
def satırından sonra gelen girintili satırlar, fonksiyon çağrıldığında çalıştırılacak olan kodları içerir.
Sınıf Tanımları (class):
class Dog: species = "Canis familiaris" # Sınıf değişkeni (class attribute) def init(self, name, age): # Kurucu metot (initializer/constructor) self.name = name # Bu satır 'init' metodunun bloğuna ait self.age = age # Bu satır da 'init' metodunun bloğuna ait # init metot bloğu biter def bark(self): # Başka bir metot print(f"{self.name} havlıyor: Hav hav!") # Bu satır 'bark' metodunun bloğuna ait # bark metot bloğu biter # Dog sınıf bloğu burada biter # Sınıftan nesne oluşturma (bloğun dışında) my_dog = Dog("Karabaş", 3) print(f"{my_dog.name} bir köpek ve {my_dog.age} yaşında.") my_dog.bark() print("Sınıf tanımlama ve nesne oluşturma bitti.") # Girinti seviyesi geri döndü
class satırından sonra gelen girintili satırlar sınıfın gövdesini oluşturur. Sınıf içindeki metotlar (def ile tanımlananlar) kendi içlerinde ayrıca girintilenir.
İstisna Yönetimi (try, except, finally):
try: x = 10 / 0 # Hata potansiyeli olan kod print("Bölme başarılı.") # Bu satır 'try' bloğuna ait except ZeroDivisionError: print("Hata: Sıfıra bölme hatası!") # Bu satır 'except' bloğuna ait finally: print("Bu blok her zaman çalışır.") # Bu satır 'finally' bloğuna ait print("Try/except/finally yapısı bitti.") # Girinti seviyesi geri döndü
try, except ve finally anahtar kelimelerinden sonra gelen girintili bloklar, ilgili kod parçacıklarını tanımlar.
Bağlam Yöneticileri (with):
try: with open("dosya.txt", "w") as f: print("Dosya açıldı.") # Bu satır 'with' bloğuna ait f.write("Merhaba dosya!") # Bu satır da 'with' bloğuna ait # Dosya otomatik olarak burada kapanır (with bloğu bitince) print("With bloğu başarıyla tamamlandı.") # Girinti seviyesi geri döndü except Exception as e: print(f"Dosya işlemi sırasında bir hata oluştu: {e}")
with deyiminden sonra gelen girintili blok, bağlam yöneticisinin aktif olduğu (örneğin dosyanın açık olduğu) kod bölümünü belirtir.
2.3. Girintileme Kuralları ve En İyi Uygulamalar (PEP 8)

Python’da girintileme ile ilgili kesin kurallar ve topluluk tarafından kabul görmüş en iyi uygulamalar vardır:

Tutarlılık Şart: Bir kod bloğu içindeki tüm satırlar aynı miktarda girintilenmelidir. Farklı miktarlarda girintileme IndentationError hatasına yol açar.
Girinti Miktarı (PEP 8 Önerisi): Python yorumlayıcısı için önemli olan girintinin varlığı ve tutarlılığıdır, miktarı değil. Ancak, Python topluluğunun stil rehberi olan PEP 8, her girinti seviyesi için 4 boşluk (space) kullanılmasını şiddetle tavsiye eder. Bu, en yaygın kabul gören standarttır ve kodun okunabilirliğini en üst düzeye çıkarır.
Boşluk mu, Sekme mi? (Spaces vs. Tabs): Python hem boşlukları hem de sekme (tab) karakterlerini girintileme için kabul eder. Ancak, aynı kod dosyasında boşlukları ve sekmeleri karıştırmak TabError: inconsistent use of tabs and spaces in indentation hatasına neden olur. PEP 8, kesinlikle boşluk kullanılmasını önerir. Çoğu modern kod düzenleyici (IDE ve text editor), Tab tuşuna basıldığında otomatik olarak 4 boşluk ekleyecek şekilde yapılandırılabilir. Neden boşluklar tercih edilir? Çünkü sekme karakterinin görsel genişliği farklı düzenleyicilerde ve işletim sistemlerinde değişebilir, bu da kodun görünümünü bozabilir. 4 boşluk ise her zaman 4 boşluktur.
İç İçe Bloklar: Bir blok içinde başka bir blok başlatıldığında (örneğin, bir if içinde bir for döngüsü), içteki blok bir önceki seviyeye göre ekstra girintilenmelidir (genellikle +4 boşluk daha).
def process_data(data_list): print("Veri işleme başlıyor...") for item in data_list: # İlk seviye girinti (4 boşluk) print(f"İşlenen öğe: {item}") if isinstance(item, int): # İkinci seviye girinti (8 boşluk) if item > 10: # Üçüncü seviye girinti (12 boşluk) print(" -> Bu sayı 10'dan büyük.") else: # Üçüncü seviye girinti (12 boşluk) print(" -> Bu sayı 10 veya daha küçük.") elif isinstance(item, str): # İkinci seviye girinti (8 boşluk) print(" -> Bu bir string.") # İçteki if/elif bitti (girinti 8 boşluğa döndü) # For döngüsü bitti (girinti 4 boşluğa döndü) print("Veri işleme tamamlandı.") # Fonksiyon bitti (girinti 0'a döndü) process_data([5, "elma", 15, "armut", 8])
Yaygın Girintileme Hataları (Common Indentation Errors)

Girintileme Python’un temel taşı olduğundan, hatalı kullanım sık karşılaşılan sorunlara yol açar. Python yorumlayıcısı bu konuda oldukça katıdır ve aşağıdaki hataları verebilir:

IndentationError: expected an indented block
Anlamı: Python, bir blok başlatıcı ifadeden (if, while, def, class, vb. sonunda : olanlar) sonra girintili bir kod bloğu bekliyordu, ancak bulamadı.
Örnek Hata:
x = 5 if x > 0: print("Pozitif") # Hata! Bu satır girintili olmalıydı.
Düzeltme: print satırını girintileyin (4 boşluk ekleyin).
x = 5 if x > 0: print("Pozitif") # Doğru
IndentationError: unexpected indent
Anlamı: Python, girintilenmemesi gereken bir yerde (örneğin, kodun en dış seviyesinde veya bir bloğun mantıksal olarak bittiği yerde) gereksiz bir girinti tespit etti.
Örnek Hata:
print("Başlangıç") x = 10 # Hata! Bu satırın başında gereksiz girinti var. print("Bitiş")
Düzeltme: Gereksiz girintiyi kaldırın.
print("Başlangıç") x = 10 # Doğru print("Bitiş")
IndentationError: unindent does not match any outer indentation level
Anlamı: Bir satırın girinti seviyesi azaltıldı (unindent yapıldı), ancak geri dönülen seviye, daha önceki herhangi bir dış bloğun girinti seviyesiyle eşleşmiyor. Bu genellikle tutarsız girintileme veya yanlış hizalamadan kaynaklanır.
Örnek Hata:
if True: print("Blok 1") print("Hatalı hizalama") # Hata! Girinti seviyesi (2 boşluk) ne dış (0) ne de iç (4) seviyeyle eşleşiyor.
Düzeltme: Girintiyi doğru seviyeye (0 veya 4 boşluk) getirin.
if True: print("Blok 1") print("Doğru hizalama") # İç blokla aynı seviye (4 boşluk) # veya if True: print("Blok 1") print("Blok dışı") # Dış seviye (0 boşluk)
TabError: inconsistent use of tabs and spaces in indentation
Anlamı: Aynı kod bloğu içinde veya bazen farklı bloklar arasında hem sekme (tab) karakterleri hem de boşluklar tutarsız bir şekilde girintileme için kullanılmış. Python 3, sekmeler ve boşlukların karıştırılmasına izin vermez.
Örnek Hata (Görsel olarak fark etmek zor olabilir):
if True: print("Bu satır 4 boşlukla girintili.") print("Bu satır bir TAB karakteriyle girintili.") # Hata!
Düzeltme: Tüm girintilemeler için sadece boşlukları (tercihen 4 boşluk) veya (önerilmese de) sadece sekmeleri kullanın. Kod düzenleyicinizin “boşlukları göster” özelliğini açmak ve “sekmeleri boşluklara çevir” ayarını kullanmak bu hatayı önlemeye yardımcı olur.
2.5. Girintilemenin Felsefesi ve Okunabilirlik

Python’un girintilemeyi zorunlu kılması sadece teknik bir gereklilik değil, aynı zamanda dilin temel felsefesinin bir yansımasıdır. Python Zen’de (kodunuza import this yazarak görebilirsiniz) belirtilen ilkelerden biri şudur: “Readability counts.” (Okunabilirlik önemlidir.)

Zorunlu girintileme, kodun yazıldığı andan itibaren belirli bir yapısal düzene sahip olmasını garanti eder. Bu, hem kodu yazan kişi için hem de daha sonra okuyacak veya üzerinde çalışacak diğer geliştiriciler için büyük bir avantajdır. Kodun mantıksal akışı ile görsel yapısı arasında doğrudan bir ilişki kurularak anlaşılması kolaylaşır.

Diğer dillerde, girintileme stilinin programcıya bırakılması, bazen kötü veya tutarsız girintilenmiş kodlara yol açabilir. Bu durum, özellikle büyük projelerde veya ekipler halinde çalışırken kodun anlaşılmasını ve bakımını zorlaştırabilir. Python, bu potansiyel sorunu tasarım düzeyinde çözmüştür.

Başlangıçta, diğer dillerden gelen programcılar için Python’un girintileme kuralı biraz garip veya kısıtlayıcı gelebilir. Ancak çoğu geliştirici, zamanla bu özelliğin kod kalitesini ve okunabilirliğini artırmadaki değerini takdir eder hale gelir.

Bölüm 3: Sözdizimi ve Girintileme Birlikte Nasıl Çalışır? — Örnekler

Şimdiye kadar öğrendiğimiz temel sözdizimi öğelerini ve girintileme kurallarını birleştirerek daha bütünsel örnekler inceleyelim.

Örnek 1: Basit Bir Sayı Tahmin Oyunu

import random # Rastgele sayı üretmek için modülü içe aktar (Sözdizimi: import)

Değişken tanımlama ve atama (Sözdizimi: tanımlayıcı = ifade)

secret_number = random.randint(1, 100) # 1 ile 100 arasında rastgele bir tam sayı seç
guess = None # Başlangıçta tahmin yok (None değeri)
attempts = 0 # Deneme sayısı
print("1 ile 100 arasında bir sayı tuttum. Tahmin etmeye çalış!") # print fonksiyonu

While döngüsü ve koşul (Sözdizimi: while ifade:)

while guess != secret_number:
# Girintili blok başlıyor (while döngüsünün gövdesi)
attempts += 1 # Atama operatörü (attempts = attempts + 1)
# Kullanıcıdan girdi alma ve tip dönüşümü (Sözdizimi: input, int)
try:
# Try bloğu başlıyor
guess_str = input(f"{attempts}. deneme. Tahmininiz: ")
guess = int(guess_str) # String'i integer'a çevir
# Try bloğu bitiyor
except ValueError:
# Except bloğu başlıyor (eğer int'e çevirme başarısız olursa)
print("Lütfen geçerli bir sayı girin.")
continue # Döngünün başına dön (continue anahtar kelimesi)
# Except bloğu bitiyor
# If/elif/else yapısı (Sözdizimi: if ifade: ... elif ifade: ... else:)
if guess < secret_number:
# Girintili blok (if'in gövdesi)
print("Daha yüksek bir sayı deneyin.")
elif guess > secret_number:
# Girintili blok (elif'in gövdesi)
print("Daha düşük bir sayı deneyin.")
else:
# Girintili blok (else'in gövdesi)
print(f"Tebrikler! Sayıyı {attempts} denemede buldunuz.")
print(f"Tuttuğum sayı {secret_number} idi.")
# Else bloğu bitiyor (ve döngü koşulu sağlanmadığı için while da biter)
# If/elif/else yapısı bitiyor

While döngü bloğu bitiyor (girinti seviyesi geri döndü)

print("Oyun bitti.") # Döngüden sonra çalışacak kod
Bu örnekte:

import, değişken atamaları, print, input, int gibi temel sözdizimi öğeleri kullanılmıştır.
while, try/except, if/elif/else gibi kontrol yapıları iki nokta üst üste (:) ile biterek blokları başlatmıştır.
Her bloğun içeriği tutarlı bir şekilde (4 boşluk) girintilenmiştir.
continue anahtar kelimesi döngünün akışını kontrol etmek için kullanılmıştır.
Farklı girinti seviyeleri (while içinde if, if içinde print) kodun yapısal hiyerarşisini göstermektedir.
Örnek 2: Fonksiyon ve Liste Kullanımı

Fonksiyon tanımlama (Sözdizimi: def fonksiyon_adı(parametreler):)

def filter_even_numbers(number_list):
"""Verilen listedeki çift sayıları filtreler ve yeni bir liste döner."""
# Girintili blok (fonksiyon gövdesi)
even_numbers = [] # Boş bir liste oluştur (Veri Tipi: list)
# For döngüsü (Sözdizimi: for eleman in koleksiyon:)
for number in number_list:
# Girintili blok (for döngüsü gövdesi)
# Modülüs operatörü ve karşılaştırma operatörü kullanılıyor
if number % 2 == 0: # Eğer sayının 2'ye bölümünden kalan 0 ise (çiftse)
# Girintili blok (if gövdesi)
even_numbers.append(number) # Sayıyı even_numbers listesine ekle (Liste metodu)
# If bloğu bitiyor
# For döngüsü bitiyor
# Fonksiyonun dönüş değeri (Sözdizimi: return ifade)
return even_numbers
# Fonksiyon bloğu bitiyor

Ana kod bölümü (girinti yok)

my_numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] # Liste literali
print(f"Orijinal Liste: {my_numbers}")

Fonksiyonu çağırma ve sonucu bir değişkene atama

filtered_list = filter_even_numbers(my_numbers)
print(f"Çift Sayılar: {filtered_list}")

Başka bir örnek

more_numbers = range(15, 26) # range objesi (bir tür koleksiyon)
even_subset = filter_even_numbers(more_numbers)
print(f"15-25 arasındaki çift sayılar: {list(even_subset)}") # range'den gelen sonucu görmek için listeye çevirdik
Bu örnekte:

def ile bir fonksiyon tanımlanmış, fonksiyon gövdesi girintilenmiştir.
Fonksiyon içinde for döngüsü ve if koşulu kullanılarak iç içe bloklar oluşturulmuştur.
Liste veri tipi ([]), liste metodu (append), return anahtar kelimesi gibi sözdizimi öğeleri görülmektedir.
Kodun farklı bölümleri (fonksiyon tanımı, ana kod) girinti seviyeleri ile açıkça ayrılmıştır.
Sonuç

Python’un temel sözdizimi, okunabilirlik ve basitlik üzerine kurulmuştur. Anahtar kelimeler, tanımlayıcılar, operatörler, veri tipleri ve temel fonksiyonlar gibi yapı taşları, programların mantığını ifade etmek için kullanılır. Ancak Python’u gerçekten özgün kılan ve onu diğer dillerden ayıran en önemli özellik, kod bloklarını tanımlamak için süslü parantezler yerine zorunlu girintileme kullanmasıdır.

Girintileme, sadece bir stil tercihi değil, Python sözdiziminin ayrılmaz bir parçasıdır. Kodun yapısal ve mantıksal hiyerarşisini görsel olarak yansıtarak okunabilirliği artırır ve tüm Python kodlarının belirli bir tutarlılığa sahip olmasını sağlar. PEP 8 stil rehberi, her seviye için 4 boşluk kullanılmasını önererek bu tutarlılığı pekiştirir.

Python’a yeni başlayanlar için girintileme kurallarına alışmak ve IndentationError gibi hatalardan kaçınmak başlangıçta biraz pratik gerektirebilir. Ancak bu mekanizmayı doğru bir şekilde anlamak ve uygulamak, temiz, okunabilir ve hatasız Python kodu yazmanın temelini oluşturur. Tutarlı girintileme alışkanlığı kazanmak, Python geliştirme sürecinin doğal ve önemli bir parçasıdır.

Python’un bu zarif ve etkili sözdizimi ve girintileme yapısı, onu hem yeni başlayanlar için öğrenmesi kolay hem de deneyimli geliştiriciler için güçlü ve verimli bir araç haline getiren temel nedenlerden biridir. Bu temelleri sağlam bir şekilde kavradıktan sonra, Python’un sunduğu daha gelişmiş özellikleri ve kütüphaneleri keşfetmeye hazır olacaksınız.

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