Python Sözlük (dict) Metotları: get, setdefault, update ve frozendict

Sözlük oluşturmanın yolları

Belgeler sözlük oluşturmak için üç ana yol tanımlar: süslü parantez içinde virgülle ayrılmış anahtar: değer çiftleri, dict comprehension ve dict() yapıcısı. Yapıcı esnektir: anahtar kelime argümanları, iki elemanlı çiftlerden oluşan bir yinelenebilir ya da başka bir eşleme (mapping) alabilir; konumsal argümanın üzerine anahtar kelime argümanları eklenir. Anahtar kelime biçimi (dict(ad='Ayşe')) yalnızca anahtarlar geçerli Python tanımlayıcısıysa çalışır; 'e-posta' gibi bir anahtar için süslü parantezli yazımı kullanmanız gerekir. Aynı anahtar birden fazla kez verilirse son değer geçerli olur.

a = {'ad': 'Ayşe', 'yas': 30}
b = dict(ad='Ayşe', yas=30)
c = dict([('ad', 'Ayşe'), ('yas', 30)])
d = dict(zip(['ad', 'yas'], ['Ayşe', 30]))
e = dict({'yas': 30}, ad='Ayşe')
print(a == b == c == d == e)          # çıktı: True

print({x: x ** 2 for x in (2, 4, 6)}) # çıktı: {2: 4, 4: 16, 6: 36}
print({1: 'ilk', 2: 'iki', 1: 'son'}) # çıktı: {1: 'son', 2: 'iki'}

try:
    dict([('a', 1, 2)])
except ValueError as hata:
    print(hata)   # çıktı: dictionary update sequence element #0 has length 3; 2 is required

Boş süslü parantez {} boş bir sözlük oluşturur, boş küme değil; boş küme için set() yazmanız gerekir. Dict comprehension'ın tüm biçimleri list comprehension rehberinde ayrıca anlatılıyor.

Hangi değerler anahtar olabilir?

Anahtarlar hash edilebilir olmalıdır. Pratikte bu, string, sayı, None, yalnızca hash edilebilir eleman içeren tuple ve frozenset gibi değiştirilemez değerler anlamına gelir. Liste, küme ve sözlük anahtar olamaz. Python SSS bunun sebebini şöyle açıklar: sözlük, anahtarın hash değerinden hesaplanan bir konuma değeri yerleştiren bir hash tablosudur; anahtar değişebilseydi hash'i de değişir ve kayıt bir daha bulunamazdı. Değerler için hiçbir kısıtlama yoktur, değer olarak liste ya da başka bir sözlük kullanabilirsiniz.

Belgelerin özellikle uyardığı bir ayrıntı daha var: eşit kabul edilen değerler aynı anahtar gibi davranır. 1, 1.0 ve True birbirine eşit olduğu için aynı sözlük kaydını gösterir. İlk yazılan anahtar nesnesi korunur, değer ise en son atanandır.

d = {1: 'bir'}
d[1.0] = 'float'
d[True] = 'bool'
print(d)                              # çıktı: {1: 'bool'}

konumlar = {(0, 0): 'başlangıç'}       # tuple anahtar olabilir
print(konumlar[(0, 0)])               # çıktı: başlangıç

try:
    {['a']: 1}
except TypeError as hata:
    print(hata)   # çıktı: cannot use 'list' as a dict key (unhashable type: 'list')

Değer okumak: d[k], get() ve in

d[anahtar] değeri döndürür; anahtar yoksa KeyError fırlatır. Anahtarın olmayabileceği durumlarda get(anahtar, varsayılan) kullanın: anahtar yoksa varsayılan değeri, varsayılan verilmemişse None döndürür ve hiçbir zaman KeyError fırlatmaz. in işleci sözlükte anahtarlar arasında arar, değerler arasında değil. Bir değeri aramak için deger in d.values() yazmalısınız.

