Python’un sunduğu temel veri yapılarından biri olan sözlükler (Dictionaries), programlamada verileri ilişkilendirmek ve hızlı bir şekilde erişmek için kullanılan son derece güçlü ve esnek bir araçtır. Gerçek hayattaki bir sözlüğe benzer şekilde, Python sözlükleri de bir anahtar (key) kullanarak ona karşılık gelen bir değere (value) ulaşmamızı sağlar. Bu anahtar-değer çifti (key-value pair) yapısı, listeler veya demetler gibi sadece sayısal indekslere dayalı erişimin ötesine geçerek, verileri daha anlamlı ve sezgisel bir şekilde organize etmemize olanak tanır.

Sözlükler, Python’da en sık kullanılan veri yapılarından biridir ve JSON verilerini temsil etmekten, nesne özelliklerini saklamaya, konfigürasyon ayarlarını yönetmekten veri sayımlamaya kadar çok geniş bir kullanım alanına sahiptir. Bu rehberde, Python sözlüklerinin temelini oluşturan anahtar-değer kavramını, sözlüklerin nasıl oluşturulduğunu, öğelerine nasıl erişilip değiştirildiğini ve üzerlerinde işlem yapmak için kullanılan zengin metot setini detaylı bir şekilde ele alacağız.

Bölüm 1: Sözlük Nedir? Temel Kavramlar
Python’da bir sözlük (dictionary), süslü parantezler {} içinde tanımlanan, virgülle ayrılmış anahtar: değer çiftlerinden oluşan, sırasız (Python 3.6 ve öncesi) veya eklenme sırasına göre sıralı (Python 3.7 ve sonrası) ve değiştirilebilir (mutable) bir koleksiyondur.

1.1. Anahtar-Değer Çiftleri (Key-Value Pairs)
Sözlüklerin temel yapı taşı anahtar-değer çiftleridir. Her çift, iki kısımdan oluşur:

Anahtar (Key): Sözlük içindeki bir değere erişmek için kullanılan benzersiz bir tanımlayıcıdır. Bir etikete benzetilebilir.
Değer (Value): Anahtarla ilişkilendirilmiş olan asıl veridir.
Örneğin, bir telefon rehberi sözlüğünde, kişinin adı anahtar, telefon numarası ise değer olabilir.

telefon_rehberi = {
"Ali Veli": "555-1234", # "Ali Veli" anahtar, "555-1234" değer
"Ayşe Yılmaz": "555-5678", # "Ayşe Yılmaz" anahtar, "555-5678" değer
"Can Demir": "555-9900" # "Can Demir" anahtar, "555-9900" değer
}
print(telefon_rehberi)
1.2. Anahtar (Key) Özellikleri
Sözlük anahtarlarının belirli kurallara uyması gerekir:

Benzersiz Olmalıdır (Unique): Bir sözlük içinde her anahtar sadece bir kez bulunabilir. Aynı anahtarı tekrar kullanmaya çalışırsanız, eski değerin üzerine yazılır.
sozluk = {"a": 1, "b": 2} sozluk["a"] = 100 # "a" anahtarının değeri güncellenir print(sozluk) # {'a': 100, 'b': 2}
Değiştirilemez Olmalıdır (Immutable): Anahtarlar, değerleri program çalışırken değişmeyen tiplerden olmalıdır. Bu nedenle sayılar (int, float), stringler (str), booleanlar (bool) ve içinde sadece değiştirilemez öğeler bulunan demetler (tuple) anahtar olarak kullanılabilir. Listeler veya diğer sözlükler gibi değiştirilebilir (mutable) tipler anahtar olarak kullanılamaz. Bunun nedeni, Python’un anahtarları verimli bir şekilde bulmak için hash tablosu kullanması ve hash değerinin değişmezliğe bağlı olmasıdır.
gecerli_anahtarlar = { 10: "Sayı", "metin": "String", 3.14: "Float", True: "Boolean", (1, 2): "Tuple (içi immutable)" } print(gecerli_anahtarlar) # Geçersiz anahtar denemesi: try: gecersiz = {[1, 2]: "Liste anahtar olamaz"} except TypeError as e: print(f"\nHata (Liste Anahtar): {e}") # Hata: unhashable type: 'list'
1.3. Değer (Value) Özellikleri
Sözlük değerleri için ise herhangi bir kısıtlama yoktur:

Herhangi Bir Tip Olabilir: Değerler sayılar, stringler, listeler, demetler, başka sözlükler, fonksiyonlar, sınıflar veya herhangi bir Python nesnesi olabilir.
Tekrarlanabilir: Farklı anahtarlar aynı değere sahip olabilir.
cesitli_degerler = {
"sayi": 100,
"metin": "Merhaba",
"liste": [1, 2, 3],
"demet": (4, 5),
"sozluk": {"ic_anahtar": "ic_deger"},
"bool": True,
"tekrar": 100 # Başka bir anahtar da aynı değere sahip olabilir
}
print(cesitli_degerler)
1.4. Sıra (Ordering)
Python 3.7 ve Sonrası: Sözlükler, anahtar-değer çiftlerinin eklenme sırasını korur. Yani, sözlük üzerinde iterasyon yaptığınızda veya öğeleri yazdırdığınızda, çiftler sizin onları eklediğiniz sırayla gelir.
Python 3.6 ve Öncesi: Sözlükler sırasızdır. Öğelerin eklenme sırası korunmaz ve iterasyon sırası garanti edilmezdi.
Bu değişiklik (sıranın korunması), Python 3.7 ile gelen önemli bir özelliktir ve sözlükleri birçok durumda daha öngörülebilir ve kullanışlı hale getirmiştir.

Bölüm 2: Sözlük Oluşturma
Python’da sözlük oluşturmanın birkaç farklı yolu vardır:

2.1. Süslü Parantez Kullanarak ({})
En yaygın ve okunaklı yöntem, anahtar-değer çiftlerini anahtar: değer formatında süslü parantezler içine virgülle ayırarak yazmaktır.

Boş sözlük oluşturma

bos_sozluk = {}
print(f"Boş Sözlük: {bos_sozluk}, Tipi: {type(bos_sozluk)}")

Öğelerle dolu sözlük oluşturma

ogrenci = {
"ad": "Zeynep",
"numara": 123,
"bolum": "Bilgisayar Müh.",
"aktif_mi": True,
"notlar": [85, 90, 78] # Değer bir liste olabilir
}
print(f"Öğrenci Sözlüğü: {ogrenci}")
2.2. dict() Yapıcı Fonksiyonu (Constructor) Kullanarak
dict() fonksiyonu, sözlük oluşturmak için çeşitli yollar sunar:

a) Anahtar Kelime Argümanları ile (Keyword Arguments)
Anahtarlar geçerli Python değişken isimleri ise (string olarak), doğrudan anahtar kelime argümanı olarak kullanılabilirler. Bu durumda anahtarları tırnak içine almaya gerek yoktur.

dict() ile anahtar kelime argümanları kullanarak

urun = dict(ad="Laptop", marka="ABC", fiyat=25000, stok=15)
print(f"Ürün (dict() kwarg): {urun}")

{'ad': 'Laptop', 'marka': 'ABC', 'fiyat': 25000, 'stok': 15}

Anahtarlar tire (-) veya sayı içeriyorsa bu yöntem doğrudan çalışmaz:

gecersiz = dict(ogrenci-no=456) # SyntaxError

b) Yinelenebilir Anahtar-Değer Çiftleri ile
dict() fonksiyonu, her biri iki öğe içeren (ilk öğe anahtar, ikinci öğe değer) yinelenebilir bir nesneyi (örneğin, listelerden oluşan bir liste, demetlerden oluşan bir liste/demet) argüman olarak alabilir.

List of tuples

veri_listesi_tuple = [("a", 1), ("b", 2), ("c", 3)]
sozluk1 = dict(veri_listesi_tuple)
print(f"Sözlük (List of Tuples): {sozluk1}") # {'a': 1, 'b': 2, 'c': 3}

List of lists

veri_listesi_liste = [["x", 10], ["y", 20]]
sozluk2 = dict(veri_listesi_liste)
print(f"Sözlük (List of Lists): {sozluk2}") # {'x': 10, 'y': 20}

Tuple of tuples

veri_demeti_demet = (("k1", "v1"), ("k2", "v2"))
sozluk3 = dict(veri_demeti_demet)
print(f"Sözlük (Tuple of Tuples): {sozluk3}") # {'k1': 'v1', 'k2': 'v2'}
c) zip() Fonksiyonu ile
İki ayrı yinelenebilir (biri anahtarlar, diğeri değerler için) varsa, zip() fonksiyonu bunları eşleştirerek anahtar-değer çiftleri oluşturur ve bu dict() ile sözlüğe çevrilebilir.

anahtarlar = ["ad", "soyad", "yas"]
degerler = ["Mehmet", "Kaya", 40]
kisi = dict(zip(anahtarlar, degerler))
print(f"Sözlük (zip ile): {kisi}") # {'ad': 'Mehmet', 'soyad': 'Kaya', 'yas': 40}
d) Başka Bir Sözlükten (Mapping)
dict(), argüman olarak başka bir sözlük aldığında, o sözlüğün bir sığ kopyasını (shallow copy) oluşturur.

