Python’da nesne zihinsel modeli: kimlik, değer, durum ve referans

Bu haftadan itibaren nesne yönelimli programlamaya (object-oriented programming, OOP) geçiyoruz. Python’da programın kullandığı her değer, yani her sayı, metin, liste ve sözlük, bir nesnedir (object). Kendi nesne türlerimizi, yani sınıfları (class), gelecek hafta class deyimiyle tanımlayacağız. Bu hafta değişken adlarının nesnelere nasıl bağlandığını ve aynı nesneye iki farklı addan erişince ne olduğunu göreceğiz. 3. haftada listelerle yaptığımız deneyleri bu kez bir kayıtla yineleyeceğiz. Örnekler bir kırtasiyenin stok programından. Her ürünün bir adı ve depoda kaç tane kaldığını gösteren bir stok sayısı var. Kasada satılan kalem depo ekranında da eksilmeli, yani iki ekran aynı ürün kaydını kullanmalı.

Bu sayfadaki kod hücreleri kendiliğinden çalışmaz. Her hücrede önce çıktıyı tahmin edin, sonra Run Code düğmesine basın. Kodu değiştirip yeniden çalıştırabilir, Start Over ile ilk hâline döndürebilirsiniz.

Bu bölümün kapsamı

NotSınavda sorulur
  • Değişken adının bir nesneye bağlanması
  • Nesnenin kimlik, tür ve değer özellikleri
  • Aynı nesneye iki referans olduğunda değişikliğin iki addan da görülmesi
  • is ile == ayrımı
  • Küçük tam sayı ve string önbelleklemesinden dil kuralı çıkarılamayacağı
  • Nesnenin durumu ve durumun hangi yollarla değiştiği
  • Yerinde değiştirme ile yeniden bağlama ayrımı
  • id() değerinin bellek adresiyle ilişkisi
  • Çöp toplama (garbage collection) ayrıntıları
  • CPython’ın hangi nesneleri yeniden kullandığının ayrıntıları

Bu başlıklar konunun devamıdır. İleride karşınıza çıkar, ama bu derste ezberlemeniz beklenmiyor.

Ad bir nesneye bağlanır

Bir kırtasiyenin stok programını düşünün. Her ürünün adını ve stoğunu tek bir kayıtta tutmak istiyoruz. Bu kaydı 3. haftada gördüğünüz sözlükle tutabilirsiniz:

product = {"name": "Kalem", "stock": 10}

Bu satır önce bir sözlük nesnesi oluşturur, sonra product adını o nesneye bağlar. Değişkeni, içine değer konan bir kutu gibi düşünmek tek bir adla çalışırken işe yarar, ama iki ad aynı nesneyi gösterdiği anda yetmez. Bu derste şu modeli kullanacağız:

Değişken adı bir nesneye bağlanır.

Masada bir karton kutu duruyor, üzerindeki kâğıtta name: Kalem ve stock: 10 yazıyor. Kutuya iki ip bağlı. Bir ipin ucundaki etikette product, ötekinde selected yazıyor.

Kutu nesnedir, adlar ona iple bağlanan etiketlerdir. Aynı nesneye birden çok ad bağlanabilir: product ve selected aynı kalem kaydını gösterir. AI ile üretilmiş görsel.

Model sayılar için de geçerli. 3. haftada gördüğünüz id() bir nesnenin kimlik numarasını döndürüyordu. Değişken bir kutu olsaydı score = 90 atamasından sonra da aynı kutu kalırdı, yalnız içi değişirdi. id(score) ise adın o anda bağlı olduğu nesnenin numarasını verir. Hücrede score adına iki kez değer atanıyor ve her atamadan sonra id(score) yazdırılıyor. İki sayı aynı mı çıkar?

score = 90 satırı 80 nesnesinin içini 90 yapmaz. score adını, değeri 90 olan başka bir nesneye bağlar. Buna yeniden bağlama denir.

İki farklı sayı. Sayılar her çalıştırmada değişebilir, ama ikisi birbirinden hep farklıdır: score adı önce bir nesneyi, sonra başka bir nesneyi gösterdi.

Her nesnenin kimliği, türü ve değeri var

Python’ın resmî belgelerindeki veri modeline (data model) göre her nesnenin bir kimliği (identity), bir türü (type) ve bir değeri (value) vardır. Kimlik nesneyi ötekilerden ayırır ve nesne var olduğu sürece değişmez. Tür, nesneyle hangi işlemleri yapabileceğinizi ve değerinin değişip değişemeyeceğini belirler. Değer nesnenin içeriğidir.

Hücre kalem kaydının kimliğini, türünü ve değerini yazdırıyor. Sonra stoğu 8’e indirip aynı üç bilgiyi yeniden yazdırıyor. İki satır arasında ne değişir?

id(product) kimliği, type(product) türü, product ise değeri gösterir.

Kimlik ve tür iki satırda aynı, yalnız değer değişti. product["stock"] = 8 yeni bir sözlük oluşturmadı, var olan sözlüğün içini değiştirdi.

product adı bir sözlük nesnesini gösteriyor. Stok 10'dan 8'e inince nesnenin kimliği ve türü (dict) aynı kalıyor, yalnız değeri değişiyor.

Satıştan önce ve sonra aynı nesne
Notid() değerini bellek adresi diye ezberlemeyin