tel = {'ali': 4098, 'banu': 4139}
tel['cem'] = 4127
print(tel)                       # çıktı: {'ali': 4098, 'banu': 4139, 'cem': 4127}
print(tel['ali'])                # çıktı: 4098
print(tel.get('deniz'))          # çıktı: None
print(tel.get('deniz', 'yok'))   # çıktı: yok
print('banu' in tel, 4098 in tel)        # çıktı: True False
print(4098 in tel.values())      # çıktı: True

try:
    tel['deniz']
except KeyError as hata:
    print(repr(hata))            # çıktı: KeyError('deniz')

Ekleme, güncelleme ve ekleme sırası

d[k] = v anahtar yoksa yeni bir kayıt ekler, varsa eski değeri unutup yenisini yazar. Python 3.7'den bu yana sözlüklerin ekleme sırasını koruması dilin garantisidir (3.6'da yalnızca CPython'un bir uygulama ayrıntısıydı). Belgelerdeki iki kural önemlidir: var olan bir anahtarın değerini güncellemek sırasını değiştirmez; bir anahtarı silip yeniden eklerseniz sona eklenir.

d = {'bir': 1, 'iki': 2, 'üç': 3, 'dört': 4}
d['bir'] = 42
print(list(d))      # çıktı: ['bir', 'iki', 'üç', 'dört']
del d['iki']
d['iki'] = None
print(d)            # çıktı: {'bir': 42, 'üç': 3, 'dört': 4, 'iki': None}
print(list(reversed(d)))   # çıktı: ['iki', 'dört', 'üç', 'bir']

Silme: del, pop(), popitem() ve clear()

del d[k] anahtarı siler ve anahtar yoksa KeyError verir. pop(k) de siler ama değeri geri döndürür; ikinci argüman olarak bir varsayılan verirseniz anahtar yokken hata yerine o değer döner. popitem() son eklenen (anahtar, değer) çiftini çıkarır; Python 3.7'den beri bu "son giren ilk çıkar" (LIFO) sırası garantidir, öncesinde rastgele bir çift dönerdi. Boş sözlükte popitem() KeyError fırlatır. clear() tüm kayıtları siler.

d = {'bir': 1, 'iki': 2, 'üç': 3, 'dört': 4}
print(d.pop('üç'))                  # çıktı: 3
print(d.pop('beş', 'varsayılan'))   # çıktı: varsayılan
print(d.popitem())                  # çıktı: ('dört', 4)
print(d)                            # çıktı: {'bir': 1, 'iki': 2}
d.clear()
try:
    d.popitem()
except KeyError as hata:
    print(hata)                     # çıktı: 'popitem(): dictionary is empty'

Tüm sözlük metotları

setdefault() ve get() ile sayma ve gruplama

Bir değeri sayarken ya da gruplarken "anahtar yoksa başlangıç değeri koy, varsa güncelle" desenine sık ihtiyaç duyarsınız. Sayma için d.get(k, 0) + 1, gruplama için d.setdefault(k, []).append(x) kalıpları yaygındır. setdefault() anahtar yoksa varsayılanı sözlüğe ekleyip aynı nesneyi döndürdüğü için append() doğrudan sözlükteki listeye uygulanır. Belgeler bu işler için collections.defaultdict kullanmanın daha basit ve daha hızlı olduğunu belirtir; sayma için ise doğrudan Counter vardır. İkisi de collections modülü yazısında.

sayac = {}
for harf in 'merhaba':
    sayac[harf] = sayac.get(harf, 0) + 1
print(sayac)     # çıktı: {'m': 1, 'e': 1, 'r': 1, 'h': 1, 'a': 2, 'b': 1}

gruplar = {}
for ad in ['Ali', 'Ayşe', 'Bora', 'Can', 'Burak']:
    gruplar.setdefault(ad[0], []).append(ad)
print(gruplar)   # çıktı: {'A': ['Ali', 'Ayşe'], 'B': ['Bora', 'Burak'], 'C': ['Can']}

Sözlükleri birleştirmek: update(), | ve **

