Python Dictionary – Sözlük

Sözlük, Python’da Eşleme olarak da bilinen bir anahtar değer deposu örneğidir.

Sözlük, Python’da Eşleme olarak da bilinen bir anahtar değer deposu örneğidir. Bir anahtara başvurarak öğeleri saklamanıza ve almanıza olanak tanır. Sözlüklere anahtarla başvurulduğu için, arama işlemleri çok hızlıdır. Öğelere anahtarla başvurmak için kullanıldıklarından sıralanmazlar.

Sözlük – dict oluşturma

Sözlükler birçok şekilde oluşturulabilir:

söz dizimi 

# sözlük oluşturma ve değerlerle doldurma
stock = {'eggs': 5, 'milk': 2}

# Veya boş bir sözlük oluşturma
dictionary = {}

# Ve sonra değerlerle doldurmak
dictionary['eggs'] = 5
dictionary['milk'] = 2

# Değerler liste de olabilir
mydict = {'a': [1, 2, 3], 'b': ['one', 'two', 'three']}

# Değerler listesine yeni öğeler eklemek için list.append() yöntemini kullanın
mydict['a'].append(4)   # => {'a': [1, 2, 3, 4], 'b': ['one', 'two', 'three']}
mydict['b'].append('four')  # => {'a': [1, 2, 3, 4], 'b': ['one', 'two', 'three', 'four']}

# Ayrıca iki öğeli tuple'lardan oluşan bir liste kullanarak da bir sözlük oluşturabiliriz
iterable = [('eggs', 5), ('milk', 2)]
dictionary = dict(iterables)

# Ya da anahtar kelime argümanını kullanarak:
dictionary = dict(eggs=5, milk=2)

# Başka bir yol da dict.fromkeys kullanmak olacaktır:
dictionary = dict.fromkeys((milk, eggs))  # => {'milk': None, 'eggs': None}
dictionary = dict.fromkeys((milk, eggs), (2, 5))  # => {'milk': 2, 'eggs': 5}
# Ayrıca bir veya birden fazla sözlüğü benzer sözdizimiyle açmak da mümkündür

# otherdict'in sığ bir kopyasını yapar
d = {**otherdict}
# ayrıca sığ kopyayı yetanotherdict'in içeriği ile günceller.
d = {**otherdict, **yetanotherdict}

dict comprehension 

d = {k:v for k,v in [('key', 'value',)]}

yerleşik class: dict() 

d = dict()                    # boş dict
d = dict(key='value')         # açık anahtar kelime argümanları
d = dict([('key', 'value')])  # anahtar/değer çiftlerinin bir listesini iletme
# başka bir dict'in sığ bir kopyasını oluşturun (anahtarlar yalnızca dizeler ise mümkündür!)
d = dict(**otherdict)

dict() oluşturucusu, anahtar sözcük değişkenlerinden veya anahtar-değer çiftlerinin yinelenebilir öğelerinden ya da tek bir sözlük ve anahtar sözcük bağımsız değişkenlerinden sözlükler oluşturmak için kullanılabilir. 

dict(a=1, b=2, c=3)                   # {'a': 1, 'b': 2, 'c': 3}
dict([('d', 4), ('e', 5), ('f', 6)])  # {'d': 4, 'e': 5, 'f': 6}
dict([('a', 1)], b=2, c=3)            # {'a': 1, 'b': 2, 'c': 3}
dict({'a' : 1, 'b' : 2}, c=3)         # {'a': 1, 'b': 2, 'c': 3}

sözlükte değişiklik yapma 

Bir sözlüğe öğe eklemek için, değer içeren yeni bir anahtar oluşturmak yeterlidir:

d['newkey'] = 42

Değer olarak liste ve sözlük eklemek de mümkündür:

d['new_list'] = [1, 2, 3]
d['new_dict'] = {'nested_dict': 1}

Bir öğeyi silmek için anahtarı sözlükten silmek yeterli olur:

del d['newkey']

