Sözlükler, kümeler ve koleksiyon seçimi

Listelerde bir değere erişmek için çoğunlukla indeks kullanırız. Oysa bir üründen söz ederken “0. eleman” ya da “2. eleman” demeyiz; adını, fiyatını, stok miktarını söyleriz. Öğrencide de öyle: adı, öğrenci numarası.

Bu hafta iki yeni koleksiyon öğreneceğiz. Sözlük (dictionary, dict) her değeri bir adla tutar; bu ada anahtar denir. "fiyat" anahtarının değeri 12.5 olabilir. Küme (set, set) ise her değeri yalnızca bir kez tutar. Bölümün sonunda da “bu iş için liste mi, sözlük mü, küme mi?” sorusunu cevaplamayı öğreneceğiz.

Bu bölümün kapsamı

Sınavda sorulur

Anahtar–değer modeliyle okuma ve alan güncelleme
in denetiminin anahtarı araması
get() ile varsayılan kullanmanın yararı ve bedeli
.keys(), .values() ve .items() farkı
Sözlük anahtarının değişmez olma zorunluluğu
Sözlükle frekans veya sayaç tablosu kurma
Kümenin benzersizlik ve sıra davranışı, koleksiyon seçimi

Sınav dışı (bilgi amaçlı)

collections modülündeki hazır sayaç yapıları
Küme kesişim, birleşim ve fark işlemlerinin ayrıntısı

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

`"Kalem" in urun` neden `False` döndürüyor?

Kısa cevap: sözlükte in değerlere değil anahtarlara bakar ve "Kalem" bir anahtar değil, değerdir. Bu farkı görmek için önce sözlüğün nasıl yazıldığına bakalım.

Sözlük: anahtardan değere erişim

Sözlükte köşeli parantez ile anahtar erişimi ve get() metodunun eksik anahtardaki farklı davranışı. — Sözlükte anahtar erişimi ve get

Bir ürünün bilgilerini listede şöyle tutabiliriz:

urun = ["Kalem", 12.5, 40]

Ama urun[1] yazınca bunun fiyat olduğunu anlamak için listenin hangi sırayla kurulduğunu bilmeniz gerekir.

Sözlükte ise her bilgiye bir ad veririz:

urun = {
    "ad": "Kalem",
    "fiyat": 12.5,
    "stok": 40
}

Değerlere anahtar ile erişiriz:

print(urun["ad"])
print(urun["fiyat"])
print(urun["stok"])

Burada "ad", "fiyat" ve "stok" anahtarlardır.

Anahtar–değer ilişkisi

Sözlükte her anahtar bir değeri gösterir:

"ad"    → "Kalem"
"fiyat" → 12.5
"stok"  → 40

Bir sözlükte aynı anahtar iki kez bulunamaz. Var olan bir anahtara yeniden değer atarsanız eski değerin yerine yenisi geçer.

urun = {"stok": 40}
urun["stok"] = 35

print(urun)

Sonuç:

{'stok': 35}

Olmayan bir anahtara değer atarsanız sözlüğe yeni bir alan eklenir:

urun["kategori"] = "Kırtasiye"

Sözlükte `in` anahtarı kontrol eder

Sözlükte in kullandığınızda Python yalnızca anahtarlara bakar:

urun = {"ad": "Kalem", "stok": 40}

print("stok" in urun)       # True
print("fiyat" in urun)      # False
print("Kalem" in urun)      # False

Son satırda "Kalem" bir değerdir, anahtar değildir. Değerlerde aramak istiyorsanız bunu .values() ile açıkça belirtin:

print("Kalem" in urun.values())

Anahtara bakan in, bir alanın eksik olup olmadığını denetlemek için kullanışlıdır:

if "stok" in urun:
    print("Stok bilgisi var")
else:
    print("Stok bilgisi eksik")

Tahmin et: sözlük nasıl değişir?

Aşağıdaki kodu çalıştırmadan önce çıktıyı tahmin edin:

ogrenci["puan"] = 82 satırını okuyan herkes puanın değiştiğini anlar. Listede ogrenci[1] = 82 yazsaydık bunu anlamak için listenin sırasını hatırlamak gerekirdi.