Üç yöntem de ortak anahtarlarda sağdaki değeri geçerli kılar. update() sözlüğü yerinde günceller ve None döndürür; başka bir eşleme, iki elemanlı çiftlerden oluşan bir yinelenebilir ve anahtar kelime argümanları kabul eder. Python 3.9 ile gelen a | b iki sözlükten yeni bir sözlük üretir ve iki tarafın da sözlük olmasını ister; a |= b ise yerinde günceller ve sağ tarafta çift listesi de kabul eder. {**a, **b} sözlük açma söz dizimidir ve varsayılan ayarların üzerine kullanıcı ayarlarını yazmak için sık kullanılır.

varsayilan = {'renk': 'mavi', 'adet': 8}
kullanici = {'renk': 'sarı'}
print(varsayilan | kullanici)        # çıktı: {'renk': 'sarı', 'adet': 8}
print({**varsayilan, **kullanici})   # çıktı: {'renk': 'sarı', 'adet': 8}

ayar = dict(varsayilan)
ayar.update(kullanici, adet=5)
print(ayar)                          # çıktı: {'renk': 'sarı', 'adet': 5}
ayar |= [('dil', 'tr')]
print(ayar)                          # çıktı: {'renk': 'sarı', 'adet': 5, 'dil': 'tr'}
print(varsayilan)                    # çıktı: {'renk': 'mavi', 'adet': 8}

try:
    varsayilan | [('dil', 'tr')]
except TypeError as hata:
    print(hata)   # çıktı: unsupported operand type(s) for |: 'dict' and 'list'

keys(), values() ve items(): görünüm nesneleri

Bu üç metot liste döndürmez, sözlüğe bağlı dinamik görünüm (view) nesneleri döndürür. Sözlük değiştiğinde görünüm de değişikliği yansıtır. Görünümler üzerinde döngü kurabilir, len() ve in kullanabilirsiniz; anahtarlar ve değerler aynı (ekleme) sırasıyla gelir. Anahtar görünümü elemanları benzersiz ve hash edilebilir olduğu için küme gibi davranır: &, |, -, ^ işlemlerini destekler ve diğer tarafta herhangi bir yinelenebilir kabul eder. Değer görünümü küme gibi davranmaz ve belgelerin uyardığı bir tuhaflığı vardır: aynı sözlükten bile alınmış olsalar iki ayrı values() görünümünün eşitlik karşılaştırması her zaman False döner. Değerleri karşılaştırmak istiyorsanız önce listeye ya da (değerler hash edilebiliyorsa) Counter'a çevirin.

yemek = {'yumurta': 2, 'sucuk': 1, 'peynir': 1, 'zeytin': 500}
anahtarlar = yemek.keys()
degerler = yemek.values()
print(sum(degerler))             # çıktı: 504

del yemek['yumurta']
print(list(anahtarlar))          # çıktı: ['sucuk', 'peynir', 'zeytin']
print(anahtarlar & {'yumurta', 'peynir', 'salata'})   # çıktı: {'peynir'}
print(sorted(anahtarlar - ['sucuk']))     # çıktı: ['peynir', 'zeytin']
print(yemek.values() == yemek.values())   # çıktı: False
print(('zeytin', 500) in yemek.items())   # çıktı: True
print(degerler.mapping['zeytin'])         # çıktı: 500

Döngüde sözlüğü değiştirmek

Bir sözlüğün üzerinde dönerken ona kayıt ekler ya da silerseniz Python RuntimeError fırlatabilir veya bazı kayıtları atlayabilir; belgeler bu durumu açıkça belirtir. Var olan anahtarların değerini değiştirmek sorun değildir, sorun boyutun değişmesidir. Çözüm, anahtarların bir kopyası (list(d)) üzerinde dönmek ya da comprehension ile yeni bir sözlük kurmaktır.

fiyat = {'elma': 10, 'armut': 0, 'muz': 25, 'kivi': 0}
try:
    for urun in fiyat:
        if fiyat[urun] == 0:
            del fiyat[urun]
except RuntimeError as hata:
    print(hata)    # çıktı: dictionary changed size during iteration

fiyat = {'elma': 10, 'armut': 0, 'muz': 25, 'kivi': 0}
for urun in list(fiyat):
    if fiyat[urun] == 0:
        del fiyat[urun]