orijinal_sozluk = {"a": 1, "b": [10, 20]}
kopya_sozluk = dict(orijinal_sozluk)
print(f"Kopya (dict() ile): {kopya_sozluk}")
print(f"Orijinal is Kopya? {orijinal_sozluk is kopya_sozluk}") # False (Farklı nesneler)

Sığ kopya detayları için Kopyalama bölümüne bakınız.

2.3. Sözlük Üreteçleri (Dictionary Comprehensions)
Liste üreteçlerine benzer şekilde, mevcut bir yinelenebilir nesneden veya başka bir sözlükten yeni sözlükler oluşturmanın kısa ve etkili bir yoludur.

Sözdizimi: {anahtar_ifadesi: deger_ifadesi for öğe in yinelenebilir if koşul}

Sayıların karelerini içeren sözlük (sayı: karesi)

sayilar = [1, 2, 3, 4, 5]
kareler_sozluk = {x: x**2 for x in sayilar}
print(f"Kareler Sözlüğü: {kareler_sozluk}")

{1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

Sadece çift sayıların kareleri

cift_kareler_sozluk = {x: x**2 for x in sayilar if x % 2 == 0}
print(f"Çift Kareler Sözlüğü: {cift_kareler_sozluk}")

{2: 4, 4: 16}

Mevcut bir sözlüğün anahtar ve değerlerini değiştirmek

fiyatlar = {"elma": 5, "armut": 7, "muz": 10}

Fiyatlara %10 KDV ekleyelim

kdvli_fiyatlar = {urun: fiyat * 1.10 for urun, fiyat in fiyatlar.items()}
print(f"KDV'li Fiyatlar: {kdvli_fiyatlar}")

{'elma': 5.5, 'armut': 7.7, 'muz': 11.0}

Belirli bir fiyattan pahalı ürünleri filtreleme

pahali_urunler = {urun: fiyat for urun, fiyat in fiyatlar.items() if fiyat > 6}
print(f"Pahalı Ürünler (>6 TL): {pahali_urunler}")

{'armut': 7, 'muz': 10}

Dictionary comprehensions, döngüler ve koşullarla sözlük oluşturma işlemlerini çok daha okunabilir ve öz hale getirir.

Bölüm 3: Sözlük Öğelerine (Değerlere) Erişim
Bir sözlükteki değere erişmenin temel yolu, ilgili anahtarı kullanmaktır.

3.1. Köşeli Parantez Notasyonu (dict[key])
Bir anahtara karşılık gelen değeri almak için en yaygın yöntem, sözlük adından sonra köşeli parantez içinde anahtarı belirtmektir.

Dikkat: Eğer belirtilen anahtar sözlükte bulunmuyorsa, bu yöntem KeyError hatası verir.

ogrenci = {"ad": "Ayşe", "numara": 456, "bolum": "Kimya"}
print(f"Öğrencinin Adı: {ogrenci['ad']}") # Ayşe
print(f"Öğrencinin Bölümü: {ogrenci['bolum']}") # Kimya

Olmayan bir anahtara erişmeye çalışma:

try:
print(ogrenci['yas'])
except KeyError as e:
print(f"\nHata (Köşeli Parantez): Anahtar bulunamadı - {e}")
3.2. get(key, default=None) Metodu
get() metodu, bir anahtara karşılık gelen değeri almak için daha güvenli bir yoldur. Köşeli parantezden farklı olarak:

Eğer anahtar sözlükte varsa, ilgili değeri döndürür.
Eğer anahtar sözlükte yoksa, KeyError vermek yerine varsayılan olarak None değerini döndürür.
İsteğe bağlı ikinci bir argüman (default) verilirse, anahtar bulunamadığında None yerine bu belirtilen varsayılan değer döndürülür.
Bu metot, bir anahtarın sözlükte olup olmadığından emin olmadığınız durumlarda veya anahtar yoksa programın hata vermeden devam etmesini istediğinizde çok kullanışlıdır.

urun_stok = {"kalem": 50, "defter": 25, "silgi": 100}

Var olan anahtara erişim

kalem_stok = urun_stok.get("kalem")
print(f"Kalem Stok (get): {kalem_stok}") # 50

Olmayan anahtara erişim (varsayılan None döner)

canta_stok = urun_stok.get("çanta")
print(f"Çanta Stok (get): {canta_stok}") # None

Olmayan anahtara erişim (kendi varsayılan değerimizle)

bant_stok = urun_stok.get("bant", 0) # Anahtar yoksa 0 döndür
print(f"Bant Stok (get, default=0): {bant_stok}") # 0

Köşeli parantez ile karşılaştırma

print(f"Defter Stok (köşeli parantez): {urun_stok['defter']}") # 25

print(urun_stok['çanta']) # KeyError verir!

Bölüm 4: Sözlükleri Değiştirme (Mutability)
Sözlükler değiştirilebilir (mutable) veri yapılarıdır, yani oluşturulduktan sonra içerikleri güncellenebilir.

4.1. Yeni Anahtar-Değer Çifti Ekleme
Sözlüğe yeni bir çift eklemek için, köşeli parantez içinde yeni anahtarı belirterek ona bir değer atamanız yeterlidir.

kisi = {"ad": "Fatma", "yas": 28}
print(f"Başlangıç: {kisi}")

Yeni 'sehir' anahtarı ekleme

kisi["sehir"] = "İzmir"
print(f"Şehir eklendi: {kisi}") # {'ad': 'Fatma', 'yas': 28, 'sehir': 'İzmir'}

Yeni 'meslek' anahtarı ekleme

kisi["meslek"] = "Mühendis"
print(f"Meslek eklendi: {kisi}") # {'ad': 'Fatma', 'yas': 28, 'sehir': 'İzmir', 'meslek': 'Mühendis'}
4.2. Mevcut Bir Anahtarın Değerini Güncelleme
Eğer atama yaparken belirttiğiniz anahtar sözlükte zaten varsa, yeni değer eski değerin üzerine yazılır.

kisi = {"ad": "Fatma", "yas": 28, "sehir": "İzmir"}
print(f"Güncelleme Öncesi: {kisi}")

'yas' değerini güncelleme

kisi["yas"] = 29
print(f"Yaş güncellendi: {kisi}") # {'ad': 'Fatma', 'yas': 29, 'sehir': 'İzmir'}

'sehir' değerini güncelleme

kisi["sehir"] = "Ankara"
print(f"Şehir güncellendi: {kisi}") # {'ad': 'Fatma', 'yas': 29, 'sehir': 'Ankara'}
4.3. update(other_dict) Metodu
Ne Yapar: Başka bir sözlüğü (veya anahtar-değer çiftleri içeren bir yinelenebilir nesneyi) argüman olarak alır ve bu argümandaki çiftleri mevcut sözlüğe ekler veya günceller. Eğer argümandaki bir anahtar mevcut sözlükte zaten varsa, değeri güncellenir. Eğer yoksa, yeni bir çift olarak eklenir.
Değişiklik: Sözlüğü yerinde (in-place) değiştirir.
Dönüş Değeri: None
sozluk1 = {'a': 1, 'b': 2}
sozluk2 = {'b': 200, 'c': 3, 'd': 4}
liste_ciftler = [('e', 5), ('a', 100)] # Liste içinde demetler
print(f"Sozluk1 (başlangıç): {sozluk1}")

sozluk2 ile güncelle

sozluk1.update(sozluk2)

'b' güncellendi, 'c' ve 'd' eklendi

print(f"update(sozluk2) sonrası: {sozluk1}") # {'a': 1, 'b': 200, 'c': 3, 'd': 4}

liste_ciftler ile güncelle

sozluk1.update(liste_ciftler)

'a' güncellendi, 'e' eklendi

print(f"update(liste_ciftler) sonrası: {sozluk1}") # {'a': 100, 'b': 200, 'c': 3, 'd': 4, 'e': 5}

Anahtar kelime argümanları ile de update yapılabilir

sozluk1.update(f=6, g=7, b=222) # 'b' tekrar güncellendi, 'f' ve 'g' eklendi
print(f"update(kwargs) sonrası: {sozluk1}") # {'a': 100, 'b': 222, 'c': 3, 'd': 4, 'e': 5, 'f': 6, 'g': 7}
Python 3.9 ve sonrasında, iki sözlüğü birleştirmek için pipe (|) operatörü de kullanılabilir, ancak bu operatör yeni bir sözlük oluşturur, mevcut olanları değiştirmez:

Python 3.9+

dict_x = {'x': 1}
dict_y = {'y': 2, 'x': 10}
birlesik_yeni = dict_x | dict_y # Sağdaki sözlük öncelikli (x=10 olur)
print(f"Yeni birleşik (| ile): {birlesik_yeni}") # {'x': 10, 'y': 2}
print(f"dict_x (| sonrası): {dict_x}") # {'x': 1} (Değişmedi)
Bölüm 5: Sözlükten Öğeleri Silme
Sözlüklerden anahtar-değer çiftlerini kaldırmanın birkaç yolu vardır.

5.1. del dict[key] İfadesi
Belirtilen key'e sahip anahtar-değer çiftini sözlükten tamamen kaldırır.

Dikkat: Eğer belirtilen anahtar sözlükte bulunmuyorsa, KeyError hatası verir.

urun_stok = {"kalem": 50, "defter": 25, "silgi": 100}
print(f"Başlangıç: {urun_stok}")

'defter' anahtarını sil

del urun_stok["defter"]
print(f"'defter' silindi: {urun_stok}") # {'kalem': 50, 'silgi': 100}

Olmayan anahtarı silmeye çalışmak

try:
del urun_stok["cetvel"]
except KeyError as e:
print(f"\nHata (del): Anahtar bulunamadı - {e}")
del ifadesi ayrıca tüm sözlüğü bellekten silmek için de kullanılabilir (del sozluk_adi), ancak bu genellikle sözlüğün içeriğini boşaltmak için kullanılmaz (onun için clear() vardır).

5.2. pop(key, default=None) Metodu
Ne Yapar: Belirtilen key'e sahip anahtar-değer çiftini sözlükten siler ve silinen öğenin değerini döndürür.
Değişiklik: Sözlüğü yerinde (in-place) değiştirir.
Dönüş Değeri: Silinen öğenin değeri.
Güvenlik: Eğer key sözlükte bulunmuyorsa, varsayılan olarak KeyError verir. Ancak, isteğe bağlı ikinci bir default argümanı verilirse, anahtar bulunamadığında hata vermek yerine bu default değeri döndürülür (ve sözlük değişmez). Bu, KeyError almadan güvenli silme yapmak için kullanışlıdır.
ayarlar = {"tema": "koyu", "font_boyutu": 12, "dil": "tr"}
print(f"Başlangıç: {ayarlar}")

'font_boyutu'nu sil ve değerini al

silinen_deger1 = ayarlar.pop("font_boyutu")
print(f"pop('font_boyutu') sonrası: {ayarlar}") # {'tema': 'koyu', 'dil': 'tr'}
print(f"Dönen değer 1: {silinen_deger1}") # 12

Olmayan anahtarı silmeye çalış (hata verir)

try:
ayarlar.pop("renk")
except KeyError as e:
print(f"\nHata (pop): {e}")

Olmayan anahtarı varsayılan değerle güvenli silmeye çalış

varsayilan_donus = "Bilinmiyor"
silinen_deger2 = ayarlar.pop("renk", varsayilan_donus) # Anahtar yok, varsayılan döner
print(f"\nGüvenli pop sonrası: {ayarlar}") # {'tema': 'koyu', 'dil': 'tr'} (Değişmedi)
print(f"Dönen değer 2: {silinen_deger2}") # Bilinmiyor
5.3. popitem() Metodu
Ne Yapar: Sözlükten bir anahtar-değer çiftini siler ve bu çifti (anahtar, değer) şeklinde bir demet (tuple) olarak döndürür.
Sıra (Python 3.7+): Son eklenen öğeyi (LIFO — Last-In, First-Out sırası) siler ve döndürür.
Sıra (Python 3.6 ve öncesi): Rastgele bir öğeyi siler ve döndürürdü.
Değişiklik: Sözlüğü yerinde (in-place) değiştirir.
Dönüş Değeri: Silinen (anahtar, değer) çiftini içeren bir tuple.
Hata: Eğer sözlük boşsa KeyError hatası verir.
sozluk = {'a': 1, 'b': 2, 'c': 3}
print(f"Başlangıç: {sozluk}")

Son ekleneni sil ve al (Python 3.7+)

silinen_cift1 = sozluk.popitem()
print(f"popitem() sonrası: {sozluk}") # {'a': 1, 'b': 2}
print(f"Dönen çift 1: {silinen_cift1}") # ('c', 3)
silinen_cift2 = sozluk.popitem()
print(f"İkinci popitem() sonrası: {sozluk}") # {'a': 1}
print(f"Dönen çift 2: {silinen_cift2}") # ('b', 2)

Boş sözlüğe popitem uygulamak

bos = {}
try:
bos.popitem()
except KeyError as e:
print(f"\nBoş sözlük hatası: {e}") # Boş sözlük hatası: 'popitem(): dictionary is empty'
5.4. clear() Metodu
Ne Yapar: Sözlükteki tüm anahtar-değer çiftlerini siler, sözlüğü boşaltır.
Değişiklik: Sözlüğü yerinde (in-place) değiştirir.
Dönüş Değeri: None
silinecek_sozluk = {"bir": 1, "iki": 2}
print(f"Başlangıç: {silinecek_sozluk}")
silinecek_sozluk.clear()
print(f"Clear sonrası: {silinecek_sozluk}") # {}
Bölüm 6: Sözlük Görünümleri (Dictionary Views): keys(), values(), items()
Python sözlükleri, içeriklerine farklı perspektiflerden bakmamızı sağlayan üç özel metot sunar: keys(), values() ve items(). Bu metotlar doğrudan listeler veya demetler döndürmezler; bunun yerine görünüm (view) nesneleri döndürürler.

Görünüm Nesnelerinin Özellikleri:

Dinamiktirler: Orijinal sözlükte bir değişiklik yapıldığında (öğe ekleme, silme vb.), bu değişiklik görünüme otomatik olarak yansır. Yani görünüm, sözlüğün o anki durumunu temsil eder.
Yinelenebilirdirler (Iterable): for döngüsü ile doğrudan üzerlerinde gezinebilirsiniz.
Üyelik Testini Desteklerler: in operatörü ile bir öğenin görünümde olup olmadığını kontrol edebilirsiniz (keys() için anahtar, values() için değer, items() için (anahtar, değer) çifti).
Liste veya Demete Çevrilebilirler: list() veya tuple() fonksiyonları ile statik bir listeye veya demete dönüştürülebilirler.
6.1. keys() Metodu
Ne Döndürür: Sözlükteki tüm anahtarları içeren bir görünüm nesnesi (dict_keys).
urun_fiyatlari = {"elma": 5, "armut": 7, "muz": 10}
anahtarlar = urun_fiyatlari.keys()
print(f"Anahtarlar Görünümü: {anahtarlar}") # dict_keys(['elma', 'armut', 'muz'])
print(f"Görünüm Tipi: {type(anahtarlar)}")

Görünüm üzerinde iterasyon

print("\nAnahtarlar:")
for anahtar in anahtarlar: # veya 'for anahtar in urun_fiyatlari:' da aynı işi yapar
print(f"- {anahtar}")

Üyelik testi

print(f"\n'elma' anahtar mı? {'elma' in anahtarlar}") # True
print(f"'portakal' anahtar mı? {'portakal' in anahtarlar}") # False

Listeye çevirme

anahtar_listesi = list(anahtarlar)
print(f"\nAnahtar Listesi: {anahtar_listesi}") # ['elma', 'armut', 'muz']

Sözlük değiştikten sonra görünüm de değişir

urun_fiyatlari["portakal"] = 8
print(f"\nSözlük Güncellendi.")
print(f"Güncel Anahtarlar Görünümü: {anahtarlar}") # dict_keys(['elma', 'armut', 'muz', 'portakal'])
print(f"Eski Anahtar Listesi (değişmedi): {anahtar_listesi}") # ['elma', 'armut', 'muz']
6.2. values() Metodu
Ne Döndürür: Sözlükteki tüm değerleri içeren bir görünüm nesnesi (dict_values). Değerler tekrarlanabilir.
urun_fiyatlari = {"elma": 5, "armut": 7, "muz": 10, "kivi": 7}
degerler = urun_fiyatlari.values()
print(f"Değerler Görünümü: {degerler}") # dict_values([5, 7, 10, 7])

Görünüm üzerinde iterasyon

print("\nDeğerler:")
for deger in degerler:
print(f"- {deger}")

Üyelik testi

print(f"\n7 değer mi? {7 in degerler}") # True
print(f"\n15 değer mi? {15 in degerler}") # False

Listeye çevirme

deger_listesi = list(degerler)
print(f"\nDeğer Listesi: {deger_listesi}") # [5, 7, 10, 7]

Sözlük değiştikten sonra görünüm de değişir

urun_fiyatlari["üzüm"] = 10
print(f"\nSözlük Güncellendi.")
print(f"Güncel Değerler Görünümü: {degerler}") # dict_values([5, 7, 10, 7, 10])
6.3. items() Metodu
Ne Döndürür: Sözlükteki tüm (anahtar, değer) çiftlerini (tuple olarak) içeren bir görünüm nesnesi (dict_items).
Bu metot, bir sözlüğün hem anahtarları hem de değerleri üzerinde aynı anda işlem yapmak istediğinizde en sık kullanılan yöntemdir (özellikle for döngülerinde tuple unpacking ile birlikte).
urun_fiyatlari = {"elma": 5, "armut": 7, "muz": 10}
ogeler = urun_fiyatlari.items()
print(f"Öğeler Görünümü: {ogeler}") # dict_items([('elma', 5), ('armut', 7), ('muz', 10)])

Görünüm üzerinde iterasyon (Tuple Unpacking ile)

print("\nAnahtar ve Değerler:")
for anahtar, deger in ogeler: # En yaygın kullanım şekli
print(f"- {anahtar.capitalize()}: {deger} TL")

Üyelik testi (tam çift olarak)

print(f"\n('armut', 7) öğe mi? {('armut', 7) in ogeler}") # True
print(f"\n('elma', 6) öğe mi? {('elma', 6) in ogeler}") # False

Listeye çevirme

oge_listesi = list(ogeler)
print(f"\nÖğe Listesi (tuple'lardan oluşan): {oge_listesi}")

[('elma', 5), ('armut', 7), ('muz', 10)]

Sözlük değiştikten sonra görünüm de değişir

urun_fiyatlari["çilek"] = 15
print(f"\nSözlük Güncellendi.")
print(f"Güncel Öğeler Görünümü: {ogeler}")

dict_items([('elma', 5), ('armut', 7), ('muz', 10), ('çilek', 15)])

Bölüm 7: Diğer Sözlük İşlemleri ve Kopyalama
7.1. Uzunluk (len())
len(sozluk) fonksiyonu, sözlükteki anahtar-değer çifti sayısını (yani anahtar sayısını) döndürür.

sozluk = {"a": 1, "b": 2, "c": 3}
print(f"Sözlük uzunluğu: {len(sozluk)}") # 3
7.2. Üyelik Testi (in / not in)
key in sozluk ifadesi, belirtilen key'in sözlüğün anahtarları arasında olup olmadığını kontrol eder ve True veya False döndürür. Bu işlem sözlükler için çok verimlidir (ortalama O(1) zaman karmaşıklığı).

Not: in operatörü varsayılan olarak sadece anahtarlarda arama yapar. Değerlerde arama yapmak için deger in sozluk.values() kullanılmalıdır (bu daha az verimli olabilir).

ayarlar = {"tema": "koyu", "dil": "tr"}
print(f"'tema' anahtarı var mı? {'tema' in ayarlar}") # True
print(f"'font' anahtarı var mı? {'font' in ayarlar}") # False
print(f"'font' anahtarı yok mu? {'font' not in ayarlar}") # True
print(f"'koyu' değeri var mı? {'koyu' in ayarlar.values()}") # True
7.3. Sözlük Kopyalama
Listelerde olduğu gibi, sözlüklerde de kopyalama işlemi önemlidir. Basit bir atama (=) kopyalama yapmaz, sadece aynı sözlüğe işaret eden yeni bir referans (isim) oluşturur.

a) Referans Atama (Kopya Değil!)
orijinal = {"a": 1, "b": 2}
referans = orijinal # Bu bir kopya DEĞİL!
print(f"Orijinal: {orijinal}")
print(f"Referans: {referans}")
print(f"Orijinal is Referans? {orijinal is referans}") # True (Aynı nesne)