Alıştırma: stok değerini güncelleyin

Mağazada 3 defter satıldı. Stoktaki sayıyı 3 azaltın.

Beklenen sonuç 9’dur.

Eksik anahtar ve `get()`

Sözlükte olmayan bir anahtara köşeli parantezle erişmek KeyError hatası verir:

urun = {"ad": "Kalem"}
# print(urun["stok"])

Alanın eksik olması beklenen bir durumsa get() kullanılabilir:

urun = {"ad": "Kalem"}

stok = urun.get("stok")
print(stok)

Sonuç None olur.

get()e ikinci argüman olarak bir varsayılan değer de verebiliriz. Anahtar yoksa bu değer döner:

stok = urun.get("stok", 0)
print(stok)

Bu kez sonuç 0 olur.

Warning

get("stok", 0) her problemde doğru sonuç vermez. Stok bilgisi girilmemiş bir ürünün stoğu gerçekten 0 mıdır? Bunu problemin kuralı belirler. “Stok bilgisi girilmemiş” ile “stokta ürün kalmamış” farklı durumlardır.

Sözlük üzerinde gezinmek: `keys()`, `values()`, `items()`

Bir sözlükten anahtarları, değerleri ya da ikisini birlikte alabilirsiniz:

urun = {"ad": "Kalem", "fiyat": 12.5, "stok": 40}

print(urun.keys())
print(urun.values())
print(urun.items())

.keys() → anahtarları,
.values() → değerleri,
.items() → (anahtar, deger) çiftlerini

verir.

Yalnızca anahtarlar üzerinde dolaşmak için şu iki yazım aynı işi görür:

for anahtar in urun:
    print(anahtar)

for anahtar in urun.keys():
    print(anahtar)

Yalnızca değerleri istiyorsak:

for deger in urun.values():
    print(deger)

Anahtar ve değeri birlikte almak için:

for anahtar, deger in urun.items():
    print(anahtar, deger)

items() her adımda (anahtar, deger) biçiminde iki elemanlı bir demet verir. for anahtar, deger in ... yazınca bu demeti, 9. haftada gördüğümüz gibi iki değişkene açmış oluruz.

Sözlükten alan silmek

Bir anahtarı değeriyle birlikte silmek için pop() kullanılır:

urun = {"ad": "Kalem", "stok": 40, "gecici_not": "kontrol"}

silinen = urun.pop("gecici_not")
print(silinen)
print(urun)

pop() anahtarı siler ve silinen değeri döndürür. Anahtarın olmaması beklenen bir durumsa get()teki gibi bir varsayılan değer verebilirsiniz:

silinen = urun.pop("indirim", None)

del urun["stok"] yazarak da anahtar silinebilir, ama anahtar yoksa KeyError verir. Silinen değer de gerekiyorsa pop() daha uygundur.

Hangi değerler sözlük anahtarı olabilir?

Sözlük, anahtarı hızlı bulmak için anahtardan bir sayı (hash değeri) hesaplar. Bu yüzden anahtarın hashlenebilir (hashable), yani hash değeri hesaplanabilen bir değer olması gerekir. Başlangıç için pratik kural şu: anahtar olarak değiştirilemeyen (immutable) değerler kullanın.

Sık kullanılan geçerli anahtarlar:

kayit = {
    "ad": "Deniz",  # str
    101: "aktif",    # int
    (41, 36): "nokta" # tuple içindeki elemanlar da hashlenebilirse
}

Liste değiştirilebilir olduğu için sözlük anahtarı olamaz:

sozluk = {}
# sozluk[[1, 2]] = "x"
# TypeError: unhashable type: 'list'

Bu kuralı 9. haftadaki değiştirilebilir (mutable) ve değiştirilemez (immutable) ayrımıyla birlikte düşünün.

Note

Buradan “değiştirilemeyen her değer iyi bir anahtardır” sonucunu çıkarmayın. Anahtarı öğrenci numarası gibi bir kimlik olarak düşünün: sözlükte durduğu sürece değerini bulmaya yarar. Bu derste str, int ve elemanları sayı ya da metin olan basit demetler yeterlidir.

Sözlük ekleme sırasını korur, küme korumaz