Söz dizimi 

  • mydict = {}
  • mydict[k] = value
  • value = mydict[k]
  • value = mydict.get(k)
  • value = mydict.get(k, “default_value”)

Parametreler 

  • key | Aranmak istenen anahtar
  • value | Ayarlanacak veya döndürülecek değer

Notlar 

Sözlük oluştururken aşağıdaki bilgileri hatırlamanız faydalı olabilir:

  • Her anahtar benzersiz olmalıdır (aksi takdirde üst üste yazılır)
  • Her anahtar hashlenebilir olmalıdır (hashlemek için hash fonksiyonu kullanılabilir; aksi takdirde TypeError atılır)
  • Anahtarlar için belirli bir sıra yoktur.

Sondaki virgül

Listeler ve tuple’lar gibi, sözlüğünüzün sonuna virgül ekleyebilirsiniz.

role = {"By day": "A typical programmer",
        "By night": "Still a typical programmer", }

PEP 8, sondaki virgül ile kapanış parantezi arasında bir boşluk bırakmanız gerektiğini belirtir.

dict constructor

dict() yapıcısı, anahtar sözcük argümanlarından veya anahtar-değer çiftlerinden oluşan tek bir yinelenebilir öğeden ya da tek bir sözlük ve anahtar sözcük argümanlarından sözlükler oluşturmak için kullanılabilir.

dict(a=1, b=2, c=3)                   # {'a': 1, 'b': 2, 'c': 3}
dict([('d', 4), ('e', 5), ('f', 6)])  # {'d': 4, 'e': 5, 'f': 6}
dict([('a', 1)], b=2, c=3)            # {'a': 1, 'b': 2, 'c': 3}
dict({'a' : 1, 'b' : 2}, c=3)         # {'a': 1, 'b': 2, 'c': 3}

Varsayılan değerlere sahip sözlük

Standart kütüphanede defaultdict olarak mevcuttur

from collections import defaultdict

d = defaultdict(int)
d['key']                         # 0
d['key'] = 5
d['key']                         # 5

d = defaultdict(lambda: 'empty')
d['key']                         # 'empty'
d['key'] = 'full'
d['key']                         # 'full'

[*] Alternatif olarak, yerleşik dict sınıfını kullanmanız gerekiyorsa, dict.setdefault() işlevini kullanmak, daha önce var olmayan bir anahtara her eriştiğinizde bir varsayılan oluşturmanıza olanak tanır:

>>> d = {}
{}
>>> d.setdefault('Another_key', []).append("This worked!")
>>> d
{'Another_key': ['This worked!']}

Eklenecek çok sayıda değeriniz varsa, dict.setdefault() işlevinin her çağrıldığında başlangıç değerinin (bu örnekte []) yeni bir örneğini oluşturacağını ve bunun gereksiz iş yükü yaratabileceğini unutmayın.

[*] Python Cookbook, 3rd edition, by David Beazley and Brian K. Jones (O’Reilly). Copyright 2013 David Beazley and Brian Jones, 978-1-449-34037-7.

Sıralı bir sözlük oluşturma

Sözlükteki anahtarlar üzerinde yineleme yaparken belirli bir sırayı takip edecek sıralı bir sözlük oluşturabilirsiniz.

collections modülündeki OrderedDict öğesini kullanabilirsiniz. Bu, üzerinde yineleme yapıldığında sözlük öğelerini her zaman orijinal ekleme sırasına göre döndürür.

from collections import OrderedDict

d = OrderedDict()
d['first'] = 1
d['second'] = 2
d['third'] = 3
d['last'] = 4

# Çıktı: "first 1", "second 2", "third 3", "last 4"
for key in d:
    print(key, d[key])

Sözlükleri ** işlecini kullanarak açma

Bir sözlükteki anahtar-değer çiftlerini bir fonksiyonun argümanlarına göndermek için ** anahtar sözcüğü argüman açma operatörünü kullanabilirsiniz. Resmi belgelerden basitleştirilmiş bir örnek:

>>>
>>> def parrot(voltage, state, action):
...     print("This parrot wouldn't", action, end=' ')
...     print("if you put", voltage, "volts through it.", end=' ')
...     print("E's", state, "!")
...
>>> d = {"voltage": "four million", "state": "bleedin' demised", "action": "VOOM"}
>>> parrot(**d)

This parrot wouldn't VOOM if you put four million volts through it. E's bleedin' demised !

Python 3.5’ten itibaren bu sözdizimini rastgele sayıda dict nesnesini birleştirmek için de kullanabilirsiniz.

>>> fish = {'name': "Nemo", 'hands': "fins", 'special': "gills"}
>>> dog = {'name': "Clifford", 'hands': "paws", 'color': "red"}
>>> fishdog = {**fish, **dog}
>>> fishdog

{'hands': 'paws', 'color': 'red', 'name': 'Clifford', 'special': 'gills'}

Bu örnekte gösterildiği gibi, yinelenen anahtarlar en sondaki değerleriyle eşlenir (örneğin “Clifford”, “Nemo “yu geçersiz kılar).

Sözlük değerlerine erişme

dictionary = {"Hello": 1234, "World": 5678}
print(dictionary["Hello"])

Yukarıdaki kod 1234 yazdıracaktır.

Bu örnekteki “Hello” dizesi anahtar olarak adlandırılır. Anahtar köşeli parantez içine yerleştirilerek dict içinde bir değer aramak için kullanılır.

Dict tanımında ilgili iki nokta üst üste işaretinden sonra 1234 sayısı görülür. Buna, bu dict’te “Hello” ile eşlenen değer denir.

Mevcut olmayan bir anahtarla bu şekilde bir değer aramak bir KeyError istisnası oluşturur ve yakalanmazsa yürütmeyi durdurur. KeyError riskine girmeden bir değere erişmek istiyorsak, dictionary.get yöntemini kullanabiliriz. Varsayılan olarak, anahtar mevcut değilse, yöntem None değerini döndürür. Başarısız bir arama durumunda None yerine dönmesi için ikinci bir değer iletebiliriz.

w = dictionary.get("whatever")
x = dictionary.get("whatever", "nuh-uh")

Bu örnekte w, None değerini ve x, “nuh-uh” değerini alacaktır.

Anahtarlara ve değerlere erişme

Sözlüklerle çalışırken, genellikle sözlükteki tüm anahtarlara ve değerlere bir for döngüsü, bir list comprehension ile veya sadece düz bir liste olarak erişmek gerekir.

Şöyle bir sözlük verildiğinde:

mydict = {
    'a': '1',
    'b': '2'
}

keys() yöntemini kullanarak anahtarların bir listesini alabilirsiniz:

print(mydict.keys())
# Python2: ['a', 'b']
# Python3: dict_keys(['b', 'a'])

Bunun yerine bir değerler listesi istiyorsanız, values() yöntemini kullanırız:

print(mydict.values())
# Python2: ['1', '2']
# Python3: dict_values(['2', '1'])

Hem anahtar hem de ona karşılık gelen değerle çalışmak istiyorsanız items() yöntemini kullanabilirsiniz:

print(mydict.items())
# Python2: [('a', '1'), ('b', '2')]
# Python3: dict_items([('b', '2'), ('a', '1')])

NOT: dict sıralanmamış olduğundan, keys(), values() ve items() yöntemlerinin sıralama düzeni yoktur. Bu yöntemlerin döndürdüğü sıralamayı önemsiyorsanız sort(), sorted() veya bir OrderedDict kullanın.

Python 2/3 Farkı: Python 3’te, bu yöntemler listeler değil özel yinelenebilir nesneler döndürürler. Bu da Python 2’deki iterkeys(), itervalues() ve iteritems() yöntemlerinin eşdeğeridir. Bu nesneler, bazı farklılıklar olsa da çoğunlukla listeler gibi kullanılabilir. Daha fazla bilgi için PEP 3106.

Sözlük Üzerinde Yineleme