Python kodunu yorumlayıcı çalıştırır. Bilgisayarınıza kurduğunuz yorumlayıcının adı CPython’dır. Bu sayfadaki hücreleri çalıştıran Pyodide de tarayıcıda çalışan bir CPython’dır. PyPy ve MicroPython başka Python yorumlayıcılarıdır. CPython’da id() nesnenin bellek adresini verir, ama dil bunu garanti etmez. Biz id() değerini yalnız iki adın aynı nesneyi gösterip göstermediğini görmek için kullanacağız. Bu iş için is daha okunaklıdır. Kimlik numarası yalnız aynı anda var olan nesneleri ayırır: artık kullanılmayan bir nesnenin numarası sonradan başka bir nesneye verilebilir.

İki ad, tek kayıt

Bir kırtasiyenin kasasındaki ekranda Kalem, Stok: 8 yazıyor. Açık kapıdan görünen depoda duvardaki ekranda da aynı yazı var.

Kasadaki ekran ve depodaki ekran aynı ürün kaydını gösteriyor: kasada satılan kalem depoda da eksiliyor. AI ile üretilmiş görsel.

Kasa ekranıyla depo ekranı aynı ürün kaydını kullanmalı: kasada satılan kalem depoda da eksilmeli.

3. haftada = işaretinin kopya almadığını, var olan nesneye bir ad daha bağladığını gördünüz. Buna aynı nesneye referans verme (aliasing) dedik. Bir nesneyi gösteren ada o nesnenin referansı denir: iki ad aynı nesneyi gösteriyorsa nesnenin iki referansı vardır. Sözlük de listeyle aynı davranır. Hücrede depo ekranı kaydı product adıyla, kasa ekranı selected adıyla kullanıyor. Kasa iki kalem satıyor. print(product) ne yazar?

selected = product yeni bir sözlük oluşturmaz. product ve selected aynı sözlüğün iki adıdır, bu yüzden selected ile yapılan değişikliği product ile bakınca da görürüz.

Listenin elemanı da bir referanstır. shelf = [product] yazınca liste sözlüğün kopyasını değil kendisini tutar: shelf[0]["stock"] ile yapılan değişikliği product ile bakınca da görürsünüz. 9. haftada nesneleri listelerde tutarken bu kurala dayanacağız.

ÖnemliSınıflardan oluşturulan nesneler de kopyalanmaz

Gelecek hafta account, customer, order gibi adlar kendi yazdığınız sınıflardan oluşturulan nesneleri gösterecek. other = account satırı da hesabın kopyasını almaz, aynı hesaba bir ad daha bağlar. Hesap bir addan değiştirilirse öteki ad da değişikliği görür.

Aynı kayıt mı, eşit kayıt mı?

İki ürün kaydı için iki ayrı soru sorulabilir: ikisi aynı kayıt mı, yoksa aynı bilgileri taşıyan iki ayrı kayıt mı? Python’da bu iki soru için iki ayrı operatör var. 3. haftada gördüğünüz gibi is iki adın aynı nesneyi gösterip göstermediğini, == iki değerin eşit olup olmadığını sorar.

Hücrede second, first sözlüğünün 3. haftada gördüğümüz .copy() ile alınmış kopyası. third adına ise düz atamayla first veriliyor. Üç satır ne yazar?

İçeriği eşit iki nesne iki ayrı kayıt olabilir. İki adın aynı kaydı gösterip göstermediğini is söyler.

  • first == second → True: iki sözlüğün anahtarları ve değerleri eşit.
  • first is second → False: .copy() yeni bir sözlük oluşturdu.
  • first is third → True: third = first aynı sözlüğe bir ad daha bağladı.

first ve third adları aynı sözlüğü gösteriyor. second, .copy() ile oluşturulan ve içeriği eşit ikinci sözlüğü gösteriyor. is operatörü kimliği, == operatörü değeri soruyor.

Kimlik ve eşitlik

Küçük sayılar ve is

Hücrede aynı değerdeki sayılar ve metinler karşılaştırılıyor: önce 5 ile 5, sonra metinden dönüştürülen iki 1000, en sonda iki "Ada" metni. Beş satır ne yazar?

CPython küçük tam sayılar ve bazı stringler için her seferinde yeni nesne oluşturmaz, var olanı yeniden kullanır. Buna önbellekleme (caching) denir, stringlerde interning adı da kullanılır. Yorumlayıcı bunu hız ve bellek kazanmak için yapar. Program çalışırken birleştirilen part + "a" ise yeni bir string oluşturur. “Aynı değerdeki sayılar ya da metinler aynı nesnedir” diye bir dil kuralı yoktur: CPython, PyPy ya da başka bir yorumlayıcı hangi nesneleri yeniden kullanacağına kendisi karar verir.

True, True, False, True, False. CPython 5’i yeniden kullandı, metinden dönüştürülen iki 1000 için ayrı nesne oluşturdu. İki "Ada" metni eşit, ama ikincisi part + "a" ile oluşturulan ayrı bir nesne.

Hücrede 1000’i metinden dönüştürmemizin de bir nedeni var. x = 1000 ve y = 1000 yazarsanız CPython aynı hücredeki aynı sabiti bir kez oluşturabilir ve x is y True verir. Bu da yorumlayıcının tercihidir. Dilin kuralı daha gevşek: değiştirilemez türlerde Python aynı değer için var olan bir nesneyi yeniden kullanabilir, değiştirilebilir türlerde kullanamaz. Bu yüzden iki ayrı [] her zaman iki ayrı listedir.