print(fiyat)       # çıktı: {'elma': 10, 'muz': 25}

fiyat = {'elma': 10, 'armut': 0, 'muz': 25}
print({k: v for k, v in fiyat.items() if v > 0})   # çıktı: {'elma': 10, 'muz': 25}

Sözlüğü anahtara veya değere göre sıralamak

Sözlüğün kendisinin bir sort() metodu yoktur. sorted(d) anahtarları sıralı bir liste olarak verir. Değere göre sıralamak için sorted(d.items(), key=...) ile çiftleri sıralar, gerekiyorsa sonucu dict() ile yeniden sözlüğe çevirirsiniz; ekleme sırası korunduğu için yeni sözlük sıralı sırayla dolaşılır. En büyük değere sahip anahtarı bulmak için max(d, key=d.get) kısa bir yoldur. key parametresinin ayrıntıları lambda ve sorted yazısında.

puan = {'Can': 72, 'Ayşe': 91, 'Ece': 85}
print(sorted(puan))      # çıktı: ['Ayşe', 'Can', 'Ece']
print(sorted(puan.items(), key=lambda kv: kv[1], reverse=True))
# çıktı: [('Ayşe', 91), ('Ece', 85), ('Can', 72)]

sirali = dict(sorted(puan.items(), key=lambda kv: kv[1]))
print(sirali)            # çıktı: {'Can': 72, 'Ece': 85, 'Ayşe': 91}
print(max(puan, key=puan.get))   # çıktı: Ayşe

fromkeys() tuzağı ve tekrarları sırayla temizlemek

dict.fromkeys(anahtarlar, değer) tüm anahtarlara aynı değer nesnesini atar. Belgeler bu yüzden değerin boş liste gibi değiştirilebilir bir nesne olmasının genellikle anlamsız olduğunu, her anahtara ayrı nesne için dict comprehension kullanılması gerektiğini belirtir. Öte yandan fromkeys(), ekleme sırası korunduğu için bir listedeki tekrarları ilk görülme sırasını koruyarak temizlemenin kısa bir yoludur.

yanlis = dict.fromkeys(['a', 'b'], [])
yanlis['a'].append(1)
print(yanlis)    # çıktı: {'a': [1], 'b': [1]}

dogru = {k: [] for k in ['a', 'b']}
dogru['a'].append(1)
print(dogru)     # çıktı: {'a': [1], 'b': []}

print(list(dict.fromkeys([3, 1, 3, 2, 1])))   # çıktı: [3, 1, 2]

Eşitlik, kopyalama ve iç içe sözlükler

İki sözlük, aynı (anahtar, değer) çiftlerine sahipse sıralarından bağımsız olarak eşittir. < veya > gibi büyüklük karşılaştırmaları ise sözlükler için tanımlı değildir ve TypeError verir. copy() sığ kopya üretir: dış sözlük yenidir ama değer olarak tutulan listeler ve iç sözlükler paylaşılır. İç içe yapılarda bağımsız bir kopya için copy.deepcopy() kullanın. Bu davranış listelerdeki kopyalama kurallarının aynısıdır.

import copy

print({'a': 1, 'b': 2} == {'b': 2, 'a': 1})   # çıktı: True
try:
    {'a': 1} < {'b': 2}
except TypeError as hata:
    print(hata)   # çıktı: '<' not supported between instances of 'dict' and 'dict'

kullanici = {'ad': 'Ece', 'roller': ['admin']}
kopya = kullanici.copy()
kopya['ad'] = 'Mert'
kopya['roller'].append('editör')
print(kullanici)  # çıktı: {'ad': 'Ece', 'roller': ['admin', 'editör']}

derin = copy.deepcopy(kullanici)
derin['roller'].clear()
print(kullanici['roller'])   # çıktı: ['admin', 'editör']

__missing__: eksik anahtarda özel davranış

dict'ten türettiğiniz bir sınıfta __missing__() metodunu tanımlarsanız, olmayan bir anahtar d[k] ile istendiğinde KeyError yerine bu metot çağrılır ve onun döndürdüğü değer kullanılır. Belgelere göre bu metodu yalnızca d[k] işlemi çağırır; get() ya da in gibi diğer işlemler onu tetiklemez. collections.Counter ve defaultdict bu mekanizmanın üzerine kuruludur.