Bir sözlük üzerinde yineleme kullanırsanız (örneğin bir for deyimi ile), sözlüğün anahtarları üzerinde dolaşırsınız. Örneğin:

d = {'a': 1, 'b': 2, 'c':3}
for key in d:
    print(key, d[key])
# c 3
# b 2
# a 1

Aynı şey bir comprehension kullanıldığında da geçerlidir

print([key for key in d])
# ['c', 'b', 'a']

items() yöntemi, aynı anda hem anahtar hem de değer üzerinde döngü oluşturmak için kullanılabilir:

for key, value in d.items():
    print(key, value)
# c 3
# b 2
# a 1

values() yöntemi, beklendiği gibi yalnızca değerler üzerinde yineleme yapmak için kullanılabilir:

for key, value in d.values():
    print(key, value)
    # 3
    # 2
    # 1

Yukarıda söylediğimiz gibi, keys(), values() ve items() yöntemleri listeleri döndürür ve yineleyicileri döndürmek için üç ekstra iterkeys() itervalues() ve iteritems() yöntemi vardır.

Sözlük değerlerinin tüm kombinasyonlarını elde etme

options = {
	“x”: [“a”, “b”],
	“y”: [10, 20, 30]
}

Yukarıda gösterilen gibi bir sözlük verildiğinde, ilgili anahtar için keşfedilecek bir dizi değeri temsil eden bir liste vardır. Diyelim ki “y”=10 ile “x”=”a”, sonra “y”=10 ile “x”=”b” ve olası tüm kombinasyonları keşfedene kadar böyle devam etmek istiyorsunuz.

Aşağıdaki kodu kullanarak bu tür tüm değer kombinasyonlarını döndüren bir liste oluşturabilirsiniz.

import itertools

options = {
	“x”: [“a”, “b”],
	“y”: [10, 20, 30]
}

keys = options.keys()
values = (options[key] for key in keys)
combinations = [dict(zip(keys, combination)) for combination in itertools.product(*values)]
print combinations

Bu bize değişken kombinasyonlarında saklanan aşağıdaki listeyi verir:

[{'x': 'a', 'y': 10},
 {'x': 'b', 'y': 10},
 {'x': 'a', 'y': 20},
 {'x': 'b', 'y': 20},
 {'x': 'a', 'y': 30},
 {'x': 'b', 'y': 30}]

Sözlükleri birleştirme

Aşağıdaki sözlükleri göz önünde bulundurun:

>>> fish = {'name': "Nemo", 'hands': "fins", 'special': "gills"}
>>> dog = {'name': "Clifford", 'hands': "paws", 'color': "red"}

Python 3.5+ 

>>> fishdog = {**fish, **dog}
>>> fishdog
{'hands': 'paws', 'color': 'red', 'name': 'Clifford', 'special': 'gills'}

Bu örnekte gösterildiği gibi, yinelenen anahtarlar en sondaki değerleriyle eşlenir (örneğin “Clifford”, “Nemo “yu geçersiz kılar).

Python 3.3+ 

>>> from collections import ChainMap
>>> dict(ChainMap(fish, dog))
{'hands': 'fins', 'color': 'red', 'special': 'gills', 'name': 'Nemo'}

Bu teknikle, belirli bir anahtar için son değer yerine en öndeki değer öncelik kazanır (“Clifford”, “Nemo” lehine atılır).

Python 2.x, 3.x 

>>> from itertools import chain
>>> dict(chain(fish.items(), dog.items()))
{'hands': 'paws', 'color': 'red', 'name': 'Clifford', 'special': 'gills'}

Bu, birleştirme için ** tabanlı teknikte olduğu gibi en son değeri kullanır (“Clifford”, “Nemo “yu geçersiz kılar).

>>> fish.update(dog)
>>> fish
{'color': 'red', 'hands': 'paws', 'name': 'Clifford', 'special': 'gills'}

dict.update, bir öncekinin üzerine yazmak için ikinci dict’i kullanır.

Sözlükte KeyError İstisnalarını Önleme