Python 3.7 ve sonrasında sözlük, anahtarları eklendikleri sırayla tutar:

urun = {}
urun["ad"] = "Kalem"
urun["fiyat"] = 12.5
urun["stok"] = 40

print(list(urun.keys()))

Çıktı:

['ad', 'fiyat', 'stok']

Sözlük anahtarları alfabetik ya da sayısal olarak sıralamaz; yalnızca ekleme sırasını korur.

Kümelerde ise yazdırma veya dolaşma sırasına güvenmeyin: aynı küme farklı çalıştırmalarda veya ortamlarda farklı sırada görünebilir.

Important

Alıştırmada kümenin elemanları beklediğinizden farklı sırada yazıldıysa cevabınız yanlış demek değildir. Kümede önemli olan, bir değerin kümede olup olmadığı ve her değerin bir kez bulunmasıdır. Çıktının belirli bir sırada olması gerekiyorsa sorted(kume) ile sıralayın.

Sayma tablosu oluşturmak

Sözlüğün en çok işe yaradığı yerlerden biri, her değerin kaç kez geçtiğini (frekansını) saymaktır.

Bir listedeki şehirlerin kaç kez geçtiğini bulalım:

sehirler = ["Samsun", "Ordu", "Samsun", "Amasya", "Ordu", "Samsun"]
sayilar = {}

for sehir in sehirler:
    sayilar[sehir] = sayilar.get(sehir, 0) + 1

print(sayilar)

Sonuç:

{'Samsun': 3, 'Ordu': 2, 'Amasya': 1}

Bir şehir ilk kez geldiğinde sözlükte henüz yoktur ve get(sehir, 0) 0 verir. Aynı şehir yeniden geldiğinde o ana kadarki sayı alınır ve bir artırılır.

Alıştırma: durumları sayın

Aşağıdaki listede "tamam" ve "bekliyor" değerlerinin kaç kez geçtiğini sözlükte sayın.

Beklenen:

{'tamam': 3, 'bekliyor': 2}

Küme (`set`): tekrarsız değerler

Bir küme her değeri bir kez tutar:

etiketler = {"python", "web", "python", "veri"}

print(etiketler)

İki kez yazdığımız "python" kümede bir kez bulunur. Sözlükten farklı olarak kümede elemanların hangi sırayla yazdırılacağı belli değildir.

Bir listeyi set() ile kümeye çevirebilirsiniz:

sehirler = ["Samsun", "Ordu", "Samsun", "Amasya"]
benzersiz = set(sehirler)

print(benzersiz)

Böylece listedeki tekrarlar atılır ve yalnızca benzersiz değerler kalır.

Liste, sözlük ve küme arasında gereksinime göre seçim. — Koleksiyon seçimi

Note

Kümenin indeksi yoktur; kume[0] yazamazsınız. Sıra sizin için önemliyse liste daha uygun olabilir.

Kümede üyelik kontrolü

Kümeler, bir değerin içlerinde olup olmadığını sormak (üyelik kontrolü) için çok uygundur:

izinli_roller = {"ogrenci", "personel", "misafir"}

rol = "personel"

if rol in izinli_roller:
    print("Rol tanımlı")

Kümeye eleman add() ile eklenir:

izinli_roller.add("yonetici")

Tahmin et: kaç benzersiz değer var?

İlk uzunluk 6, benzersiz değer sayısı 4 olur.

Alıştırma: tekrar eden ders kodlarını ayıklayın

Aşağıdaki listedeki ders kodlarını, her biri bir kez geçecek biçimde bir kümede toplayın.

Kümede 3 ders kodu kalmalı. Kodların hangi sırayla yazdırıldığı önemli değildir.

Hangi koleksiyonu seçmeliyim?

Tek bir “en iyi” koleksiyon yoktur; seçim, veriyle ne yapmak istediğimize bağlıdır.

İhtiyaç	Genellikle uygun yapı
Sıralı bir değer dizisi	`list`
Küçük ve değişmemesi beklenen sıralı grup	`tuple`
Anlamlı anahtardan değere erişim	`dict`
Tekrarsız değerler ve üyelik kontrolü	`set`

Örnekler:

