Değişkenler: Python'da 'Etiket vs Kutu' Felsefesi ve Assignment'ın İçsel Gerçeği

Önce diğer dillerde nasıl?#

1. RAM'de
   int
   boyutunda (4 byte) bir slot ayrılır.
2. O slot'a
   5
   yazılır.
3. x
   o slot'un adresine bağlanır.

[Bellek] x: [0x7ffe0]: 5    →    x: [0x7ffe0]: 10

x = 5
x = 10

1. Bellekte
   5
   integer nesnesi yaratıyor (zaten varsa kullanıyor — small int caching var).
2. x
   adlı bir etiket o nesneye yapıştırıyor.
3. Sonra
   5
   nesnesinden etiketi söküyor,
   10
   nesnesine yapıştırıyor.

[Bellek] [int 5] ← x         →    [int 5]    [int 10] ← x

Pratik kanıt —

id()

fonksiyonu#

>>> x = 5
>>> id(x)
4368089096

>>> x = 10
>>> id(x)
4368089256        # FARKLI! Aynı slot'a 10 yazılmadı; başka nesneye işaret ediyor

>>> a = 5
>>> b = 5
>>> id(a)
4368089096
>>> id(b)
4368089096        # AYNI! İkisi de aynı 5 nesnesine bağlı

>>> a = [1, 2, 3]
>>> b = [1, 2, 3]
>>> id(a)
4374893376
>>> id(b)
4374893568        # FARKLI! Liste mutable; iki ayrı nesne

Immutable vs Mutable — kritik ayrım#

• int
  ,
  float
  ,
  complex
• str
  (string)
• tuple
• bool
  ,
  None
• frozenset
• bytes

• list
• dict
• set
• bytearray
• Custom class (genelde)

# Immutable örnek (str)
s1 = "merhaba"
s2 = s1
s1 = s1 + " dünya"   # s1 yeni nesneye bağlandı
print(s1)            # 'merhaba dünya'
print(s2)            # 'merhaba'  ← değişmedi!

# Mutable örnek (list)
l1 = [1, 2, 3]
l2 = l1              # l2 aynı listeye bağlı
l1.append(4)         # listeyi yerinde değiştirdik
print(l1)            # [1, 2, 3, 4]
print(l2)            # [1, 2, 3, 4]  ← değişti!  (aynı nesne)

Multiple assignment — birden fazla değişkeni tek satırda#

# Tuple unpacking
a, b = 1, 2
print(a, b)         # 1 2

# Üç değişken
x, y, z = "merhaba", 3.14, True
print(x, y, z)      # merhaba 3.14 True

# Klasik swap (Python'un sevimli özelliği)
a, b = b, a
print(a, b)         # 2 1

// C
int temp = a;
a = b;
b = temp;

Aynı değer çoklu atama#

x = y = z = 0
print(x, y, z)      # 0 0 0

>>> x is y is z
True

# TUZAK!
a = b = c = []      # ÜÇÜ DE AYNI listeye bağlı
a.append(1)
print(a, b, c)      # [1] [1] [1]   ← üçü de değişti!

# Doğrusu
a, b, c = [], [], []   # üç ayrı liste
a.append(1)
print(a, b, c)      # [1] [] []

Klasik tuzak: Mutable default arguments#

def add_item(item, items=[]):
    items.append(item)
    return items

print(add_item("apple"))     # ['apple']  ← Beklenen
print(add_item("banana"))    # ['apple', 'banana']  ← ?!?!
print(add_item("cherry"))    # ['apple', 'banana', 'cherry']  ← FAKE!

>>> add_item.__defaults__
([],)   # Tek bir liste, fonksiyona bağlı

def add_item(item, items=None):
    if items is None:
        items = []
    items.append(item)
    return items

print(add_item("apple"))     # ['apple']
print(add_item("banana"))    # ['banana']  ← Doğru!
print(add_item("cherry"))    # ['cherry']

Augmented assignment —

+=

,

-=

,

*=

, ...#

x = 5
x += 3      # x = x + 3 → 8
x -= 1      # x = x - 1 → 7
x *= 2      # x = x * 2 → 14
x /= 4      # x = x / 4 → 3.5
x //= 1     # x = x // 1 → 3.0 (floor)
x %= 2      # x = x % 2 → 1.0
x **= 2     # x = x ** 2 → 1.0

a = [1, 2, 3]
b = a

a += [4]            # a'yı yerinde değiştirdi
print(a)            # [1, 2, 3, 4]
print(b)            # [1, 2, 3, 4]  ← b de değişti! (aynı nesne)

# Karşılaştır:
a = [1, 2, 3]
b = a
a = a + [4]         # YENİ liste yarattı, a yeni liste'ye bağlı
print(a)            # [1, 2, 3, 4]
print(b)            # [1, 2, 3]  ← b değişmedi

Walrus operator (

:=

) — Python 3.8 yenilikçisi#

# Eski yol — okumak istediğin şeyi iki kere yazıyorsun
data = read_chunk()
while data:
    process(data)
    data = read_chunk()

# Walrus ile
while (data := read_chunk()):
    process(data)

# numbers'ın karelerini al, ama 100'den büyük olanları sayma
numbers = [10, 20, 5, 100, 50, 200]