Referans üzerinden yapılan değişiklik orijinali de etkiler!

referans["c"] = 3
print(f"\nDeğişiklik sonrası Orijinal: {orijinal}") # {'a': 1, 'b': 2, 'c': 3}
print(f"Değişiklik sonrası Referans: {referans}") # {'a': 1, 'b': 2, 'c': 3}
b) Sığ Kopya (Shallow Copy)
Yeni bir sözlük nesnesi oluşturur, ancak içindeki değerler orijinal sözlükteki değerlere referans olarak kopyalanır. Değerler değiştirilemez ise sorun olmaz, ancak değiştirilebilir nesneler (listeler, başka sözlükler) içeriyorsa, kopyadaki referans üzerinden yapılan değişiklik orijinali de etkiler.

Sığ kopya yapmanın yolları:

sozluk.copy() metodu
dict(sozluk) yapıcısı
orijinal_sig = {"sayi": 10, "liste": [1, 2]}
print(f"Orijinal (Sığ): {orijinal_sig}")
kopya_sig_1 = orijinal_sig.copy()
kopya_sig_2 = dict(orijinal_sig)
print(f"Orijinal is Kopya1? {orijinal_sig is kopya_sig_1}") # False
print(f"Orijinal is Kopya2? {orijinal_sig is kopya_sig_2}") # False