ÖnemliSayıları ve metinleri == ile karşılaştırın

Bir is deneyinde True görmeniz, başka bir sayıda ya da başka bir yorumlayıcıda da True göreceğiniz anlamına gelmez. Değer sorusunu == ile sorun. CPython da score is 100 gibi bir satırda SyntaxWarning uyarısı verir ve == yazmak isteyip istemediğinizi sorar. is en sık value is None biçiminde, bir değerin None olup olmadığını denetlemek için kullanılır. Programda tek bir None nesnesi olduğu için bu soru kimlikle sorulur.

Yerinde değiştirme ve yeniden bağlama

Atamada = işaretinin soluna bakın. Solda yalnız bir ad varsa (selected = ...) ad yeniden bağlanır, hiçbir nesne değişmez. Solda bir sözlüğün elemanı varsa (selected["stock"] = 0) adın gösterdiği sözlük yerinde değişir: aynı nesnenin içeriği değişir ve o sözlüğü gösteren bütün adlar değişikliği görür.

Hücrede kasa önce kalemin stoğunu sıfırlıyor, sonra selected adına yeni bir sözlük veriyor. İki satır ne yazar?

{'name': 'Kalem', 'stock': 0} ve {'name': 'Silgi', 'stock': 4}. selected["stock"] = 0 ortak sözlüğü yerinde değiştirdi, bu yüzden product ile bakınca da stok 0. selected = {...} yalnız selected adını yeni bir sözlüğe bağladı, product eski sözlüğü göstermeye devam ediyor.

selected = {"name": "Silgi", "stock": 4} satırı kalem kaydının içini silip yerine Silgi’nin bilgilerini yazmaz. Python’da = bir nesnenin üzerine başka bir nesneyi hiçbir zaman kopyalamaz, yalnız soldaki adı ya da elemanı yeni nesneye bağlar.

Stok sayısının kendisi bir int. 3. haftadan hatırlayın: list, dict ve set değiştirilebilir (mutable), int, float, bool, str ve tuple değiştirilemez (immutable) türlerdir. selected["stock"] -= 2 satırı da bir int nesnesinin içini değiştirmez. Çıkarma, değeri 8 olan yeni bir int verir, atama da bu sayıyı sözlüğün "stock" anahtarına bağlar. Değişen sözlüktür, eski sayı olduğu gibi kalır.

Tür, bir nesneyle hangi işin yapılabileceğini de belirler. int nesnesinin içini değiştiren bir işlem olmadığı için int gösteren bir adla yalnız yeniden bağlama yapılabilir. Listeyi ise yerinde değiştirebilir, onu gösteren adı da başka bir listeye bağlayabilirsiniz. 4. haftada gördüğünüz gibi aynı += yazımı listeyi yerinde uzatır, int’te adı yeniden bağlar.

Gelecek hafta yazacağınız account.balance = 0 satırı da sözlük elemanına atama gibi çalışır: account adını değil, hesap nesnesinin içini değiştirir.

Fonksiyon kaydın kopyasını değil kendisini alır

Satış fonksiyonu stoğu azaltınca bu değişiklik çağıran koddaki kayda da yansımalı. 4. haftada parametre adının, çağıranın verdiği nesneye bağlandığını gördünüz.

Hücredeki sell fonksiyonu sözlüğü parametre olarak alıyor. Fonksiyonun içindeki ad product, dışarıdaki ad pencil. Son satır ne yazar?

Çağrıda product parametresi pencil adının gösterdiği sözlüğe bağlanır, Python sözlüğü kopyalamaz. Fonksiyonun sözlükte yaptığı değişikliği çağıran kod da görür. return da böyle çalışır: fonksiyon bir sözlüğü döndürdüğünde çağırana kopyasını değil kendisini verir.

Parametreye yeni değer atamak çağıranın adını değiştirmez

4. haftadaki add_one deneyinde int parametreye yeni değer atamıştık ve dışarıdaki sayı değişmemişti. Bu kez sözlük parametresine yeni bir sözlük atayalım. Son satır ne yazar?

{'name': 'Kalem', 'stock': 10}. reset içindeki atama yalnız yerel product adını yeni sözlüğe bağladı. pencil eski sözlüğü göstermeye devam ediyor.

İki fonksiyon az önceki kurala uyuyor. sell sözlüğü yerinde değiştirdi: = işaretinin solunda sözlüğün elemanı var. reset ise adı yeniden bağladı: solda yalnız yerel ad var. Parametre de bir addır. Çağrıda çağıranın adıyla aynı nesneye bağlanır, ama çağıranın adının kendisi değildir.

Nesnenin durumu

OOP’de bir nesnenin o anki verisine onun durumu (state) deriz. Değiştirilebilir bir nesnenin durumu program çalışırken değişebilir.

{"name": "Kalem", "stock": 8} sözlüğünde stock değeri durumun bir parçasıdır. Stok 8’den 7’ye inerse nesnenin durumu değişir, kimliği ve türü aynı kalır. Stok 0 olunca satış yapılmamalı: durum, nesneyle neyin yapılabileceğini belirler.

Not“Değer” ve “durum”

Python belgeleri nesnenin içeriğine değer der. OOP’de nesneyi tasarlarken aynı veriye durum deriz ve onu kurallara bağlarız: bir banka hesabının bakiyesi onun durumudur, bakiye yetmiyorsa para çekilmemeli.