# Eski yol — iki kere n*n hesaplıyor
result = [n*n for n in numbers if n*n < 10000]

# Walrus ile — bir kere hesapla, atayıp kullan
result = [sq for n in numbers if (sq := n*n) < 10000]
print(result)   # [100, 400, 25, 10000... oh wait, 10000 değil 100, 400, 25, 2500]

# Eski
match = re.search(pattern, text)
if match:
    print(match.group())

# Walrus ile
if match := re.search(pattern, text):
    print(match.group())

del

ve garbage collection#

x = [1, 2, 3]
del x
print(x)   # NameError: name 'x' is not defined

import sys

l = [1, 2, 3]
sys.getrefcount(l)   # 2 (l + sys.getrefcount'un kendi referansı)

a = l
sys.getrefcount(l)   # 3

b = l
sys.getrefcount(l)   # 4

del a
sys.getrefcount(l)   # 3

del b
del l
# l artık 0 referansa düştü, garbage collector temizler

• Her nesne kaç etikete sahipse o sayıda "referans" sayar.
• Sayı 0'a düştüğünde nesneyi otomatik siler.

a = []
b = [a]
a.append(b)
# a, b'yi içerir; b, a'yı içerir → reference counting bunları silmez
# Ek GC algoritması bu cycles'ı bulur ve temizler

Fonksiyon parametreleri — pass by value mı, reference mı?#

• Fonksiyon parametresi yeni bir etiket.
• O etiket, dışardan verilen nesneye işaret ediyor.
• Mutable nesne dışardan içeride mutate edilirse — değişiklik kalıcı.
• Immutable nesne içeride "değiştirildiğinde" — yeni nesne yaratılır, dışarıdaki değişmez.

def modify_list(lst):
    lst.append(99)         # mutate — dış da etkilenir

def reassign_list(lst):
    lst = [4, 5, 6]        # yerel etiket başka nesneye bağlandı; dış değişmez

def modify_int(n):
    n = n + 1              # yerel etiket başka nesneye; dış değişmez

# Test
my_list = [1, 2, 3]
modify_list(my_list)
print(my_list)             # [1, 2, 3, 99]  ← DEĞIŞTI

my_list2 = [1, 2, 3]
reassign_list(my_list2)
print(my_list2)            # [1, 2, 3]  ← DEĞIŞMEDI

my_int = 5
modify_int(my_int)
print(my_int)              # 5  ← DEĞIŞMEDI (immutable)

1. Fonksiyon adı net olsun:
   add_item(items, item)
   mutate ettiğini belli ediyor.
2. Mutate etmek istemiyorsan kopya al:
   def f(items): items = items.copy(); ...
   .
3. Type hint kullan:
   def f(items: list[int]) -> None
   — None dönüyorsa side-effect yapacağı belli.

Değişken adı kuralları (kısa giriş)#

• Harf veya
  _
  ile başlar, devamında harf/rakam/
  _
  olabilir.
• Case-sensitive:
  x
  ile
  X
  farklı.
• Reserved keyword olamaz:
  if
  ,
  for
  ,
  def
  ,
  class
  ,
  return
  , ... (toplam ~35 keyword).
• Türkçe karakter teknik olarak çalışır ama kullanma — Modül 2/Ders 2'de detayda göreceğiz.

x = 1
total = 100
my_var = "hello"
_private = True
__name__ = "main"
counter1 = 0

1x = 1          # rakamla başlayamaz
my-var = 1      # tire değil, alt çizgi
class = "X"     # reserved keyword
my var = 1      # boşluk olmaz

import keyword
print(keyword.kwlist)
# ['False', 'None', 'True', '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', 'match', 'case', '_']

Hands-on egzersizi 1: Etiket vs nesne#

a = [1, 2, 3]
b = a
c = a.copy()

a.append(4)
b.append(5)
c.append(6)

print(f"a = {a}")
print(f"b = {b}")
print(f"c = {c}")

print(f"a is b: {a is b}")
print(f"a is c: {a is c}")

a = [1, 2, 3, 4, 5]    # a ve b aynı listede; iki append uygulandı
b = [1, 2, 3, 4, 5]    # aynı liste — b is a True
c = [1, 2, 3, 6]       # ayrı bir liste — sadece c.append(6)
a is b: True
a is c: False

Hands-on egzersizi 2: Mutable default tuzağı#

def collect_users(name, users=[]):
    users.append({"name": name, "added_at": "now"})
    return users

# Test
print(collect_users("Ali"))
print(collect_users("Ayşe"))
print(collect_users("Mehmet"))

[{'name': 'Ali', 'added_at': 'now'}]
[{'name': 'Ayşe', 'added_at': 'now'}]
[{'name': 'Mehmet', 'added_at': 'now'}]

[{'name': 'Ali', 'added_at': 'now'}]
[{'name': 'Ali', 'added_at': 'now'}, {'name': 'Ayşe', 'added_at': 'now'}]
[{'name': 'Ali', 'added_at': 'now'}, {'name': 'Ayşe', 'added_at': 'now'}, {'name': 'Mehmet', 'added_at': 'now'}]

def collect_users(name, users=None):
    if users is None:
        users = []
    users.append({"name": name, "added_at": "now"})
    return users

Bu derste neler kazandın?#