Sözlükleri kullanırken sık karşılaşılan bir tuzak, var olmayan bir anahtara erişmektir. Bu genellikle bir KeyError istisnasıyla sonuçlanır

mydict = {}
mydict['not there']
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'not there'

Anahtar hatalarını önlemenin bir yolu, yukarıda da kısaca bahsettiğimiz gibi, anahtarın olmaması durumunda döndürülecek varsayılan bir değer belirlemenize olanak tanıyan dict.get yöntemini kullanmaktır. Şimdi bu yönteme biraz daha detaylı bakalım:

value = mydict.get(key, default_value)

Eğer varsa mydict[key] döndürür, aksi takdirde default_value döndürür. Bunun mydict’e anahtar eklemediğini unutmayın. Dolayısıyla, bu anahtar değer çiftini saklamak istiyorsanız, anahtar değer çiftini saklayan mydict.setdefault(key, default_value) kullanmalısınız.

mydict = {}
print(mydict)
# {}
print(mydict.get("foo", "bar"))
# bar
print(mydict)
# {}
print(mydict.setdefault("foo", "bar"))
# bar
print(mydict)
# {'foo': 'bar'}

Bu sorunla başa çıkmanın alternatif bir yolu ise istisnayı yakalamaktır

try:
    value = mydict[key]
except KeyError:
    value = default_value

Anahtarın sözlükte olup olmadığını da kontrol edebilirsiniz.

if key in mydict:
    value = mydict[key]
else:
    value = default_value

Bununla birlikte, çok iş parçacıklı ortamlarda, siz kontrol ettikten sonra anahtarın sözlükten kaldırılmasının mümkün olduğunu ve istisnanın yine de atılabileceği bir yarış koşulu oluşturduğunu unutmayın.

Başka bir seçenek de, bir new_key verildiğinde dict’te yeni girdiler oluşturmak için default_factory’ye sahip bir dict alt sınıfı olan collections.defaultdict’i kullanmaktır.

Sözlük Örnekleri

Sözlükler anahtarları değerlerle eşler.

car = {}
car["wheels"] = 4
car["color"] = "Red"
car["model"] = "Corvette"

Sözlük değerlerine anahtarlarıyla erişilebilir.

print "Little " + car["color"] + " " + car["model"] + "!"
# Bu "Little Red Corvette!" çıktısını verecektir.

Sözlükler JSON tarzında da oluşturulabilir:

car = {"wheels": 4, "color": "Red", "model": "Corvette"}

Sözlük değerleri üzerinde yineleme yapılabilir:

for key in car:
  print key + ": " + car[key]

# wheels: 4
# color: Red
# model: Corvette
Bu yazı topluluk tarafından oluşturuldu. Lisans bilgisine bakabilirsiniz. Yanlış veya eksik bilgileri düzenlemek için github üzerinden katkıda bulunabilirsiniz.

Kategoriler: Ders, Python

konular

Okumaya devam et!
Sonraki Yazı: Python Veri Türlerinde Arama

n eleman içeren yinelenebilir veriler üzerindeki tüm arama algoritmaları O(n) karmaşıklığına sahiptir.

Python101 – Hata Ayıklama

Hata ayıklama nedir?  “Programlamaya başlar başlamaz, programları doğru yapmanın düşündüğümüz kadar kolay olmadığını gördük.

Pythonda dist-paketleri ile site-paketleri arasındaki fark nedir?

Dist paketleri dizinine yüklenen paketler ile site paketleri dizini arasındaki fark nedir? dist-packages Debian’a özgü bir düzendedir, Ubuntu gibi Debian türevlerinde de bulunur.

Python sözlük listesini sözlük değerlerine göre nasıl sıralarız?

Diyelim ki elimde aşağıdaki gibi bir sözlük listesi var: Bu listeyi name anahtarına göre sıralamak, dolayısıyla aşağıdaki sonucu elde etmek istiyorum.

Yorum Gönderin

E-posta hesabınız yayımlanmayacak.

koddla
Tema Mundana by WowThemes.net.