Stok örneğinde stock değerini yalnız satış fonksiyonu değiştirmeli. Oysa programın herhangi bir yeri product["stock"] = -100 yazabilir. OOP’de bir nesnenin durumunu hangi kodun, hangi kurala uyarak değiştirebileceğine biz karar veririz.

Davranışı veriyle birlikte tutmak

Az önceki sell fonksiyonuyla, stokta iki kalem varken beş kalem satalım. Son satır ne yazar?

Program hata vermeden çalışır. “Stok eksiye düşemez” kuralını denetleyen tek bir satır bile yok.

5. haftada gördüğümüz raise ile fonksiyona bir denetim ekleyelim. Hücre ne yazar? Satış reddedilirse stok değişir mi?

Denetim, stoğu değiştiren satırdan önce çalışır. Satış reddedilince stok olduğu gibi kalır.

Bu küçük örnekte kural sell fonksiyonunun içinde duruyor. Ama program büyüdükçe product sözlüğünde hangi anahtarların bulunması gerektiğini ve sözlüğü hangi fonksiyonların değiştirdiğini izlemek zorlaşır. Başka bir dosyadaki bir fonksiyon product["stock"] değerini hiç denetlemeden değiştirebilir.

Nesnenin verisi onun durumudur. Bu veriyi okuyan ve değiştiren fonksiyonlar da nesnenin davranışıdır. Gelecek hafta göreceğimiz sınıf (class), durumu ve davranışı tek bir ad altında, aynı yapıda toplar. Böylece kuralı denetleyen kod tek bir yerde durur.

Bu haftanın işleri yan yana

Bu haftaki işler ve Python’da nasıl yapıldıkları:

İş Python’da Dikkat
Ürünün adını ve stoğunu tek kayıtta tutmak product = {"name": "Kalem", "stock": 10}: product adı bir sözlük nesnesine bağlanır Ada yeni değer atamak nesneyi değiştirmez, adı başka bir nesneye bağlar
Kasa ve depo ekranının aynı kaydı kullanması selected = product = hiçbir türde kopya almaz. Ayrı bir kayıt için sözlüğü .copy() ile kopyalayın. .copy() sığ kopyadır: içteki liste ya da sözlük iki kopyada ortak kalır
İki kaydın aynı kayıt mı, eşit kayıt mı olduğunu anlamak is kimliği, == değeri sorar Sayıları ve metinleri is ile karşılaştırmayın
Kaydın alanını değiştirmek ya da başka kaydı göstermek selected["stock"] = 0 ve selected = {"name": "Silgi", "stock": 4} Solda eleman varsa nesne yerinde değişir, yalnız ad varsa ad yeniden bağlanır
Çağıranın kaydındaki stoğu azaltan satış fonksiyonu sell(product, 2): parametre aynı sözlüğe bağlanır Parametreye yeni değer atamak çağıranın adını değiştirmez
Stoğun eksiye düşmesini önlemek sell içinde if ile denetleyip raise ValueError Kodun başka bir yeri yine product["stock"] = -100 yazabilir

selected = product satırı kasaya ve depoya aynı kaydı verir, çünkü = kopya almaz. Satış fonksiyonu çağıranın sözlüğünü değiştirebilir, çünkü parametre verilen nesneye bağlanır. Eksi stok kuralı ise yarım kalıyor: sell stoğu denetliyor, ama kayıt programın her yerinden değiştirilebilir. Gelecek hafta veriyi ve onu değiştiren fonksiyonları bir sınıfta toplayacağız. Sınıf da account.balance = -100 gibi bir atamayı kendiliğinden engellemez. 8. haftada bu doğrudan atamayı da kurala bağlayacağız.

Alıştırma: Yerinde mi, yeniden bağlama mı?

Hücre dört satır yazdırıyor. Önce dört satırı tahmin edin, sonra çalıştırın.

Hangi satır listeyi yerinde değiştirdi, hangisi bir adı yeniden bağladı? Hangi adlardan bakınca aynı listeyi görüyorsunuz? Ardından aynı denemeyi bir tam sayıyla yapın: n = 1, m = n ve m += 1 satırlarından sonra print(n, m) ne yazar?

b += [3] listeyi yerinde uzatır: a ve b aynı listeyi gösterir, ikisi de [1, 2, 3] yazar. c + [4] yeni bir liste oluşturur ve c = ... ataması c adını ona bağlar: c [1, 2, 3, 4] yazar, a değişmez. Son satır True False yazar.

Tam sayı denemesi 1 2 yazar. int değiştirilemediği için m += 1 yeni bir sayı oluşturur ve yalnız m adını ona bağlar.

Alıştırma: Referans diyagramı

first = {"balance": 100}
second = first
third = {"balance": 100}

Üç değişken adını ve kaç ayrı sözlük nesnesi olduğunu gösteren bir diyagram çizin. Ardından second["balance"] += 50 satırından sonra hangi adlarla bakınca 150 görüleceğini açıklayın. Son olarak second = {"balance": 0} satırı çalışınca diyagramda hangi okun değiştiğini gösterin.

İki sözlük nesnesi var. first ve second aynı sözlüğü, third ise içeriği eşit ikinci sözlüğü gösterir. second["balance"] += 50 ortak sözlüğü yerinde değiştirir: first ve second ile bakınca 150, third ile bakınca 100 görülür.

second = {"balance": 0} üçüncü bir sözlük oluşturur ve yalnız second okunu ona taşır. first 150’lik sözlüğü göstermeye devam eder, third değişmez.