Kopyadaki değiştirilemez değeri (sayi) değiştirelim

kopya_sig_1["sayi"] = 99
print(f"\nKopya1 (sayi değişti): {kopya_sig_1}") # {'sayi': 99, 'liste': [1, 2]}
print(f"Orijinal (sayi etkilenmedi): {orijinal_sig}") # {'sayi': 10, 'liste': [1, 2]}

Kopyadaki değiştirilebilir değeri (liste) değiştirelim

kopya_sig_1["liste"].append(3)
print(f"\nKopya1 (liste değişti): {kopya_sig_1}") # {'sayi': 99, 'liste': [1, 2, 3]}
print(f"Orijinal (ETKİLENDİ!): {orijinal_sig}") # {'sayi': 10, 'liste': [1, 2, 3]}
print(f"Orijinal liste ID: {id(orijinal_sig['liste'])}")
print(f"Kopya1 liste ID: {id(kopya_sig_1['liste'])}") # ID'ler aynı!
c) Derin Kopya (Deep Copy)
Tamamen bağımsız bir kopya oluşturur. Sadece sözlüğün kendisi değil, içindeki tüm değiştirilebilir nesneler de (ne kadar iç içe olurlarsa olsunlar) özyinelemeli olarak kopyalanır. Bunun için copy modülünün deepcopy() fonksiyonu kullanılır.

