Python Sözlük Anlaması: Bilmeniz Gereken Temeller

Python Sözlüğü Nedir?

Python’da bir sözlük, öğelere indeksle değil belirli bir anahtarla erişilen bir koleksiyondur. Bu ne anlama gelir?

Gerçek dünyadaki bir sözlüğü düşünün. Bir kelimenin anlamına bakmanız gerektiğinde, kelimenin olası indeksini değil, kelimenin kendisini kullanırsınız. Python sözlükleri de aynı kavramla çalışır: Anlamına baktığınız kelime anahtardır, kelimenin anlamı ise değerdir. Anlamını bulmak için bir sözlükte kelimenin indeksini bilmenize gerek yoktur.

Python’da bir sözlük başlatma

Python’da bir sözlüğü şu şekilde başlatabilirsiniz:

a = {'apple': 'fruit', 'beetroot': 'vegetable', 'cake': 'dessert'}
a['doughnut'] = 'snack'
print(a['apple'])
Altyapı:

fruit
Altyapı:

print(a[0])
Altyapı:

---------------------------------------------------------------------------

KeyError                                  Traceback (most recent call last)

<ipython-input-9-00d4a978143a> in <module>()
----> 1 print(a[0])


KeyError: 0

Altyapı:

İlk olarak, a adlı ve üç anahtar-değer çifti içeren bir sözlük oluşturuyoruz: 'apple': 'fruit', 'beetroot': 'vegetable' ve 'cake': 'dessert'. Anahtarlar, öğelerin adlarını temsil eden dizgelerdir; değerler ise öğenin türünü veya kategorisini temsil eden dizgelerdir.

Ardından a sözlüğüne a ['doughnut'] = 'snack' sözdizimini kullanarak yeni bir anahtar-değer çifti ekliyoruz. Bu, sözlüğe 'doughnut' anahtarını ve karşılık gelen 'snack' değerini ekler.

Koddaki üçüncü satır, a sözlüğünde 'apple' anahtarına karşılık gelen değeri yazdırır. 'apple' sözlükte bir anahtar olduğundan, kod 'fruit' değerini yazdırır.

Koddaki dördüncü satır ise a sözlüğünde geçerli bir anahtar olmayan 0 anahtarına karşılık gelen değeri yazdırmayı dener. Bu da sözlükte var olmayan bir anahtara erişilmeye çalışıldığında ortaya çıkan bir KeyError ile sonuçlanır.

Python sözlük veri türleri

Bir sözlükteki öğeler herhangi bir veri türünde olabilir. Mantığını kavramak için aşağıdaki sözlük örneklerine göz atın:

Dört anahtar-değer çiftiyle bir a sözlüğü oluşturun:

a = {'one': 1, 'two': 'to', 'three': 3.0, 'four': [4,4.0]}
print(a)Altyapı:

a sözlüğünde 'one' anahtarına karşılık gelen değeri 1.0 olarak güncelleyin.

# Update a dictionary
a['one'] = 1.0 
print(a)Altyapı:

{'four': [4, 4.0], 'two': 'to', 'three': 3.0, 'one': 1.0}Altyapı:

a sözlüğünden 'one' anahtarına karşılık gelen anahtar-değer çiftini silin.

# Delete a single element
del a['one'] 
print(a)Altyapı:

{'four': [4, 4.0], 'two': 'to', 'three': 3.0}Altyapı:

clear() yöntemini kullanarak a sözlüğündeki tüm anahtar-değer çiftlerini kaldırın.

# Delete all elements in the dictionary
a.clear()
print(a)Altyapı:

{}Altyapı:

del anahtar sözcüğünü kullanarak a sözlüğünü silin.

# Delete the dictionary
del a 
print(a)
Altyapı:

---------------------------------------------------------------------------

NameError                                 Traceback (most recent call last)

<ipython-input-12-701c9d6596da> in <module>()
      1 del a #Deletes the dictionary
----> 2 print(a)


NameError: name 'a' is not defined
Altyapı:

Bir sözlükte anahtarın benzersiz olması gerektiğini unutmamak önemlidir; yinelenenlere izin verilmez. Ancak yinelenen anahtarlar söz konusu olduğunda Python hata vermek yerine anahtarın son örneğini geçerli kabul eder ve ilk anahtar-değer çiftini yok sayar. Kendiniz görün:

sweet_dict = {'a1': 'cake', 'a2':'cookie', 'a1': 'icecream'}
print(sweet_dict['a1'])
Altyapı:

icecream
Altyapı:

Python Sözlük Anlaması

Sözlük anlaması, bir sözlüğü başka bir sözlüğe dönüştürme yöntemidir. Bu dönüşüm sırasında, özgün sözlükteki öğeler koşullu olarak yeni sözlüğe dahil edilebilir ve her bir öğe gerektiği gibi dönüştürülebilir.

İyi bir liste anlaması (list comprehension) kodunuzu daha ifade edici ve dolayısıyla daha okunabilir hale getirebilir. Anlamalar oluşturmanın püf noktası, onları ne yaptıklarını çözmeye çalıştığınızda başınızı döndürecek kadar karmaşık hale getirmemektir. "Okuması kolay" ilkesini canlı tutun.

Python’da sözlük anlaması yapmanın yolu, bir sözlüğün key (anahtar) ve value (değer) nesnelerine erişebilmektir.

Bu nasıl yapılır?

Python bu konuda yardımcı olur! Yerleşik yöntemleri doğrudan kullanabilirsiniz:

dict1 = {'a': 1, 'b': 2, 'c': 3, 'd': 4}
# Put all keys of `dict1` in a list and returns the list
dict1.keys()
Altyapı:

dict_keys(['c', 'd', 'a', 'b'])
Altyapı:

# Put all values saved in `dict1` in a list and returns the list
dict1.values()
Altyapı:

dict_values([3, 4, 1, 2])
Altyapı:

Yukarıdaki kod, dört anahtar-değer çifti içeren dict1 adlı bir Python sözlüğü oluşturur. Sözlük üzerinde keys() yöntemi çağrılır ve sözlükteki tüm anahtarları içeren bir görünüm nesnesi döndürür.

Ayrıca sözlük üzerinde values() yöntemi de çağrılır ve sözlükteki tüm değerleri içeren bir görünüm nesnesi döndürür.

Her iki görünüm nesnesi de kümeler gibi davranır ve sırasıyla anahtarlar ve değerler üzerinde küme işlemleri yapmak için kullanılabilir.

Görünüm nesnelerindeki anahtarların ve değerlerin sırasının, sözlüğe eklendikleri sırayla aynı olacağının garanti edilmediğine dikkat edin.

Basit değer dönüştürme 

Basit bir sözlük anlamasıyla başlayalım:

dict1 = {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5}
# Double each value in the dictionary
double_dict1 = {k:v*2 for (k,v) in dict1.items()}
print(double_dict1)
Altyapı:

{'e': 10, 'a': 2, 'c': 6, 'b': 4, 'd': 8}
Altyapı:

Yukarıdaki anlama kodunda, dict1 sözlüğündeki her değeri ikiyle çarparak yeni bir double_dict1 sözlüğü oluşturuyoruz.

Anahtarları da değiştirebilirsiniz. Örneğin, yukarıdakiyle aynı sözlüğü oluşturalım ama anahtar adlarını da değiştirelim.

dict1_keys = {k*2:v for (k,v) in dict1.items()}
print(dict1_keys)
Altyapı:

{'dd': 4, 'ee': 5, 'aa': 1, 'bb': 2, 'cc': 3}
Altyapı:

items() yöntemini kullanma

Artık bir sözlükteki tüm anahtarlara ve değerlerine nasıl erişeceğinizi bildiğinize göre, items() yöntemini kullanarak bir sözlük içindeki her anahtar-değer çiftine de erişebilirsiniz:

dict1.items()
Altyapı:

dict_items([('c', 3), ('d', 4), ('a', 1), ('b', 2)])
Altyapı:

Python’da sözlük anlaması için izleyebileceğiniz genel şablon şudur:

dict_variable = {key:value for (key,value) in dictonary.items()}
Altyapı:

Bu, temel ve en basit şablon olarak hizmet edebilir. Buna koşullar ekledikçe daha karmaşık hale gelebilir.

fromkeys() yöntemini kullanma