Alıştırma: Geçersiz durumu engelle

Boşluğun yerine iki satır yazın: bakiye çekilmek istenen tutara yetmiyorsa fonksiyon ValueError yükseltsin. Denetim bakiyeyi azaltan satırdan önce gelmeli: işlem reddedilirse bakiye değişmemeli. Bakiyenin tamamı çekilebilmeli. Run Code sonucu denetler.

if amount > account["balance"]:
    raise ValueError("Yetersiz bakiye")

Sıra sizde: Prosedürel hesap

account = {
    "owner": "Ada",
    "balance": 500,
}

Veriyi bir sözlükte, işlemleri ayrı fonksiyonlarda tutan bu yaklaşıma prosedürel yaklaşım denir. Programı VS Code’da hesap.py adlı bir dosyaya yazıp çalıştırın. Para çekme fonksiyonunu alıştırmadaki gibi yazın, para yatırma ve bakiye sorgulama fonksiyonlarını ekleyin. Yatırılan ve çekilen tutar pozitif olmalı, çekilen tutar bakiyeyi aşmamalı. Bu kurallar bozulursa ValueError yükseltin. Bakiye sorgulama fonksiyonu bakiyeyi döndürsün, sözlüğü değiştirmesin.

Çalışır kod görevi: Başlangıç bakiyesi 500. Önce 100 çekip bakiyenin 400 olduğunu denetleyin. Sonra yetersiz bakiye ve negatif tutarla deneyin: iki işlem de ValueError yükseltmeli, bakiye 400 kalmalı. Bakiyeyi en az üç assert ile denetleyin. 5. haftadaki gibi assert satırı, koşul yanlışsa AssertionError yükseltir: assert account["balance"] == 400. Reddedilen bir işlemi try içinde çağırın, yoksa program assert satırına gelmeden durur. else bloğu hata yükselmezse çalışır ve işlemin reddedilmediğini bildirir:

try:
    withdraw(account, 1000)
except ValueError:
    pass
else:
    raise AssertionError("Yetersiz bakiyede ValueError bekleniyordu")
assert account["balance"] == 400

Gelecek hafta bu üç fonksiyonu ve hesabın verisini BankAccount sınıfında birleştireceğiz.

Sınav provası

Önce kendi cevabınızı seçin; sonra cevap anahtarında her şıkkın neden doğru veya yanlış olduğunu okuyun. Çeldiriciler uydurma değil, bu konuda gerçekten yapılan hatalardır. Sınav soruları da bu mantıkla yazılır.

1. score = 80 ve ardından score = 90 yazıldığında ne olur?

  • A. score adlı kutudaki 80 silinir, yerine 90 yazılır
  • B. İki ayrı score değişkeni oluşur
  • C. Hata verir; bir ada iki kez atama yapılamaz
  • D. score adı başka bir nesneye yeniden bağlanır
  • E. 80 değeri bellekten hemen silinir ve score geçersiz olur

2. Python veri modelinde her nesnenin sahip olduğu üç özellik nedir?

  • A. Durum, davranış ve sorumluluk
  • B. Ad, tür ve değer
  • C. Değer, kopya ve referans
  • D. Ad, adres ve boyut
  • E. Kimlik, tür ve değer

3. product = {"name": "Kalem", "stock": 10} iken product["stock"] = 8 satırı çalışıyor. Sözlük nesnesinin hangi özelliği değişir?

  • A. Üçü de; Python sözlüğün yeni bir kopyasını oluşturur
  • B. Yalnız kimliği; içeriği değişen nesne yeni bir nesne olur
  • C. Yalnız değeri; kimliği ve türü aynı kalır
  • D. Hiçbiri; satır TypeError verir, sözlük değiştirilemez
  • E. Değeri ve türü; stock anahtarının değeri değişti

4. Aşağıdaki program ne yazdırır?

def find(products, name):
    for product in products:
        if product["name"] == name:
            return product

catalog = [{"name": "Kalem", "stock": 10}, {"name": "Silgi", "stock": 4}]
item = find(catalog, "Silgi")
item["stock"] = 0

print(catalog[1]["stock"])
print(item is catalog[1])
  • A. 0 ve True
  • B. Hata verir; fonksiyonun döndürdüğü sözlük değiştirilemez
  • C. 4 ve False
  • D. 4 ve True
  • E. 0 ve False

5. Aşağıdaki program ne yazdırır?

cart = [{"code": "K1"}, {"code": "S2"}]
wanted = {"code": "S2"}

found = False
for item in cart:
    if item is wanted:
        found = True

print(found)
print(wanted == cart[1])
  • A. True ve False
  • B. False ve True
  • C. False ve False
  • D. Hata verir; sözlükler is ile karşılaştırılamaz
  • E. True ve True

6. is operatörünün önerilen kullanımı hangisidir?

  • A. items is [] biçiminde boşluk denetimi
  • B. first is second biçiminde iki listenin içerik karşılaştırması
  • C. value is None biçiminde None denetimi
  • D. score is 100 biçiminde sayı karşılaştırması
  • E. name is "Ada" biçiminde metin karşılaştırması

7. a = 5 ve b = 5 iken bir öğrencinin denemesinde a is b True veriyor. Bu sonuçla ilgili hangisi doğrudur?

  • A. a ile b artık tek bir değişkendir
  • B. Bu yorumlayıcının bir tercihidir, dil kuralı değildir
  • C. is operatörü sayılarda == ile aynı işi yapar
  • D. Küçük sayılarda == kullanmak hatalıdır
  • E. Python’da aynı değerdeki sayılar her zaman aynı nesnedir