class Sayac(dict):
    def __missing__(self, anahtar):
        return 0

c = Sayac()
print(c['kırmızı'])     # çıktı: 0
c['kırmızı'] += 1
print(c)                # çıktı: {'kırmızı': 1}
print(c.get('mavi'))    # çıktı: None

Python 3.15 yeniliği: frozendict

Python 3.15, PEP 814 ile frozendict adında yeni bir yerleşik tip ekledi. frozendict, oluşturulduktan sonra değiştirilemeyen bir sözlüktür. Yapıcısı dict() ile aynı biçimleri kabul eder ve okuma işlemlerinin hepsini ([], get(), keys(), items(), in, len()) destekler. Belgelerde listelenen farklar şunlardır: __setitem__, __delitem__, clear(), pop(), popitem(), setdefault() ve update() yoktur; tüm anahtar ve değerleri hash edilebilirse kendisi de hash edilebilir; |= işleci nesneyi yerinde değiştirmez, yeni bir frozendict üretir. Ekleme sırasını korur ama eşitlik karşılaştırması sırayı dikkate almaz.

import collections.abc
import json

a = frozendict(x=1, y=2)
print(a)                              # çıktı: frozendict({'x': 1, 'y': 2})
b = frozendict(y=2, x=1)
print(a == b, hash(a) == hash(b))     # çıktı: True True
print(a == {'x': 1, 'y': 2})          # çıktı: True
print(a['x'], a.get('z', 0), len(a))  # çıktı: 1 0 2

profiller = {a: 'ilk profil'}         # sözlük anahtarı olabilir
print(profiller[b])                   # çıktı: ilk profil

print(isinstance(a, dict))            # çıktı: False
print(isinstance(a, collections.abc.Mapping))   # çıktı: True

eski = a
a |= {'z': 3}
print(a)                              # çıktı: frozendict({'x': 1, 'y': 2, 'z': 3})
print(a is eski, eski)                # çıktı: False frozendict({'x': 1, 'y': 2})
print(json.dumps(eski))               # çıktı: {"x": 1, "y": 2}

try:
    hash(frozendict(liste=[1]))
except TypeError as hata:
    print(hata)                       # çıktı: unhashable type: 'list'

frozendict, dict'in alt sınıfı değildir; doğrudan object'ten türer. Bu yüzden isinstance(x, dict) kontrolü yapan eski kodlar frozendict'i kabul etmez. 3.15 sürüm notları böyle kodları isinstance(x, (dict, frozendict)) ya da her türlü eşlemeyi kabul etmek için isinstance(x, collections.abc.Mapping) ile güncellemeyi önerir. Yine sürüm notlarına göre copy, json, pickle, pprint ve decimal gibi standart kütüphane modülleri frozendict'i kabul edecek şekilde güncellendi. Değiştirmeye çalıştığınızda aldığınız hata şöyledir (Python 3.15.2 çıktısı, dosya yolu ornek.py olarak kısaltıldı):

ayar = frozendict(dil='tr')
ayar['tema'] = 'koyu'
# Traceback (most recent call last):
#   File "ornek.py", line 2, in <module>
#     ayar['tema'] = 'koyu'
#     ~~~~^^^^^^^^
# TypeError: 'frozendict' object does not support item assignment

Eski Python sürümlerinde salt okunur bir sözlük görünümü için types.MappingProxyType kullanılırdı; belgeler hâlâ iki seçeneği birlikte anar. Fark şudur: MappingProxyType var olan bir sözlüğe salt okunur bir pencere açar ve alttaki sözlük değişirse görünüm de değişir; frozendict ise kendi verisini tutan bağımsız, değişmez bir nesnedir. Sürümün diğer yenilikleri için Python 3.15 yenilikleri yazısına bakın.

Uygulamalı mini örnek: kelime sıklığı