Python ayrıca, belirli bir anahtar kümesi için uniform bir değerle sözlük oluşturmanıza olanak tanıyan fromkeys() yöntemini sunar. Bu yöntem, sözlükleri varsayılan değerlerle başlatırken kullanışlıdır. Şuna bakın:

# Create a dictionary with keys ranging from 0 to 4, all set to True
my_dict = dict.fromkeys(range(5), True)
print(my_dict)Altyapı:

{0: True, 1: True, 2: True, 3: True, 4: True}Altyapı:

Bu örnekte, fromkeys() yöntemi anahtarları 0’dan 4’e kadar olan ve her anahtara True değeri atanan bir sözlük oluşturur. Bu yaklaşım, sözlükleri daha sonra güncellemek veya işlemek için başlatma gibi görevleri basitleştirir.

Neden Sözlük Anlaması Kullanılır?

Sözlük anlaması güçlü bir kavramdır ve for döngülerinin ve lambda işlevlerinin yerine kullanılabilir. Ancak, her for döngüsü sözlük anlamasıyla yazılamaz; fakat her sözlük anlaması bir for döngüsüyle yazılabilir.

0-10 aralığında 2’ye bölünebilen sayıların anahtar olduğu ve değerinin sayının karesi olduğu yeni bir sözlük oluşturmak istediğiniz aşağıdaki problemi düşünün.

Aynı problemi bir for döngüsü ve sözlük anlaması kullanarak nasıl çözebileceğinize bakalım:

numbers = range(10)
new_dict_for = {}

# Add values to `new_dict` using for loop
for n in numbers:
    if n%2==0:
        new_dict_for[n] = n**2

print(new_dict_for)
Altyapı:

{0: 0, 8: 64, 2: 4, 4: 16, 6: 36}
Altyapı:

# Use dictionary comprehension
new_dict_comp = {n:n**2 for n in numbers if n%2 == 0}

print(new_dict_comp)
Altyapı:

{0: 0, 8: 64, 2: 4, 4: 16, 6: 36}Altyapı:

For döngülerine alternatif

For döngüleri, bir programda belirli bir işlemi veya talimat bloğunu belirli sayıda tekrar etmek için kullanılır. Ancak iç içe for döngüleri (bir for döngüsünün içinde başka bir for döngüsü) kafa karıştırıcı ve karmaşık olabilir. Böyle durumlarda sözlük anlamaları daha iyidir; okunabilirliği ve kodu anlama sürecinizi basitleştirir.

İpucu: Python’daki döngüler hakkında daha fazla bilgi için DataCamp’in Python’da Döngüler eğitimine göz atın.

Lambda işlevlerine alternatif

Lambda işlevleri küçük, isimsiz işlevler oluşturmanın bir yoludur. Bunlar adı olmayan işlevlerdir. Yalnızca oluşturuldukları yerde ihtiyaç duyulan, tek kullanımlık işlevlerdir. Lambda işlevleri çoğunlukla filter(), map() ve reduce() işlevleriyle birlikte kullanılır.

Şimdi map() işleviyle birlikte lambda işlevine bakalım:

# Initialize `fahrenheit` dictionary 
fahrenheit = {'t1':-30, 't2':-20, 't3':-10, 't4':0}

#Get the corresponding `celsius` values
celsius = list(map(lambda x: (float(5)/9)*(x-32), fahrenheit.values()))

#Create the `celsius` dictionary
celsius_dict = dict(zip(fahrenheit.keys(), celsius))

print(celsius_dict)
Altyapı:

{'t2': -28.88888888888889, 't3': -23.333333333333336, 't1': -34.44444444444444, 't4': -17.77777777777778}
Altyapı:

Ayrıntılı Bir Python Sözlük Anlaması Örneği

Fahrenheit sıcaklıklarından oluşan bir sözlüğü Celsius’a dönüştürmek istediğiniz başka bir duruma bakalım.

Kodu parçalara ayıralım: Önce Fahrenheit’tan Celsius’a dönüşümü yapan matematiksel formülü tanımlamanız gerekir.

Kodda bu, lambda işlevinin yardımıyla yapılır. Ardından bu işlevi map() işlevine argüman olarak geçirirsiniz; fahrenheit.values() listesindeki her öğeye bu işlemi uygular.