8. Bu programda bakiye eksiye düşmemeli. Program bu kurala neden uymaz?

account = {"owner": "Ada", "balance": 30}

def withdraw(account, amount):
    account["balance"] -= amount

withdraw(account, 50)
print(account)
  • A. Bakiye hata vermeden -20 olur
  • B. Parametre adı dıştaki account ile aynı olduğu için çakışma olur
  • C. Python bakiyenin eksiye düşmesine izin vermez, ValueError yükseltir
  • D. withdraw fonksiyonu sözlüğü değiştiremez; değişiklik kaybolur
  • E. KeyError yükselir

9. Aşağıdaki programın son üç satırından hangileri product adının gösterdiği sözlüğün durumunu değiştirir?

product = {"name": "Kalem", "stock": 10}
shelf = [product]
alias = product

def sell(item, amount):
    item["stock"] -= amount

sell(alias, 2)
shelf[0]["stock"] += 5
alias = {"name": "Kalem", "stock": 0}
  • A. Üç satırın üçü de
  • B. Yalnız sell(alias, 2)
  • C. Hiçbiri; bu satırlarda product adı geçmiyor
  • D. sell(alias, 2) ve shelf[0]["stock"] += 5
  • E. Yalnız alias = {"name": "Kalem", "stock": 0}

10. Aşağıdaki iki program neden farklı davranır?

# A
def add_tag(tags):
    tags.append("oop")

labels = ["python"]
add_tag(labels)
print(labels)

# B
def add_tag(tags):
    tags = tags + ["oop"]

labels = ["python"]
add_tag(labels)
print(labels)
  • A. A’da liste referansla, B’de kopyalanarak geçirildiği için
  • B. A’da append yeni bir liste oluşturup labels adına bağlar
  • C. A’daki labels global olduğu için fonksiyon onu değiştirebilir
  • D. B’de fonksiyon return içermediği için değişiklik kaybolur
  • E. A listeyi yerinde değiştirir, B yerel adı yeniden bağlar

1. Doğru: D. Atama bir kutunun içeriğini değiştirmez; adın hangi nesneyi gösterdiğini değiştirir. İlk nesnenin içi değiştirilmez.

  • A yanlış: Değişkeni içine değer konan bir kutu gibi düşünmek akla yatkındır. Ama kutu modeli burada yanıltır; int nesneleri değiştirilemez ve içleri güncellenmez.
  • B yanlış: İki atama iki ayrı nesneyle çalıştığı için iki değişken varmış gibi görünür. Oysa tek bir ad vardır; yalnız bağlandığı nesne değişir.
  • C yanlış: Bir adın bir kez bağlandıktan sonra sabit kaldığı düşünülebilir. Oysa yeniden atama geçerli ve olağandır.
  • E yanlış: Eski değer artık kullanılmadığı için hemen silindiği sanılabilir. Ama score adı 90 nesnesini gösterir ve geçerlidir. Eski nesneye ne olacağı çöp toplamanın işidir.

2. Doğru: E. Tür, nesneyle yapılabilecek işlemleri ve değerin değişip değişemeyeceğini belirler; kimlik nesneyi ötekilerden ayırır.

  • A yanlış: Bu terimler OOP’de nesneden söz ederken geçtiği için akla gelebilir. Ama bunlar nesne tasarlarken kullanılan terimlerdir; veri modelinin her nesne için saydığı özellikler değildir.
  • B yanlış: Nesne kodda hep bir adla birlikte göründüğü için ad da nesnenin bir özelliği sanılabilir. Ama ad nesneye yalnız bağlanır: aynı nesnenin birden çok adı olabilir, listedeki bir nesnenin hiç adı olmayabilir.
  • C yanlış: Kopya ve referans bu bölümde nesneyle birlikte sık geçtiği için özellik sanılabilir. Ama bunlar nesneyle yapılan işleri ve nesneye ulaşma yolunu anlatır; nesnenin özellikleri değildir.
  • D yanlış: Bellekte yer kaplayan her şeyin bir adresi ve boyutu olduğu için bu üçlü akla yatar. Ama dil adres ve boyutu her nesnenin özelliği olarak tanımlamaz; ad da nesnenin parçası değildir, yalnızca nesneye bağlanır.

3. Doğru: C. Atama var olan sözlüğün içini değiştirir, yeni bir sözlük oluşturmaz. Kimlik nesne var olduğu sürece aynı kalır, tür de dict olarak kalır. Değişen yalnız içeriktir.

  • A yanlış: Değiştirilemez türlerde her işlem yeni bir nesne verdiği için sözlükte de böyle olduğu sanılabilir. Ama dict değiştirilebilir bir türdür, Python kopya oluşturmaz.
  • B yanlış: score = 90 gibi atamalarda ad yeni bir nesneye bağlandığı için burada da yeni nesne oluştuğu sanılabilir. Ama solda bir ad değil sözlüğün elemanı var; aynı sözlük yerinde değişir.
  • D yanlış: Demetin elemanına atama yapılamadığı için sözlükte de yapılamayacağı sanılabilir. Ama dict değiştirilebilir bir türdür, anahtara yeni değer atanabilir.
  • E yanlış: Anahtarın değeri değişince nesnenin türünün de etkilendiği düşünülebilir. Ama sözlük dict olarak kalır; değerin değişmesi türü değiştirmez.