Bir öğrencinin haftalık puanları → liste
Bir koordinat çifti → demet
Bir ürünün ad, fiyat, stok alanları → sözlük
Sistemde görülen benzersiz hata kodları → küme

Tip

Koleksiyonu verinin “nasıl göründüğüne” göre değil, programın veriye nasıl erişeceğine ve ne yapacağına göre seçin.

Liste ve sözlüğü birlikte kullanmak

Birden fazla ürünü saklamak için her ürünü bir sözlüğe, bütün sözlükleri de bir listeye koyabiliriz:

urunler = [
    {"ad": "Kalem", "fiyat": 12.5},
    {"ad": "Defter", "fiyat": 45},
    {"ad": "Silgi", "fiyat": 8}
]

for urun in urunler:
    print(urun["ad"], urun["fiyat"])

Her ürünün sözlüğüne bir kayıt diyebiliriz. Gelecek hafta bu yapıyla çalışacağız: kayıtları filtreleyecek, gruplayacak ve özetleyeceğiz.

Üret: basit stok özeti

Bir stok sözlüğünde ürün kodları anahtar, stok miktarları değer olsun:

stoklar = {
    "KLM": 12,
    "DFT": 0,
    "SLG": 8,
    "CTN": 0
}

stok_ozeti(stoklar) adlı bir fonksiyon yazın. Fonksiyon şu iki sayıyı hesaplayıp (toplam_stok, tukenen_urun_sayisi) demeti olarak döndürsün:

Toplam stok miktarı
Stoğu 0 olan ürün sayısı

Başlangıç:

Beklenen:

(20, 2)

def stok_ozeti(stoklar):
    toplam_stok = 0
    tukenen_urun_sayisi = 0

    for miktar in stoklar.values():
        toplam_stok = toplam_stok + miktar
        if miktar == 0:
            tukenen_urun_sayisi = tukenen_urun_sayisi + 1

    return toplam_stok, tukenen_urun_sayisi

stoklar = {
    "KLM": 12,
    "DFT": 0,
    "SLG": 8,
    "CTN": 0
}

print(stok_ozeti(stoklar))

Sınav provası

Önce kendi cevabınızı seçin, sonra cevap anahtarında her şıkkın neden doğru ya da yanlış olduğunu okuyun. Yanlış şıklar rastgele yazılmadı; bu konuda öğrencilerin gerçekten yaptığı hatalardan seçildi. Sınav soruları da aynı yolla hazırlanır.

Madde 1. urun = {"ad": "Kalem", "fiyat": 15} iken urun["fiyat"] ifadesindeki "fiyat" nedir?

A. Sözlüğün adı
B. Bir metot çağrısı; fiyatı okur
C. İndeks; 1 numaralı elemanı gösterir
D. Değer; köşeli parantez içindeki veridir
E. Anahtar; 15 değerine bu adla ulaşılır

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

urun = {"ad": "Kalem", "fiyat": 15}
urun["fiyat"] = 20
urun["stok"] = 7
print(len(urun))

A. Hata verir; olmayan bir anahtara atama yapılamaz
B. 20
C. 4
D. 3
E. 2

Madde 3. urun = {"ad": "Kalem", "fiyat": 15} iken "Kalem" in urun sonucu nedir?

A. False; in yalnız anahtarlara bakar
B. None döner; eşleşen anahtar bulunmaz
C. KeyError oluşur; "Kalem" bir anahtar değil
D. "ad"; eşleşen anahtarı döndürür
E. True; Kalem sözlüğün içindedir

Madde 4. urun.get("stok", 0) çağrısı ne yapar?

A. stok anahtarını 0 değeriyle sözlüğe ekler
B. Anahtar yoksa KeyError verir
C. stok anahtarını siler ve 0 döndürür
D. Değeri her zaman 0 yapar
E. Anahtar varsa değerini, yoksa 0 döndürür

Madde 5. Stok raporunda urun.get("stok", 0) kullanmak hangi durumda yanıltıcı olur?

A. Yanıltıcı olmaz; 0 güvenli bir varsayılandır
B. Girilmemiş stok ile gerçek sıfır stok ayrılmalıysa
C. Sözlükte çok sayıda ürün ve anahtar bulunduğunda
D. get() büyük sözlüklerde yavaş çalıştığı için
E. Varsayılan değer her zaman 0 olmak zorunda olduğu için