values() işlevini hatırladınız mı? Sözlükte saklanan öğeleri içeren bir liste döndürür.

Elinizde artık sıcaklık değerlerini Celsius cinsinden içeren bir liste var; ancak çözümün bir sözlük olması gerekiyor.

Python’da yinelemelerin öğeleri üzerinde dolaşan ve onları bir araya getiren zip() adlı yerleşik bir işlev vardır. Bu Python örneğinde zip() işlevi hakkında daha fazla okuyabilirsiniz.

Yukarıdaki örneğimizde zip işlevi, fahrenheit.keys() öğeleriyle celsius listesini birleştirir; böylece dict işlevini kullanarak sözlük haline getirebileceğiniz anahtar-değer çiftleri elde edersiniz; istenen sonuç budur.

Şimdi aynı problemi sözlük anlaması kullanarak çözmeyi deneyelim:

# Initialize the `fahrenheit` dictionary 
fahrenheit = {'t1': -30,'t2': -20,'t3': -10,'t4': 0}

# Get the corresponding `celsius` values and create the new dictionary
celsius = {k:(float(5)/9)*(v-32) for (k,v) in fahrenheit.items()}

print(celsius_dict)
Altyapı:

{'t2': -28.88888888888889, 't3': -23.333333333333336, 't1': -34.44444444444444, 't4': -17.77777777777778}
Altyapı:

Yukarıdaki kodda neler oluşturduğumuzu adım adım açıklayalım: 

1. Fahrenheit cinsinden sıcaklık okumalarını temsil eden dört anahtar-değer çifti içeren fahrenheit adlı bir sözlük oluşturun.

2. celsius adlı yeni bir sözlük tanımlayın.

3. fahrenheit sözlüğü üzerinde yinelenmek ve Fahrenheit sıcaklıklarını (5/9) * (F-32) formülünü kullanarak Celsius’a dönüştürmek için sözlük anlaması kullanın.

4. fahrenheit içindeki her anahtar-değer çifti için, anahtar k değişkenine, değer ise v değişkenine atanır.

5. Her Fahrenheit sıcaklığına karşılık gelen Celsius değeri yukarıdaki formülle hesaplanır ve celsius sözlüğüne anahtar-değer çifti olarak eklenir.

6. Ortaya çıkan celsius sözlüğü konsola yazdırılır.

Gördüğünüz gibi, ilk uygulamada üç işlevin (lambda, map() ve zip()) nasıl çalıştığını anlamayı ve iki adımı gerektiren çözüme kıyasla, sözlük anlamasıyla problem tek satır kodla çözülebilir.

Ayrıca, sözlük anlamasıyla çözüm sezgiseldir ve anlaşılması kolaydır. Bu nedenle sözlük anlaması, lambda işlevlerine iyi bir alternatif olabilir.

Sözlük Anlamasına Koşullar Ekleme

Problemlerle uğraşırken çözüme sıklıkla koşullar eklemeniz gerekir. Sözlük anlamasını daha güçlü kılmak için koşulları nasıl ekleyebileceğinizi inceleyelim.

If koşulu

Diyelim ki verilen bir sözlükten, değeri 2’den büyük olan öğelerle yeni bir sözlük oluşturmanız gerekiyor. Bu, yukarıda gördüğünüz özgün şablona bir koşul eklemeniz gerektiği anlamına gelir...

dict1 = {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5}

# Check for items greater than 2
dict1_cond = {k:v for (k,v) in dict1.items() if v>2}

print(dict1_cond)
Altyapı:

{'e': 5, 'c': 3, 'd': 4}
Altyapı:

O kadar da zor değil! Peki ya birden çok koşul varsa?

Birden çok if koşulu

Yukarıdaki problemde, yalnızca 2’den büyük olan öğeleri almakla kalmayıp aynı zamanda aynı anda 2’nin katı olup olmadıklarını da kontrol etmeniz gerekirse ne olur?

dict1_doubleCond = {k:v for (k,v) in dict1.items() if v>2 if v%2 == 0}
print(dict1_doubleCond)
Altyapı:

{'d': 4}
Altyapı:

Birden çok koşul eklemenin çözümü, anlamanızda koşulları art arda eklemek kadar kolaydır. Ancak, problemde ne yapmaya çalıştığınız konusunda dikkatli olmalısınız. Art arda gelen if deyimlerinin aralarında and bağlacı varmış gibi çalıştığını unutmayın.

Üç koşullu bir örneğe daha bakalım:

dict1 = {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5, 'f':6}

dict1_tripleCond = {k:v for (k,v) in dict1.items() if v>2 if v%2 == 0 if v%3 == 0}

print(dict1_tripleCond)
Altyapı:

{'f': 6}
Altyapı:

Bir for döngüsünde bunun karşılığı şöyledir:

dict1_tripleCond = {}

for (k,v) in dict1.items():
    if (v>=2 and v%2 == 0 and v%3 == 0):
            dict1_tripleCond[k] = v

print(dict1_tripleCond)
Altyapı:

{'f': 6}Altyapı:

If-else koşulları

Bir if-else koşuluyla çalışmak da sözlük anlamasında kolaydır. Kendiniz görmek için aşağıdaki örneğe göz atın:

dict1 = {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5, 'f':6}

# Identify odd and even entries
dict1_tripleCond = {k:('even' if v%2==0 else 'odd') for (k,v) in dict1.items()}

print(dict1_tripleCond)
Altyapı:

{'f': 'even', 'c': 'odd', 'b': 'even', 'd': 'even', 'e': 'odd', 'a': 'odd'}Altyapı:

İç içe sözlük anlaması

İç içelik (nesting), verilerin katmanlar halinde düzenlendiği veya nesnelerin başka benzer nesneler içerdiği bir programlama kavramıdır. Çoğu zaman iç içe bir ‘if’ yapısı görmüşsünüzdür; bu, başka bir if koşulunun içinde yer alan bir if koşuludur.

Benzer şekilde, sözlükler iç içe olabilir; dolayısıyla anlamaları da iç içe olabilir. Bunun ne anlama geldiğine bakalım:

nested_dict = {'first':{'a':1}, 'second':{'b':2}}
float_dict = {outer_k: {float(inner_v) for (inner_k, inner_v) in outer_v.items()} for (outer_k, outer_v) in nested_dict.items()}
print(float_dict)
Altyapı:

{'first': {1.0}, 'second': {2.0}}
Altyapı:

Bu bir iç içe sözlük örneğidir. nested_dict, değerlerinde sözlük nesneleri bulunan first ve second anahtarlarına sahip bir sözlüktür. Kod, iç sözlük değerleriyle çalışır, onları float’a dönüştürür ve ardından dış anahtarları yeni float iç değerlerle birleştirerek yeni bir sözlük oluşturur.

Kod aynı zamanda bir iç içe sözlük anlaması içerir; yani bir sözlük anlamasının içinde başka bir sözlük anlaması vardır. İç içe olduğunda sözlük anlaması okumak ve anlamak oldukça zorlaşabilir; bu da başta anlamaları kullanmanın amacını ortadan kaldırır.

Üzerinde çalıştığınız sözlüğün yapısı karmaşıklaştıkça sözlük anlaması da karmaşıklaşır. Böyle durumlarda, kodunuzda karmaşık anlamalar kullanmamak daha iyi olabilir.

Not: Yukarıdaki kod parçasını iç içe for döngüsüyle de yeniden yazabilirsiniz:

nested_dict = {'first':{'a':1}, 'second':{'b':2}}

for (outer_k, outer_v) in nested_dict.items():
    for (inner_k, inner_v) in outer_v.items():
        outer_v.update({inner_k: float(inner_v)})
nested_dict.update({outer_k:outer_v})

print(nested_dict)
Altyapı:

{'first': {'a': 1.0}, 'second': {'b': 2.0}}
Altyapı:

Son Düşünceler

Umarız artık Python’daki sözlükleri, anlama (comprehension) kavramını ve Python sözlük anlamasının neden ve nerede yararlı olabileceğini öğrendiniz. 

Pratik yaptıkça Python’unuz gelişir! Kodunuzu geliştirmek için en iyi Python ipuçları ve püf noktalarımıza göz atın veya en önemli konularda ustalaşmak için Python Data Fundamentals yolumuzu tamamlayın.