import copy
orijinal_derin = {"id": 1, "data": {"degerler": [100, 200]}}
print(f"Orijinal (Derin): {orijinal_derin}")
kopya_derin = copy.deepcopy(orijinal_derin)
print(f"Derin Kopya: {kopya_derin}")
print(f"Orijinal is Derin Kopya? {orijinal_derin is kopya_derin}") # False

Derin kopyadaki iç listeyi değiştirelim

kopya_derin["data"]["degerler"].append(300)
print(f"\nDerin Kopya (iç liste değişti): {kopya_derin}")

{'id': 1, 'data': {'degerler': [100, 200, 300]}}

print(f"Orijinal (ETKİLENMEDİ): {orijinal_derin}")

{'id': 1, 'data': {'degerler': [100, 200]}}

print(f"Orijinal iç liste ID: {id(orijinal_derin['data']['degerler'])}")
print(f"Derin Kopya iç liste ID: {id(kopya_derin['data']['degerler'])}") # ID'ler farklı!
Ne zaman hangi kopyalama yöntemini kullanacağınız, sözlüğünüzün yapısına ve kopyayla ne yapmak istediğinize bağlıdır. Genellikle, iç içe değiştirilebilir nesnelerle çalışıyorsanız ve tam bağımsızlık istiyorsanız deepcopy kullanmak en güvenlisidir.

