Python Değişkenler:RAM Fiziği, İşaretçiler ve Veri Tanımlama

Herhangi bir yazılım kitabını veya sıradan bir internet eğitimini açtığında sana şu klasik, basmakalıp tanımı yaparlar: "Değişkenler, içine veri koyduğumuz birer kutudur." Bu aşırı basitleştirilmiş ve ezbere dayalı benzetme, Python programlama dilinde tamamen yanlıştır! Python'da değişkenler, içine veri atılan fiziksel kutular (depolama alanları) değildir. Python'da değişkenler; heap bellekte (RAM) bağımsızca yaşayan devasa nesnelere (objelere) tutturulmuş, onları işaret eden birer etiket veya referans (isim kartı)'dır!

Kullandığımız en küçük bir sayının veya metnin arka planda RAM'deki fiziksel transistör hücrelerini nasıl adreslediğini, Python'ın veri tiplerini nasıl dinamik olarak yönettiğini ve bellekteki "değiştirilemezlik" (immutability) kurallarını kavramadan yazacağın her kod, yarın devasa projelerde bellek sızıntılarına (memory leak) ve gizli böceklere (bug) dönüşecektir. Bu rehberde; klasik, sıkıcı "kutular" masalını bir kenara bırakıyoruz. Python'daki referans atama (binding) mekaniğini, id() fonksiyonuyla RAM adreslerinin izini sürmeyi, Mutable (Değiştirilebilir) ve Immutable (Değiştirilemez) verilerin bellek savaşını ve CPython'ın perde arkasındaki PyObject yapısını tıpkı bir bilgisayar mimarı gibi inceliyoruz!

1. Python'da Değişkenlerin Gerçek Fiziği: Referans ve Etiketleme

C, C++ veya Java gibi statik tipli dillerde bir değişken tanımladığında (örneğin int x = 10;), bellekte doğrudan 4 baytlık (32-bit) bir "fiziksel hücre" ayrılır ve 10 sayısı o hücrenin içine yazılır. Eğer x = 20 derseniz, o hücrenin içindeki eski veri silinir ve yerine 20 yazılır. Hücrenin bellek adresi asla değişmez.

Python'da x = 10 yazdığında ise şu üç kademeli süreç işletilir:

1. Nesne Oluşturulması: Python önce RAM'in "Heap" bölgesinde 10 değerini taşıyan bağımsız bir tam sayı (integer) nesnesi (objesi) oluşturur. Bu nesne sadece "10" sayısını değil; referans sayacını ve tip bilgisini de içeren 28 baytlık devasa bir PyObject yapısıdır.
2. Adresleme: Bu nesnenin RAM'de benzersiz bir fiziksel adresi oluşur (örneğin 0x7ffee23b1ab0).
3. Referans Atama (Binding): İşte senin x dediğin değişken, bu adresi işaret eden, o nesneye yapıştırılmış bir etikettir (pointer/referans).

Eğer kodun devamında x = 20 derseniz, Python 10 sayısının olduğu kutunun içini boşaltıp 20 yazmaz! Gider bellekte tamamen yeni bir yerde 20 nesnesi oluşturur ve x etiketini söküp bu yeni 20 nesnesine yapıştırır. Ortada başıboş kalan 10 nesnesi ise, ona işaret eden başka bir değişken yoksa, Python'ın Garbage Collector (Çöp Toplayıcı) mekanizması tarafından RAM'den sessizce silinir.

  [PYTHON REFERANS ATAMA (BINDING) GÖRSELİ]

  x = 10  Yazıldığında:
  [ x (Etiket) ] ----------> [ Heap Bellekte 10 Nesnesi (Adres: 0x01) ] (Referans Sayısı: 1)

  x = 20  Yazıldığında:
  [ x (Etiket) ] ──┐         [ Heap Bellekte 10 Nesnesi (Adres: 0x01) ] (Referans: 0 -> Çöp Toplayıcı Siler!)
                   └-------> [ Heap Bellekte 20 Nesnesi (Adres: 0x02) ] (Referans Sayısı: 1)

2. Bir Değişkenin Bellek Adresini (RAM) İzlemek: id() Fonksiyonu

Python'da bu durumun bir yanılsama olmadığını kendi gözlerinle görebilirsin. id() fonksiyonu, bir nesnenin RAM'deki benzersiz kimlik numarasını (adresini) verir. Gel beraber şu deneyi terminalde yapalım:

# İki farklı etiket, aynı nesneye yapışıyor
a = 500
b = 500

print(f"a'nın RAM Adresi: {id(a)}") # Örn: 140732715096368
print(f"b'nin RAM Adresi: {id(b)}") # Örn: 140732715096368 (Aynı adres!)