4. Doğru: A. return product listedeki sözlüğün kopyasını değil kendisini döndürür. item ve catalog[1] aynı sözlüğü gösterir; item ile yapılan değişiklik listeden bakınca da görülür.

  • B yanlış: Fonksiyondan dönen değerin salt okunur olduğu sanılabilir. Python’da böyle bir kısıt yoktur; dönen sözlük her sözlük gibi değiştirilebilir.
  • C yanlış: Fonksiyonun bulduğu kaydın bir kopyasını döndürdüğü düşünülebilir. Ama return kopya almaz; çağırana aynı nesneye giden bir referans verir.
  • D yanlış: İki adın aynı sözlüğü gösterdiği doğru. Ama aynı sözlük değiştirildiği için listeden bakınca da yeni değer 0 görünür.
  • E yanlış: Stoğun 0 olduğu doğru. Ama değişikliğin listeden görülmesi, item ile catalog[1]’in aynı sözlük olmasından gelir. Bu yüzden is de True verir.

5. Doğru: B. wanted ayrı yazılmış yeni bir sözlüktür; içeriği cart[1] ile eşittir ama aynı nesne değildir. is kimliği sorduğu için döngü eşleşme bulmaz. İçerik karşılaştırması için item == wanted yazılmalıdır.

  • A yanlış: is içeriğe, == kimliğe bakıyormuş gibi düşünülürse bu sonuç çıkar. Oysa is aynı nesne mi diye, == eşit değerli mi diye sorar.
  • C yanlış: Döngünün eşleşme bulamaması iki sözlüğün eşit olmadığını düşündürebilir. Ama == anahtarları ve değerleri karşılaştırır; ikisi de aynı olduğu için True verir.
  • D yanlış: is çoğunlukla None ile kullanıldığı için başka değerlerle hata vereceği sanılabilir. is her nesneyle çalışır; burada yalnız yanlış soruyu sorar.
  • E yanlış: İçerikleri aynı olan iki sözlüğün is ile de eşleşeceği sanılabilir. Ama is içeriğe değil kimliğe bakar; wanted listedeki sözlüklerden hiçbiri değildir.

6. Doğru: C. Programda tek bir None nesnesi vardır; bu yüzden bir değerin None olup olmadığı kimlikle sorulur.

  • A yanlış: is sözcüğü “… mı?” diye okunduğu için “liste boş mu?” sorusu gibi görünebilir. Ama her [] yeni bir liste oluşturur; bu karşılaştırma hep False verir.
  • B yanlış: is sözcüğü “eşit mi?” diye okunduğu için içerik karşılaştırması sanılabilir. Ama is iki adın aynı nesneyi gösterip göstermediğini sorar; içeriği eşit iki ayrı liste için False verir. İçerik == ile karşılaştırılır.
  • D yanlış: Küçük sayılar CPython’da yeniden kullanıldığı için score is 100 bazen True verir ve doğru sanılabilir. Ama sonuç yorumlayıcıya bağlıdır; CPython da bu satırda SyntaxWarning verir. Sayı eşitliği için == kullanılır.
  • E yanlış: Kısa metinler CPython’da yeniden kullanıldığı için bu karşılaştırma bazen True verir ve doğru sanılabilir. Ama sonuç yorumlayıcıya bağlıdır. Metin eşitliği için == kullanılır.

7. Doğru: B. CPython küçük tam sayıları yeniden kullanır. Dil bunu zorunlu tutmaz, başka bir yorumlayıcı farklı davranabilir. Değer sorusu için == kullanılmalıdır.

  • A yanlış: İki adın aynı nesneyi göstermesi, adların birleştiği izlenimini verir. Ama a ve b iki ayrı addır. b = 6 yazılırsa a yine 5’i gösterir.
  • C yanlış: İki operatör burada aynı sonucu verdiği için aynı işi yapıyormuş gibi görünür. Ama farklı sorulardır; sonuçların rastlantısal olarak örtüşmesi bunu değiştirmez.
  • D yanlış: is daha kesin bir karşılaştırma gibi göründüğü için tercih edilesi sanılabilir. Ama değerlerin eşitliği == ile denetlenir.
  • E yanlış: Deneyde True görüldüğü için sonucu her sayıya genellemek kolaydır. Ama int("1000") ile oluşturulan iki değer aynı nesne olmayabilir.

8. Doğru: A. Program hata vermeden çalışır ve {'owner': 'Ada', 'balance': -20} yazdırır. Eksik olan, bakiyenin eksiye düşmesini engelleyen bir denetimdir.

  • B yanlış: Aynı adın iki yerde geçmesi bir çakışma gibi görünür. Ama parametre fonksiyonun yerel adıdır ve çağrıda aynı sözlüğe bağlanır; hata çıkmaz.
  • C yanlış: Bakiye eksiye düşmemesi gerektiği için Python’ın bunu kendisi engelleyeceği sanılabilir. Ama Python sözlükteki değerin anlamını bilmez. Kuralı denetleyen satırı siz yazmazsanız bakiye -20 olur.
  • D yanlış: Fonksiyonun sözlüğün kopyasını aldığı düşünülürse değişikliğin kaybolacağı sanılabilir. Ama fonksiyon aynı sözlük nesnesini değiştirir ve değişiklik çağıran taraftan da görülür.
  • E yanlış: Fonksiyon dışarıdaki sözlüğün anahtarlarını göremezmiş gibi düşünülebilir. Ama parametre aynı sözlüğe bağlanır ve sözlükte balance anahtarı var.