Bir metindeki kelimeleri sayıp en sık geçenden en aza doğru, eşitlikte alfabetik sırayla yazdıralım. Örnek get() ile sayma, items() ile çiftleri alma ve tuple anahtarla çok kriterli sıralamayı bir araya getiriyor. Çıktıdaki hizalama f-string biçim belirteciyle yapılıyor; ayrıntılar f-string biçimlendirme yazısında.

metin = 'bir elma bir armut iki elma'
frekans = {}
for kelime in metin.split():
    frekans[kelime] = frekans.get(kelime, 0) + 1

for kelime, adet in sorted(frekans.items(), key=lambda kv: (-kv[1], kv[0])):
    print(f'{kelime:<6}{adet}')
# çıktı: bir   2
# çıktı: elma  2
# çıktı: armut 1
# çıktı: iki   1

Sık yapılan hatalar

• Olmayabilecek bir anahtarı d[k] ile okumak: KeyError yerine get() veya in kullanın.
• in işlecinin değerlerde aradığını sanmak: sözlükte in anahtarlara bakar.
• Liste gibi değiştirilebilir bir nesneyi anahtar yapmaya çalışmak: tuple'a çevirin.
• Döngü sırasında sözlüğe kayıt eklemek ya da silmek: list(d) üzerinde dönün.
• dict.fromkeys(anahtarlar, []) ile her anahtara ayrı liste verdiğinizi sanmak.
• copy() ile iç içe sözlüğün tamamen kopyalandığını sanmak: copy.deepcopy() kullanın.
• Başka dillerden metot adı getirmek: Python 3.15 bunlara da öneride bulunur (aşağıda).

sepet = {}
sepet.put('elma', 3)
# Traceback (most recent call last):
#   File "ornek.py", line 2, in <module>
#     sepet.put('elma', 3)
#     ^^^^^^^^^
# AttributeError: 'dict' object has no attribute 'put'. Use d[k] = v.

Bu hata mesajındaki "Use d[k] = v." önerisi Python 3.15 ile geldi: Python, başka dillerde yaygın olan bir metot adını tanıdığında, karşılığı bir metot değil de bir dil yapısıysa onu doğrudan tarif ediyor. Hata mesajlarının genel bir rehberi için sık görülen hata mesajları yazısına bakabilirsiniz.

Sık Sorulan Sorular

Sözlükler sıralı mı?

Sözlükler ekleme sırasını korur; bu Python 3.7'den beri dil garantisidir. Ancak "sıralı" kelimesi alfabetik ya da sayısal sıra anlamına gelmez; sıralı bir görünüm istiyorsanız sorted() kullanmanız gerekir. Sıra, eşitlik karşılaştırmasını etkilemez.

Sözlükte arama neden hızlı?

Python SSS'ye göre CPython sözlükleri yeniden boyutlandırılabilen hash tabloları olarak uygular. Anahtarların hash değerleri birbirinden farklı olduğu sürece bir anahtarı bulmak sabit zamanda, yani sözlüğün boyutundan bağımsız olarak gerçekleşir. Glossary'ye göre kümeler de hash değerini içeride aynı amaçla kullanır.

OrderedDict'e hâlâ ihtiyaç var mı?

Belgelere göre normal sözlük ekleme sırasını hatırladığı için OrderedDict eskisi kadar önemli değil, ama sıraya duyarlı eşitlik testi ve move_to_end() gibi yeniden sıralama işlemleri için hâlâ avantajlı. Karşılaştırma collections modülü yazısında.

Sözlüğü JSON'a nasıl çeviririm?

json.dumps(d) bir sözlüğü JSON metnine çevirir; Türkçe karakterleri korumak için ensure_ascii=False parametresi gerekir. Ayrıntılar json modülü yazısında.

Marka adları sahiplerine aittir. Bu yazı bağımsız bir teknik rehberdir; adı geçen kuruluşlarla bayilik veya ortaklık ilişkisi bulunduğu anlamına gelmez.

İlgili içerikler: Python öğrenme rehberi · Liste metotları · set ve küme işlemleri · dict comprehension · Counter ve defaultdict · json modülü