# a'nın değerini değiştirelim (etiketi başka yere taşıyalım)
a = a + 1

print(f"Yeni a'nın RAM Adresi: {id(a)}") # Örn: 140732715096400 (ADRES DEĞİŞTİ!)
print(f"b'nin RAM Adresi: {id(b)}")     # Örn: 140732715096368 (b'nin adresi aynı kaldı)

Gördüğün gibi, a'nın değerini artırmak, a'nın işaret ettiği nesneyi yerinde değiştirmemiş; onu tamamen farklı bir bellek adresindeki yeni bir sayı nesnesine (501) yönlendirmiştir. b ise hala eski adresindeki 500 nesnesine bakmaya devam etmektedir.

3. Hayati Ayrım: Değiştirilebilir (Mutable) ve Değiştirilemez (Immutable) Tipler

Python'da değişkenlerin ve verilerin davranışını belirleyen en keskin sınır, verinin bellekte "değiştirilebilir" olup olmamasıdır. Bu ayrım, algoritmaların performansını ve güvenliğini doğrudan etkiler:

• Değiştirilemez (Immutable) Veri Tipleri: int, float, string, tuple, bool. Bu nesneler bellekte bir kez oluştuktan sonra asla değiştirilemezler. Üzerinde yapacağın her işlem (örneğin bir metne yeni bir harf eklemek), bellekte tamamen yeni bir nesne oluşturulmasıyla ve etiketin oraya taşınmasıyla sonuçlanır.
• Değiştirilebilir (Mutable) Veri Tipleri: list, dict, set. Bu nesneler bellekteki yerlerini ve adreslerini korurken, içerdikleri elemanlar dinamik olarak eklenebilir, silinebilir veya güncellenebilir.

Görünüşte basit olan bu kuralın yaratabileceği büyük tehlikeyi şu örnekte inceleyelim:

# İki liste tanımlayalım
liste_1 = [1, 2, 3]
liste_2 = liste_1 # liste_2'yi liste_1'e eşitledik (aynı nesneye iki etiket)

# Sadece liste_2'ye yeni bir eleman ekleyelim
liste_2.append(99)

print(f"liste_1: {liste_1}") # Çıktı: [1, 2, 3, 99] (WOW! liste_1 de değişti!)
print(f"liste_2: {liste_2}") # Çıktı: [1, 2, 3, 99]

Buradaki "WOW!" anı, yazılıma yeni başlayanların en çok düştüğü tuzaktır. liste_2 = liste_1 dediğinde Python listeyi kopyalamadı; sadece liste_2 etiketini de liste_1'in baktığı aynı fiziksel listeye (referansa) bağladı. Liste "değiştirilebilir (mutable)" olduğu için, bir etiket üzerinden yapılan değişiklik, o ortak nesneyi doğrudan etkiledi ve diğer etiketten bakıldığında da veri değişmiş oldu.

4. Temel Veri Tipleri ve Doğru Tanımlama Kılavuzu

Python, dinamik tipli (dynamically-typed) bir dildir. Değişkeni tanımlarken tipini (int, str vb.) belirtmek zorunda kalmazsın; Python, nesneye atanan değere göre tipi çalışma zamanında (runtime) otomatik olarak belirler. İşte en çok kullanacağın temel tipler ve mühendislik düzeyinde tanımlanmaları:

5. Pythonic Değişken Tanımlama Kuralları ve Standartlar (PEP 8)

Yazdığın kodun kalitesi ve okunabilirliği, Python topluluğunun resmi stil rehberi olan PEP 8 standartlarına ne kadar uyduğunla ölçülür. Python'da değişken tanımlarken şu kuralları adeta bir refleks haline getirmelisin:

• Snake Case Kullanımı: Değişken isimleri tamamen küçük harflerle yazılmalı ve kelimeler alt çizgi ile ayrılmalıdır. (Örn: kullanici_giris_sayisi = 5 - Doğru / kullaniciGirisSayisi = 5 veya kullanicigirissayisi = 5 - Yanlış/Zayıf).
• Sayı ile Başlayamaz: Değişken isimleri bir rakamla başlayamaz, ancak içinde veya sonunda sayı barındırabilir. (Örn: 3_veri = "hatali" - Çalışmaz / veri_3 = "dogru" - Sorunsuz).
• Özel Karakter Yasağı: İsimlendirmede boşluk ve !, @, $, %, &, - gibi özel karakterler kullanılamaz. Sadece harf, sayı ve alt çizgi (_) geçerlidir.
• Anahtar Kelime Yasağı (Reserved Words): Python'ın kendi sentaksında kullandığı özel anahtar kelimeler değişken ismi olamaz. (Örn: if = 5, class = "okul", def = True gibi ifadeler doğrudan syntax error (sözdizimi hatası) fırlatır).