Madde 6. .keys(), .values() ve .items() sırasıyla neyi dolaşmayı sağlar?

A. Üçü de anahtarları dolaşır; fark yalnızca yazımdadır
B. Anahtarları, değerleri ve eleman sayısını
C. Anahtarları, değerleri ve anahtar–değer çiftlerini
D. Sıralı anahtarları, sıralı değerleri ve sıralı çiftleri
E. Değerleri, anahtarları ve indeksleri

Madde 7. [1, 2] listesi neden sözlük anahtarı olamaz?

A. Olabilir; yalnızca köşeli parantez yerine süslü parantez yazılmalıdır
B. Listeler çok fazla bellek kullandığı için
C. Liste değiştirilebilir olduğu için hashlenemez
D. Listeler yalnızca sayı tuttuğu için
E. Sözlük anahtarları yalnızca metin olabilir

Madde 8. Aşağıdaki kalıp ne yapar?

sayilar[deger] = sayilar.get(deger, 0) + 1

A. Her değerin kaç kez geçtiğini sayar
B. Değer ilk kez geliyorsa KeyError verir
C. deger anahtarını 0 değeriyle sıfırlar
D. Yinelenen anahtarları sözlükten siler
E. Sözlükteki bütün değerleri 1 yapar

Madde 9. Bir alıştırmada kümenin yazdırma sırası her çalıştırmada farklı çıkabiliyor. Bu ne anlama gelir?

A. Python sürümü eskidir; güncellenmelidir
B. Küme sıra tutmaz; bu bir hata değildir
C. Kümede bozulma vardır; yeniden oluşturulmalıdır
D. Küme her çalıştırmada elemanlarını rastgele değiştirir
E. Küme yerine demet kullanılmalıdır

Madde 10. Bir ankette kaç farklı şehir yanıtı geldiğini bulmak için hangisi en doğrudur?

A. len(tuple(yanitlar))
B. yanitlar.count()
C. len(yanitlar)
D. len(set(yanitlar))
E. len(sorted(yanitlar))

Cevaplar ve gerekçeler

Madde 1. Doğru: E. Sözlükte erişim konuma değil anahtara göre yapılır. "fiyat" değere ulaşmak için kullanılan addır, 15 ise o anahtarın değeridir.

A yanlış: Tırnak içinde bir ad olduğu için sözlüğün adı sanılabilir. Ama sözlüğün adı urundur.
B yanlış: Fiyat gerçekten okunuyor, bu yüzden bir çağrı gibi görünür. Ama metot çağrısı parantezle yazılır; buradaki köşeli parantez erişimdir.
C yanlış: Listede köşeli parantez indeks alır ve "fiyat" ikinci sırada durduğu için akla yatkın gelir. Ama sözlükte sıra numarasıyla erişim yapılmaz.
D yanlış: Köşeli parantezin içine yazılan şey okunan veri gibi görünür. Ama değer 15’tir; "fiyat" ona ulaşmak için kullanılan addır.

Madde 2. Doğru: D. Var olan anahtara atama değeri günceller ve sayıyı artırmaz; olmayan anahtara atama yeni alan ekler.

A yanlış: Olmayan anahtara atama yeni alanı oluşturur; hata yalnızca okuma sırasında çıkar.
B yanlış: len() eleman sayısını verir, bir değeri değil.
C yanlış: fiyat zaten vardı; ikinci kez eklenmez, yalnızca güncellenir.
E yanlış: stok yeni bir anahtardır; sözlüğe eklenir.

Madde 3. Doğru: A. in sözlükte anahtarları arar, değerlere bakmaz. "Kalem" bir değerdir; anahtarlar "ad" ve "fiyat"tır. Değerlerde aramak için in urun.values() yazılır.

