id(), is, == — Identity vs Equality: Python Bellek Modelinin Final Sınavı

Önce hatırlatma — Modül 2/Ders 1'den#

1. Bellekte
   5
   int nesnesi var (zaten varsa kullanılıyor — small int cache).
2. a
   adlı etiket o nesneye bağlanıyor.

• Identity: Aynı nesneye mi bağlı? (id'ler aynı mı?) →
  is
  .
• Equality: Değer eşit mi? →
  ==
  .

a = [1, 2, 3]
b = a              # b aynı nesneye bağlandı
c = [1, 2, 3]      # ayrı nesne, aynı içerik

print(a is b)      # True (aynı nesne)
print(a is c)      # False (farklı nesne)
print(a == b)      # True (eşit içerik)
print(a == c)      # True (eşit içerik)

id()

fonksiyonu — bellek adresi#

x = 42
print(id(x))         # örn 4368089096

# Hex olarak (adresleri böyle görmek alışkındır)
print(hex(id(x)))    # '0x10500ac88'

# Aynı nesneye iki etiket
y = x
print(id(y))         # aynı sayı

# Farklı nesneye atama
x = 100
print(id(x))         # farklı sayı (yeni nesne)

# x is y aslında: id(x) == id(y)
a = [1, 2]
b = a
print(a is b)              # True
print(id(a) == id(b))      # True (denk)

1. id'ler her runtime'da farklı.

   id(x) == 4368089096

   bir runtime'da, başka runtime'da farklı sayı. Test'lerinde id kullanma.
2. id'ler bir ömür için garantili sadece o nesne yaşadığı sürece. Garbage collected nesnenin id'si yeniden kullanılabilir!

import gc

x = [1, 2, 3]
old_id = id(x)
del x
gc.collect()

# Şimdi farklı bir nesne aynı id'yi alabilir
y = [4, 5, 6]
print(id(y) == old_id)   # bazen True (memory reuse)!

3. PyPy/Jython implementasyonları farklı id formatına sahip olabilir. Standardı: id'ler unique, integer, ömür boyu garantili. Implementation detayları farklı.

is

vs

==

— derinlemesine#

# Aynı nesne
a = [1, 2, 3]
b = a
print(a is b)    # True
print(a == b)    # True

# Farklı nesne, aynı içerik
c = [1, 2, 3]
d = [1, 2, 3]
print(c is d)    # False
print(c == d)    # True

# Aynı içerik, immutable — implementation-defined
x = "hello"
y = "hello"
print(x is y)    # True (string interning — sonra)
print(x == y)    # True

# Aynı içerik, immutable, dynamic
import sys
a = sys.intern("merhaba")
b = sys.intern("merhaba")
print(a is b)    # True (zorlanmış intern)

is

ne zaman kullanılır?#

# ✅
if x is None: ...
if x is True: ...     # nadiren — 'if x:' daha iyi
if x is False: ...    # nadiren

# 🚫 (implementation detail'a güveniyor)
if x is 5: ...
if x is "hello": ...

==

ne yapıyor?#

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

p1 = Point(1, 2)
p2 = Point(1, 2)
print(p1 == p2)   # False (default __eq__ — identity)
print(p1 is p2)   # False

# Override
class Point2:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __eq__(self, other):
        return isinstance(other, Point2) and self.x == other.x and self.y == other.y

p3 = Point2(1, 2)
p4 = Point2(1, 2)
print(p3 == p4)   # True (custom __eq__)
print(p3 is p4)   # False (hâlâ farklı nesne)

Small int caching — derinlemesine#

a = 5
b = 5
print(a is b)        # True (small int cache)

a = 100
b = 100
print(a is b)        # True

a = 256
b = 256
print(a is b)        # True (sınır)

a = 257
b = 257
print(a is b)        # False (genelde) — cache dışı

Görselleştirme#

import sys

# Small int cache'in pre-allocated olduğunu kanıtla
for i in range(-5, 257):
    print(f"{i}: refcount={sys.getrefcount(i)}")
# Çıktı: -5: refcount=66, -4: 30, ..., 256: çok yüksek
# Cache dışı:
print(f"257: refcount={sys.getrefcount(257)}")  # düşük

Neden böyle?#

Pratik etkisi?#

# 🚫 Kötü
if count is 5:
    ...    # 5 cache'te ama 257 olsa False!

# ✅
if count == 5:
    ...    # her zaman doğru

String interning — daha karmaşık#

# Değişken adları otomatik intern
a = "hello"
b = "hello"
print(a is b)        # True (genelde)

# Aynı şey
def foo():
    x = "world"
    return x

s = foo()
t = "world"
print(s is t)        # True

# Boşluklu string — intern olmayabilir
x = "hello world"
y = "hello world"
print(x is y)        # CPython 3.x: True (genelde)
                     # Ama implementation detail'a güvenme

# Programatik string — intern garantili değil
import time
a = "abc" + str(time.time())[:0]   # "abc" + ""
b = "abc"
print(a is b)        # genelde False (runtime concat'tı)

Manuel intern:

sys.intern

#

import sys

a = sys.intern("special_key")
b = sys.intern("special_key")
print(a is b)        # Garantili True

# Kullanım: dict key olarak yoğun aynı string'ler
keys = [sys.intern(s) for s in ["status", "id", "name"] * 1000000]

CPython implementasyon detayı#

# Identifier-like string'ler kompile time intern
"hello".isidentifier()    # True → intern
"a b c".isidentifier()     # False → intern olmayabilir

# Length sınırı yok ama kısa string'ler daha çok intern oluyor

Singleton'lar —

is

ile karşılaştırılması GEREKEN#

# None
print(None is None)              # True (tek None)
a = None
b = None
print(a is b)                    # True

# True ve False
print(True is True)              # True
print(False is False)            # True

# NotImplemented (sentinel)
print(NotImplemented is NotImplemented)   # True

# Ellipsis (...)
print(... is ...)                # True

# StopIteration
print(StopIteration is StopIteration)
# True (class itself is singleton-like)

1. is
   daha hızlı (id karşılaştırma).
2. Custom class
   __eq__
   'i override edebilir — yanıltıcı sonuç.
3. Linter (PEP 8)
   == None
   'a uyarı atıyor.

# Çok yaygın pattern
def fetch(default=None):
    if default is None:
        default = []
    # ...

Bonus:

weakref

— bellek modeline derinlik#

import weakref
import gc


class Cache:
    def __init__(self, name):
        self.name = name
        print(f"Cache({name}) yaratıldı")

    def __del__(self):
        print(f"Cache({self.name}) silindi")


# Strong reference
c1 = Cache("strong")
print(f"c1: {c1.name}")
del c1
gc.collect()
# "Cache(strong) silindi" yazar

# Weak reference
c2 = Cache("weak")
ref = weakref.ref(c2)

# weakref ile erişim
obj = ref()
print(f"weakref'ten: {obj.name if obj else 'None'}")    # weak
del c2
gc.collect()
# "Cache(weak) silindi" yazar

# weakref artık None döner
obj = ref()
print(f"Silindikten sonra: {obj}")   # None

Use case: cache, observer pattern#

import weakref


class EventBus:
    def __init__(self):
        # subscribers'ı weakref olarak tut — referans varsa otomatik silinir
        self._subscribers = weakref.WeakSet()

    def subscribe(self, listener):
        self._subscribers.add(listener)

    def emit(self, event):
        for listener in self._subscribers:
            listener.handle(event)


class Listener:
    def handle(self, event):
        print(f"Got event: {event}")


bus = EventBus()
listener = Listener()
bus.subscribe(listener)
bus.emit("test")    # "Got event: test"

# Listener silindiğinde otomatik unsubscribe
del listener
import gc; gc.collect()
bus.emit("test2")   # hiçbir çıktı (listener kayboldu)

Karar matrisi:

is

mi

==

mı?#

Pratik debug ipucu#

# Hangi nesneye bakıyorum
print(f"x: id={id(x)}, val={x!r}")

# == ve is birbirinden farklı sonuç veriyor mu?
print(f"x == y: {x == y}, x is y: {x is y}")

# Eğer == True ama is False ise: aynı değer, farklı nesne
# Eğer == False ama is True ise: __eq__ override garip — incele

Yaygın tuzaklar — son liste#

1. Integer ile

is

#

# 🚫
x = 1000
y = 1000
if x is y: ...    # False! 1000 cache dışı

# ✅
if x == y: ...

2. String ile

is

#

# 🚫
greeting = input("Merhaba ne?")
if greeting is "evet": ...    # implementation-defined

# ✅
if greeting == "evet": ...

3.

__eq__

override +

is

#

class Confusing:
    def __eq__(self, other):
        return True   # her şeye True

c = Confusing()
print(c == 5)    # True
print(c == "x")  # True
print(c is 5)    # False (identity OK)

# == güvenilir değil eğer __eq__ override edilmişse
# is her zaman doğru identity

4. Garbage collection ve id#

def get_id():
    obj = object()
    return id(obj)

id1 = get_id()
id2 = get_id()
print(id1 == id2)   # bazen True! (memory reuse)

5. Cache invalidation#

import functools

@functools.lru_cache(maxsize=128)
def expensive(x):
    return x * 2

a = expensive(5)
b = expensive(5)
print(a is b)    # True (cache aynı nesneyi dönüyor)

6. Mutable default + identity#

def f(items=[]):
    items.append(1)
    return items

a = f()
b = f()
print(a is b)    # True! (Modül 2/Ders 1 hatırla — mutable default)

Modül 2 sonu — neler kazandın?#

Self-assessment — Modül 2 mezunu olabilir misin?#

1. a = [1, 2]; b = a; a += [3]
   sonucunda
   b
   ne?
2. Decimal(0.1)
   ile
   Decimal('0.1')
   farkı?
3. 0.1 + 0.2 == 0.3
   neden False, nasıl güvenli karşılaştırırsın?
4. x & 1 == 1
   ile
   (x & 1) == 1
   farkı? Neden?
5. a = 1000; b = 1000; a is b
   ne döner ve neden?
6. @total_ordering
   decorator'unu ne için kullanırsın?
7. __eq__
   tanımladığında
   __hash__
   ile ne yapman gerek?
8. if x:
   ile
   if x is not None:
   arasında ne zaman hangi?
9. Mutable default argument tuzağı nedir, çözüm pattern'i?
10. int("3.14")
    neden hata atar, nasıl düzeltirsin?

Lokal Durum#