9. Doğru: D. alias, shelf[0] ve product aynı sözlüğü gösterir. sell bu sözlüğün stock değerini 8 yapar, += 5 aynı değeri 13 yapar. Son satır yalnız alias adını yeni bir sözlüğe bağlar, product eski sözlüğü göstermeye devam eder.

  • A yanlış: Üç satırda da product ile aynı sözlüğü gösteren adlar geçtiği için hepsinin sözlüğü değiştirdiği sanılabilir. Ama son satır yalnız alias adını yeniden bağlar.
  • B yanlış: Listeye konan sözlüğün kopyalandığı sanılabilir. Ama [product] listesi aynı sözlüğü taşır. shelf[0] ile yapılan artış da product ile bakınca görülür.
  • C yanlış: Değişikliğin yalnız product adıyla yapılabileceği sanılabilir. Ama alias ve shelf[0] aynı sözlüğün referanslarıdır; onlarla yapılan değişikliği product da görür.
  • E yanlış: alias önceden product ile aynı sözlüğü gösterdiği için son atamanın o sözlüğü değiştireceği sanılabilir. Ama solda yalnız ad var; atama alias adını yeni bir sözlüğe bağlar, ortak sözlüğe dokunmaz.

10. Doğru: E. İki programda da tags çağıranın listesine bağlanır. A’daki append bu listeyi yerinde değiştirir; değişiklik labels adından da görülür. B’deki tags + ["oop"] yeni bir liste oluşturur ve atama yalnız fonksiyonun kendi tags adını ona bağlar. A ['python', 'oop'], B ['python'] yazdırır.

  • A yanlış: İki fonksiyon farklı sonuç verdiği için listelerin farklı yollarla geçirildiği sanılabilir. Ama iki çağrı da aynı biçimde yapılır ve argüman olarak aynı türde bir liste verilir; fark fonksiyonun içinde yapılan işlemdedir.
  • B yanlış: tags + [...] yeni bir liste verdiği için append()’in de yeni liste oluşturduğu sanılabilir. Ama append() var olan listeyi değiştirir ve None döndürür. labels baştan beri aynı listeyi gösterir.
  • C yanlış: labels modül düzeyinde tanımlandığı için fonksiyonun onu bu yüzden değiştirebildiği sanılabilir. Ama fonksiyon listeye tags parametresiyle ulaşır ve append() aynı listeyi değiştirir. B’deki labels da modül düzeyindedir, ama değişmez.
  • D yanlış: Fonksiyonun sonucu çağırana yalnız return ile ulaşır sanılabilir. Ama A’da da return yoktur ve değişiklik görülür. B’de return olsa bile dönen liste labels adına atanmadıkça çağıranın listesi değişmezdi.

Tek sayfa özet

  • Python’da her değer bir nesnedir. Değişken adı nesne değildir, bir nesneye bağlanır.
  • Python veri modelinde her nesnenin kimliği, türü ve değeri vardır. Nesnenin içi değişse de kimliği ve türü aynı kalır.
  • b = a kopya almaz. İki ad aynı nesneyi gösterir ve bir addan yapılan değişikliği öteki de görür. Nesneyi gösteren her ad ya da liste elemanı o nesnenin bir referansıdır.
  • == eşitlik, is kimlik sorusudur. Eşit içerikli iki nesne iki ayrı nesne olabilir.
  • Küçük tam sayı ve string önbelleklemesi yorumlayıcının tercihidir. Değer karşılaştırmasını == ile yapın, is’i None denetimi gibi kimlik soruları için kullanın.
  • = işaretinin solunda yalnız ad varsa ad yeniden bağlanır, hiçbir nesne değişmez. Solda product["stock"] gibi bir eleman varsa nesne yerinde değişir.
  • Fonksiyon çağrılınca parametre adı verilen nesneye bağlanır. Fonksiyon nesneyi yerinde değiştirirse çağıran da görür, parametreyi yeniden bağlarsa çağıranın adı değişmez. Değiştirilemez bir nesneyi (int, str) gösteren parametreyle yalnız yeniden bağlama yapılabilir.
  • OOP’de nesnenin o anki verisine durum deriz. Nesnenin verisini okuyan ve değiştiren fonksiyonlar onun davranışıdır.
  • Sözlükteki veriyi programın her yeri değiştirebilir. Veriyi ve onu kurallara uyarak değiştiren fonksiyonları bir sınıfta toplarsak kuralı denetleyen kod tek yerde durur.

Bu bölümün kazanımları

Bu bölümü bitiren öğrenci:

  • Değişken adının bir nesneye bağlandığını, kutu olmadığını açıklar.
  • Bir nesnenin kimlik, tür ve değer özelliklerini ayırt eder.
  • Aynı nesneye iki referans olduğunda bir addan yapılan değişikliğin ötekinden görüldüğünü gösterir.
  • is ile == sorularını ayırt eder ve is operatörünü yalnızca kimlik sorusu için kullanır.
  • Küçük tam sayı ve string önbelleklemesinden dil kuralı çıkarılamayacağını açıklar.
  • Nesnenin durumunu tanımlar ve programda durumu değiştiren satırları bulur.
  • Bir nesneyi yerinde değiştirmek ile bir adı başka bir nesneye yeniden bağlamak arasındaki farkı açıklar.
Başa dön