B yanlış: get() bulamadığı anahtarda None döndürdüğü için bu davranış akla gelir. Ama in işleminin sonucu her zaman bir bool değeridir.
C yanlış: urun["Kalem"] yazılsaydı gerçekten KeyError alınırdı. Ama in hata vermez; çoğu zaman tam da hatadan kaçınmak için kullanılır.
D yanlış: "Kalem" gerçekten "ad" anahtarının değeridir, bu yüzden bu eşleşme akla gelir. Ama in anahtar döndürmez; sonucu True ya da False olur.
E yanlış: "Kalem" sözlüğü yazdırınca gerçekten görünür, bu yüzden akla yatkın gelir. Ama bir değer olarak durur; in varsayılan olarak anahtarlara bakar.

Madde 4. Doğru: E. get() eksik anahtarda programı durdurmak yerine verilen varsayılanı döndürür; hata vermez.

A yanlış: Çağrıda hem anahtar hem 0 yazılı olduğu için ekleme gibi görünür. Ama get() sözlüğü değiştirmez; ekleme yapmak için setdefault() kullanılır.
B yanlış: urun["stok"] böyle davranır, bu yüzden akla yatkın gelir. Ama get() tam da hata vermemek için kullanılır.
C yanlış: urun.pop("stok", 0) yazımı buna çok benzediği için karışabilir. Ama silme işlemi pop() veya del ile yapılır; get() sözlüğe dokunmaz.
D yanlış: Çağrıda 0 açıkça yazılı olduğu için sonuç hep 0 sanılabilir. Ama anahtar varsa gerçek değeri döner.

Madde 5. Doğru: B. get("stok", 0) iki durumda da 0 döndürür, yani “bilgi girilmemiş” ile “stok gerçekten sıfır” ayrımını siler. Hangi varsayılanın seçileceğine probleme bakarak karar verilir. Eksik veriyi ayırt etmek gerekiyorsa None daha uygun bir varsayılandır.

A yanlış: 0 programı durdurmadığı için güvenli görünür. Ama eksik veriyi sıfır saymak, rapordaki toplamı hata vermeden bozar.
C yanlış: Büyük veri her zaman hata kaynağı gibi görünür. Ama anahtar sayısının bununla ilgisi yoktur; get() her anahtarda aynı biçimde çalışır.
D yanlış: Büyük veride yavaşlama akla ilk gelen sorundur. Ama sorun hız değil, sonucun ne anlama geldiğidir.
E yanlış: Örneklerde en sık 0 görüldüğü için zorunlu sanılabilir. Ama varsayılan olarak istediğiniz değeri verebilirsiniz.

Madde 6. Doğru: C. .items() ile dolaşırken her turdaki çift iki değişkene açılabilir: for anahtar, deger in sozluk.items():

A yanlış: Üçü farklı şey döndürür.
B yanlış: Eleman sayısı için len() kullanılır.
D yanlış: Kendiliğinden sıralama yapmazlar; ekleme sırasını korurlar.
E yanlış: İlk ikisi ters yazılmış; ayrıca sözlükte indeks yoktur.

Madde 7. Doğru: C. Sözlük anahtarının değişmez olması gerekir. Anahtar sonradan değişebilseydi sözlük onu bir daha bulamazdı. Demet ise değişmez olduğu için anahtar olabilir.

A yanlış: Sözlük süslü parantezle yazıldığı için yazımın sorunu çözeceği sanılabilir. Ama {1, 2} bir küme olur ve küme de anahtar olamaz; TypeError yine alınır.
B yanlış: Büyük yapıların sorun çıkaracağı düşüncesi akla yatkın gelir. Ama bellek gerekçe değildir; iki elemanlı liste de anahtar olamaz.
D yanlış: Örnekteki liste yalnızca sayı içerdiği için akla gelebilir. Ama liste her türü tutabilir; sorun içeriğinde değil, değiştirilebilir olmasındadır.
E yanlış: Örneklerde anahtarlar çoğunlukla metin olduğu için böyle sanılabilir. Ama sayı ve demet de anahtar olabilir.

Madde 8. Doğru: A. Kalıp bir frekans tablosu kurar: değer ilk kez görülüyorsa 1’den başlar, daha önce görüldüyse sayacı bir artırır. get(deger, 0) eksik anahtar için KeyError çıkmasını önler.

