---
title: 'Değişkenler ve Bağlama'
source: 'https://academia.sh/tr/kurslar/programlama-temelleri/degiskenler-ve-baglama'
course: 'Programlama Temelleri'
language: tr
updated: '2026-08-17T18:08:27+00:00'
license: 'CC BY-SA 4.0'
---

# Değişkenler ve Bağlama

Adın değere bağlanması, atamanın anlamı, iki değişken modeli ve adlandırma kuralları.

Önceki derste `olcum_1 = 12` yazıldı ve bunun bir değer sakladığı söylendi. Bu ders o
cümlenin altını doldurur: ad ile değer arasındaki bağ nasıl kurulur, ne zaman değişir ve
bellekte neye karşılık gelir?

Soru göründüğünden daha derindir, çünkü diller bu bağı iki farklı biçimde modeller ve
aradaki fark, ilerideki derslerde gözlenebilir sonuçlar doğurur.

## Atama Bir Bağlama İşlemidir

`olcum_1 = 12` deyimi iki adımda yürütülür:

1. Eşittir işaretinin **sağındaki ifade** değerlendirilir; bir değer üretilir.
2. Bu değer, soldaki **ada bağlanır**.

Sıra önemlidir. `toplam = toplam + 5` deyimi, matematikte anlamsız bir denklem gibi
görünür; program olarak ise açıktır: önce sağdaki ifade hesaplanır (eski değere $5$
eklenir), sonra sonuç aynı ada yeniden bağlanır.

Bu nedenle eşittir işareti burada "eşitlik" değil, "bağla" anlamındadır. Bazı diller
karışıklığı önlemek için `:=` gibi ayrı bir simge kullanır; eşitlik sınaması ise
genellikle `==` ile yazılır.

## Değişken Ne Tutar: İki Model

Diller değişkeni iki farklı biçimde modeller. Fark, önceki kursta kurulan bellek
modeliyle birlikte düşünüldüğünde netleşir.

**Bellek gözü modeli.** Değişken, belirli bir tür için ayrılmış adlandırılmış bir bellek
alanıdır. Atama, o alanın içeriğini değiştirir. Değişkenin adresi ömrü boyunca sabittir;
değişen, içindeki bit örüntüsüdür. Alt seviyeli dillerin çoğu bu modeli kullanır.

**Ad–nesne bağı modeli.** Değerler bellekte bağımsız nesneler olarak durur; değişken ise
bu nesnelerden birine takılmış bir etikettir. Atama, nesnenin içeriğini değiştirmez;
etiketi başka bir nesneye taşır. Aynı nesneye birden çok etiket takılabilir.

İki modelin gözlenebilir farkı, iki değişkenin aynı veriyi paylaşıp paylaşmadığında
ortaya çıkar:

```python
a = [1, 2, 3]      # bir liste nesnesi; 'a' ona bağlandı
b = a              # 'b' aynı nesneye bağlandı; kopya yok
b.append(4)

print(a)           # [1, 2, 3, 4]  — 'a' üzerinden de görülüyor
print(a is b)      # True          — aynı nesne
print(a == b)      # True          — aynı içerik

c = [1, 2, 3, 4]
print(a is c)      # False         — farklı nesneler
print(a == c)      # True          — aynı içerik
```

`is` işleci **kimlik** sorar: iki ad aynı nesneye mi bağlı? `==` işleci **eşitlik**
sorar: içerikleri aynı mı? İki sorunun karıştırılması, paylaşılan veriyle çalışan
programların yaygın hata kaynağıdır.

Bu ayrım, fonksiyonlara argüman aktarımı dersinde tekrar karşınıza çıkacak; oradaki
"değer mi referans mı" tartışması, buradaki iki modelin doğrudan sonucudur.

Paylaşımı kırmanın yolu, açıkça kopya üretmektir. Kopyalamanın da iki derinliği vardır:
yalnızca dış kabuğu kopyalayan sığ kopya ve iç içe tüm yapıyı kopyalayan derin kopya.
Sığ kopyada iç nesneler hâlâ paylaşılır; bu, kopyalandığı sanılan verinin beklenmedik
biçimde değişmesinin yaygın nedenidir. Kopyalama maliyeti veri büyüdükçe arttığından,
paylaşmak ile kopyalamak arasındaki seçim bir tasarım kararıdır.

## Yeniden Bağlama ve Sıra

Bir ad, program boyunca farklı değerlere bağlanabilir. Bu, sırayla ilgili bir tuzağı da
beraberinde getirir: iki değişkenin değerlerini takas etmek, doğrudan iki atamayla
yapılamaz.

```python
x = 3
y = 7

# Yanlış: ilk atamadan sonra x'in eski değeri kaybolur.
x = y
y = x
print(x, y)        # 7 7  — takas olmadı

# Doğru: geçici bir ad kullanılır.
x, y = 3, 7
gecici = x
x = y
y = gecici
print(x, y)        # 7 3
```