Bölüm 8: Sözlükler Üzerinde İterasyon (Döngü)
Sözlüklerin içeriği üzerinde döngü kurmanın birkaç yaygın yolu vardır:

Anahtarlar Üzerinde İterasyon (Varsayılan): Bir sözlüğü doğrudan for döngüsüne sokarsanız, varsayılan olarak anahtarları üzerinde iterasyon yapar.

sozluk = {"a": 1, "b": 2, "c": 3} print("Anahtarlar (Varsayılan İterasyon):") for k in sozluk: print(f"- {k} (Değer: {sozluk[k]})") # Değere erişmek için tekrar lookup gerekir
Anahtarlar Üzerinde İterasyon (.keys() ile — Açıkça): Yukarıdakiyle aynı sonucu verir ancak daha açık bir ifadedir.

print("\nAnahtarlar (.keys() ile):") for k in sozluk.keys(): print(f"- {k}")
Değerler Üzerinde İterasyon (.values() ile): Sadece değerlere ihtiyacınız varsa kullanılır.

print("\nDeğerler (.values() ile):") for v in sozluk.values(): print(f"- {v}")
Anahtar-Değer Çiftleri Üzerinde İterasyon (.items() ile — En Yaygın): Hem anahtara hem de değere aynı anda erişmenin en verimli ve okunabilir yoludur. Tuple unpacking kullanılır.