B yanlış: sayilar[deger] okuması eksik anahtarda gerçekten hata verir. Ama burada okuma get(deger, 0) ile yapılır; eksik anahtar için 0 gelir.
C yanlış: Satırda 0 açıkça yazılı olduğu için sıfırlama gibi görünür. Ama 0 yalnız eksik anahtarın başlangıç değeridir; üstüne 1 eklenir.
D yanlış: Aynı değer tekrar geldiğinde bir şeyin atıldığı düşünülebilir. Ama sözlükte zaten yinelenen anahtar bulunmaz; kalıp yalnızca sayacı artırır.
E yanlış: İlk kez görülen değer gerçekten 1 alır, bu yüzden akla yatkın gelir. Ama yalnızca deger anahtarının sayısı değişir; önceki sayıya bir eklenir.

Madde 9. Doğru: B. Küme her değerin bir kez bulunacağını garanti eder, sırayı garanti etmez; sırasına güvenilmez. Sıra gerekiyorsa liste kullanılır ya da sonuç sıralanır.

A yanlış: Beklenmedik davranışta ilk akla gelen şey sürümdür. Ama sürümle ilgisi yoktur; kümenin sırası hiçbir sürümde garanti edilmez.
C yanlış: Aynı kodun farklı çıktı vermesi bir arıza gibi görünür. Ama bozulma yok; küme tanımı gereği sırasızdır.
D yanlış: Çıktı her seferinde farklı göründüğü için içerik değişiyor sanılabilir. Ama elemanlar değişmez; değişebilen yalnızca dolaşma sırasıdır.
E yanlış: Demet sırayı koruduğu için çözüm gibi görünür. Ama demet benzersizlik sağlamaz; ihtiyaç benzersizlikse küme doğru seçimdir.

Madde 10. Doğru: D. Küme yinelenen değerleri tutmaz; eleman sayısı doğrudan farklı yanıt sayısını verir.

A yanlış: Demete çevirmek de yinelenenleri kaldırmaz.
B yanlış: count() belirli bir değerin kaç kez geçtiğini sayar ve argüman ister.
C yanlış: Bu toplam yanıt sayısıdır; aynı şehir birden çok kez sayılır.
E yanlış: Sıralama yinelenenleri kaldırmaz; sayı değişmez.

Tek sayfa özet

Bu hafta listelerin yanına sözlükleri ve kümeleri de ekledik; koleksiyonu problemin ihtiyacına göre seçmeye başladık.

Sözlük her değeri bir anahtarla birlikte tutar.
sozluk["anahtar"] o anahtarın değerini verir; "anahtar" in sozluk anahtarın bulunup bulunmadığını kontrol eder.
Bir anahtara yeniden atama yapmak değeri günceller; pop() veya del ile alan silinebilir.
get() anahtar yoksa hata vermez; None ya da verdiğiniz varsayılan değeri döndürür.
.keys(), .values() ve .items() ile sırasıyla anahtarlarda, değerlerde ve anahtar–değer çiftlerinde dolaşılır.
Sözlük anahtarları hashlenebilir olmalıdır; değiştirilebilir list anahtar olamaz.
Python 3.7 ve sonrasında sözlük ekleme sırasını korur ama anahtarları alfabetik olarak sıralamaz.
Her değerin kaç kez geçtiğini saymak (frekans tablosu) için sözlük uygundur.
Küme her değeri bir kez tutar ve indeksi yoktur; yazdırma ve dolaşma sırasına güvenilmez.
set(liste) listedeki benzersiz değerleri verir.
Kümede üyelik kontrolü in ile yapılır.
Liste, demet, sözlük ve küme farklı erişim ihtiyaçlarına göre seçilir.

Bir sonraki bölümde liste ve sözlüğü birlikte kullanarak küçük kayıt listelerini işleyeceğiz.

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

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

Anahtar–değer modeliyle sözlükten değer okur ve alan günceller.
in denetiminin sözlükte değeri değil anahtarı aradığını bilir.
get() ile eksik anahtarda varsayılan kullanır ve bunun bedelini açıklar.
.keys(), .values() ve .items() arasındaki farkı açıklar.
Sözlük anahtarının hashlenebilir olması gerektiğini açıklar.
Sözlükle frekans veya sayaç tablosu kurar.
Kümenin benzersizlik ve sıra davranışını tanır ve probleme uygun koleksiyonu seçer.