Bazı diller çoklu atamayı destekler ve takas tek satıra iner (`x, y = y, x`); bu
yazımda sağ taraf tümüyle değerlendirilip sonra bağlama yapıldığı için geçici ada gerek
kalmaz. Sözdizim kolaylığı, altta yatan kuralı değiştirmez.

## Tanımlanmamış Ad

Bir ada, bağlanmadan önce erişilirse ne olur? Yanıt, dilin değişken modeline bağlıdır ve
bu, iki modelin ikinci gözlenebilir farkıdır.

Ad–nesne bağı modelinde ad henüz hiçbir nesneye bağlı değildir; erişim, açık bir hata
verir:

```python
# print(toplam)     -> çalışma zamanı hatası: 'toplam' tanımlı değil
toplam = 0          # önce bağlanır
print(toplam)       # 0
```

Bellek gözü modelinde ise değişken için yer ayrılmıştır ve o yerde bir bit örüntüsü
zaten vardır. Dil, ayrılan alanı sıfırlamıyorsa, okunan değer önceki kullanımdan kalan
anlamsız bir örüntüdür. Program çöker de çökmeyebilir de; her çalıştırmada farklı sonuç
verebilir.

İkinci durumun tehlikesi, hatanın belirtisiz olmasıdır. Bu yüzden bu modeli kullanan
diller ya ilk değer vermeyi zorunlu kılar, ya derleyici uyarısı üretir, ya da ayrılan
alanı otomatik sıfırlar.

Genel kural her iki modelde de aynıdır: **bir değişken, kullanılmadan önce anlamlı bir
değere bağlanır.** İlk değer atamasını bildirimle aynı satıra koymak, bu kuralı görünür
kılar.

## Adlandırma

Adlar dilin kurallarına ve ekibin sözleşmelerine uyar.

**Kurallar** dile aittir ve zorunludur: hangi karakterlerle başlanabileceği, büyük–küçük
harf ayrımının olup olmadığı, hangi sözcüklerin ayrılmış olduğu. `if` veya `while` gibi
anahtar sözcükler değişken adı olarak kullanılamaz.

**Sözleşmeler** ekibe aittir ve okunabilirlik içindir:

- Ad, değişkenin **ne tuttuğunu** söyler: `toplam`, `olcum_sayisi`, `en_buyuk`.
- Tek harfli adlar yalnızca dar ve alışılmış bağlamlarda kullanılır (döngü sayacı gibi).
- Kısaltma, okuyucunun bildiği varsayılamayacak biçimdeyse açılır.
- Bir projede tek bir yazım düzeni kullanılır; aynı kavram iki farklı adla anılmaz.

Ad seçimi süs değildir. Kodun okunma sayısı yazılma sayısından fazladır; adlar, kodu
her okuyanın harcadığı çabayı belirler. Yazılım tasarımı müfredatında bu konu temiz kod
başlığı altında ayrıntılandırılır.

## Sabitler

Bazı adlar programın çalışması boyunca aynı değere bağlı kalmalıdır: bir dönüşüm
katsayısı, bir üst sınır, bir yapılandırma değeri. Bunlara **sabit** denir.

Diller bunu iki biçimde ele alır. Kimi diller sabitliği zorlar: sabite yeniden atama
derleme hatasıdır. Kimi diller yalnızca sözleşmeye dayanır — ad büyük harflerle yazılır
ve değiştirilmemesi beklenir.

```python
OLCUM_SINIRI = 100        # sözleşme gereği sabit sayılır
```

Sabit kullanmanın yararı, aynı değerin kod içinde birden çok yerde yinelenmesini
önlemektir. Değer değiştiğinde tek bir satır güncellenir; kodun içine serpiştirilmiş
sayılar aranmaz. İkinci ve daha az fark edilen yararı, ada anlam yüklemesidir: koşulda
geçen `100` sayısı okuyucuya hiçbir şey söylemezken, `OLCUM_SINIRI` adı sınırın neyi
temsil ettiğini söyler.

## Özet

- Atama önce sağdaki ifadeyi değerlendirir, sonra sonucu soldaki ada bağlar; eşittir
  işareti eşitlik değil bağlama anlamındadır.
- Diller değişkeni iki biçimde modeller: adlandırılmış bellek gözü veya nesneye takılmış
  etiket.
- Aynı nesneye birden çok ad bağlanabilir; `is` kimliği, `==` içerik eşitliğini sınar.
- Yeniden bağlama sırası önemlidir; takas için geçici bir ad veya çoklu atama gerekir.
- Adlandırma kuralları dile, sözleşmeler ekibe aittir; ad değişkenin ne tuttuğunu
  söylemelidir.
- Sabitler, yinelenen değerleri tek bir noktada toplar.

## Sonraki Adım

Bu derste adlara sayılar ve listeler bağlandı; ikisinin farklı davrandığı görüldü. Peki
bir değerin türü tam olarak neyi belirler ve kaç tür vardır? Sonraki ders, temel veri
tiplerini ve her birinin hangi işlemleri desteklediğini ele alacak.