print("\nAnahtar-Değer Çiftleri (.items() ile):") for anahtar, deger in sozluk.items(): print(f"- Anahtar: {anahtar}, Değer: {deger}")
Sonuç
Python sözlükleri (Dictionaries), anahtar-değer çiftlerini kullanarak verileri esnek ve verimli bir şekilde saklamak ve yönetmek için vazgeçilmez bir veri yapısıdır. Değiştirilebilir (mutable) olmaları ve (Python 3.7+ itibarıyla) eklenme sırasını korumaları onları son derece kullanışlı kılar. Anahtarların benzersiz ve değiştirilemez olması gerektiği kuralı, sözlüklerin temel çalışma prensibini oluşturur.

Sözlük oluşturmanın çeşitli yolları ({}, dict(), comprehensions), öğelere erişim yöntemleri ([], get()), değiştirme ve silme işlemleri (=, update(), del, pop(), popitem(), clear()) ve içeriklerini incelemek için kullanılan görünüm metotları (keys(), values(), items()) sözlüklerle çalışırken bilinmesi gereken temel araçlardır.

Verileri hızlı bir şekilde aramak (lookup), yapılandırılmış bilgileri (JSON gibi) temsil etmek, nesnelerin özelliklerini saklamak, konfigürasyonları yönetmek veya frekans saymak gibi birçok görev için sözlükler ideal bir çözümdür. Kopyalama (sığ ve derin) ve iterasyon tekniklerini doğru anlamak, sözlükleri hatasız ve verimli bir şekilde kullanmanıza yardımcı olur.

Python’daki bu temel ve güçlü veri yapısını etkin bir şekilde kullanarak daha organize, okunabilir ve performanslı kodlar yazabilirsiniz.

Abdulkadir Güngör - Kişisel WebSite
Abdulkadir Güngör - Kişisel WebSite
Abdulkadir Güngör - Özgeçmiş
Github
Github
Linkedin