Ders 21
Ders 21
3.3 - Sözlük (Dictionary) Tipi Veriler
Koleksiyon tipi veriler, bilgisayar bilimlerinde "Veri Yapıları" (Data Structures) olarak adlandırılır. Liste ve topluluk (tuple) veri yapılarından sonra, bu seksiyonda sözlük (dictionary) veri tipini inceleyeceğiz.
Sözlük tipi veriler, belirli bir düzeni olmayan, sayıları istendiği kadar olabilen, anahtar:değer çiftleridir. Sözlükler süslü parantez {} içinde gösterilirler.
Sözlük anahtar değerleri benzersiz (unique) ve hashable değerler olmalıdır. Bunlar tek değer olabildikleri gibi df = {('Bölge', 1):16} tanımında olduğu gibi bileşik (kompozit) anahtar değerleri de olabilirler. Bileşik anahtar değerleri, sadece hashable tipte topluluklar veya frozensetler olabilir. Listeler kompozit anahtar değerleri olarak kullanılamaz, çünkü değişmez tipte değillerdir. Bundan başka her durumda, her geçerli Python tanıtıcısı sözlük anahtarı olarak kullanılabilir. Anahtar değeri olarak önceden belirtilmiş bir değer verilmek istenirse, eski anahtar: değer çifti silinir, yerine yeni tanımlanan anahtar:değer çifti yerleştirilir. Değerler ise, her geçerli Python veri tipinden olabilir. Sözlük tipi verilerde, indis tanımı yoktur. Bu yüzden dilimleme ile alt sözlüklere ayrılamaz. Ayrıca, indis tanımı olmadığından, sözlüklerde eleman dizilişi tamamen, gelişigüzel (random) niteliktedir. Belirli bir düzene göre yapılandırılmış sözlük verilerinin oluşturulması için özel sıralama yöntemlerinin uygulanması gerekir.
Sözlükler, değişebilir (mutable) veri tiplerindendir. Bir kez tanımlandıktan sonra kısmen değiştirilip güncellenebilirler.
3.3.1 - Sözlük Tipi Verilerin Oluşturulması
Sözlük tipi veriler, boş bir çift süslü parantez kullanılarak yaratılabilir. Örnek.
a = {}
print(a)
Program Sonucu :
{}
İstenirse, süslü parantez içeriğinde anahtar:değer çiftleri ile yaratılabilir. Örnek:
b = {'AdıveSoyadı' :'Ahmet Kahraman', 'DoğduğuYer' : 'Sulakyurt'}
print(b)
Program Sonucu :
{'AdıveSoyadı': 'Ahmet Kahraman', 'DoğduğuYer': 'Sulakyurt'}
Eğer var olan bir anahtar ile yeni bir anahtar:değer çifti yaratılmak istenirse, eski anahtar:değer çifti silinir ve yerine yeni anahtar:çifti konulur. Örnek
bd = {'AdıveSoyadı' :'Ahmet Kahraman', 'DoğduğuYer' : 'Sulakyurt',
'DoğduğuYer':'Konya'}
print(b)
Program Sonucu :
{'DoğduğuYer': 'Konya', 'AdıveSoyadı': 'Ahmet Kahraman'}
Görüldüğü gibi, anahtar değerleri mutlaka benzersiz olmalıdır. Aksi halde veri temelinde değer karmaşası yaşanır. Bunun için anahtar değerlerinin saptanmasında olağanüstü dikkat gerekir. Oluşturulan sözlükler de sıralama olmadığı ve yaratılan elemanların belirli bir sıra düzenine uymadan, gelişigüzel olarak oluşturulduğuna dikkat edilmelidir.
Sözlükler, öntanımlı dict() fonksiyonu kullanılarak başka koleksiyon veri tiplerinden, sözlük veri tipine dönüştürerek de yaratılabilir. Örnek:
sözlük1 = dict({'Parça Numarası :':978, 'Parça adı :' : 'Yakıt Pompası'})
print(sözlük1)
Program Sonucu :
{'Parça adı :': 'Yakıt Pompası', 'Parça Numarası :': 978}
Zaten tanımlanmış bir sözlüğü, yeniden sözlük tipine dönüştürmek çok akıllıca görünmemesine karşın, dict () öntanımlı fonksiyonunun sözlüklerin yüzeysel kopyalanmaları için bir yöntem oluşturduğu, bu program ile görülmektedir. Bu işlem, istenirse, aşağıda görüldüğü gibi, bir ara atama yolu ile de gerçekleştirilebilir.
sözlük2 = dict(b)
print(sözlük2)
Program Sonucu : {'AdıveSoyadı': 'Ahmet Kahraman', 'DoğduğuYer': 'Sulakyurt'}
Doğal olarak, bir liste veya topluluk gibi başka koleksiyon tipinde olan verilerin öntanımlı dict() fonksiyonu yardımı ile sözlük tipine dönüştürmek çok daha anlamlı olacaktır. Örnekler aşağıda görülmektedir:
print(dict([[34, 'Istanbul'], [41, 'Kocaeli'], [56, 'Tekirdağ']]))
Program Sonucu : {56: 'Tekirdağ', 41: 'Kocaeli', 34: 'Istanbul'}
Yukarıdaki uygulama, kodların nasıl kompakt hale getirilebileceğinin görülmesi için iyi bir örnektir. Kodların bu şekilde kompakt hale getirilmesi, programın iyi anlaşılmasını, özellikle ilk geliştirme sürecinde çok zorlaştırır ve kesinlikle bu işlem programın ilk sürümlerinde değil, çok daha sonra, program iyice yerleşik ve fonksiyonel hale geldikten sonraki sürümlerinde, güncelleme işlemleri arasında yapılmalıdır.
Başlangıç sürümlerinde, programlar daha açık ve anlaşılır olmalıdır. Örnek :
trafik_kodları = [[34, 'Istanbul'], [41, 'Kocaeli'], [56, 'Tekirdağ']]
sözlük3 = dict(trafik_kodları)
print(sözlük3)
Program Sonucu : {56: 'Tekirdağ', 41: 'Kocaeli', 34: 'Istanbul'}
Yukarıdaki programda görüldüğü gibi, bileşik olmayan anahtar değerleri için listeler kullanılabilir. Veri yapısı sözlük tipine dönüştürülecek bir koleksiyonun veri yapısı, bu dönüştürmeye uygun olmadır. Aksi halde hata oluşur. Buna şekil (shape) koşulunun uygunluğu adı verilir.
Aynı yöntemle, veri yapısı uygun olan koleksiyonlar da, dict() öntanımlı fonksiyonunun argümanı olarak tanımlandıklarında sözlük veri tiplerine dönüştürülebilirler. Örnek:
tpl=(('Mayıs', 34), ('Haziran', 40), ('Temmuz' , 42))
sözlük4 = dict(tpl)
print(sözlük4)
Program Sonucu :
{'Mayıs': 34, 'Temmuz': 42, 'Haziran': 40}
Bu uygulamanın
Bu uygulama, dict () fonksiyonun, uygun yapılı topluluklarını, sözlük veri tipine dönüştürülebileceklerini açıkça göstermektedir. Bu uygulamanın daha da ilginci zip () fonksiyonun da olaya dahil olmasıdır. Örnek:
liste = ['Istanbul', 'İzmir', 'Mersin']
topluluk = ('Enginar', 'Mandalina', 'Portakal')
sözlük5 = dict(zip(liste, topluluk))
print(sözlük5)
Program Sonucu : {'İzmir': 'Mandalina', 'Mersin': 'Portakal', 'Istanbul': 'Enginar'}
Yukarıdaki program çok ilginç ve pratik bir sözlük yaratma metodunu belirtmektedir. Bu metotla, bileşik anahtar değerli sözlükler de yaratılabilir. Sadece, bileşik anahtar değerli sözlüklerin anahtar değeri olarak sadece değişemez ve hashable koleksiyonlar kullanılabilir. Bu kriteryumu da sadece hashable toplukluklar ve frozensetler karşılayabilir. Listeler, bileşik anahtar değerli sözlüklerin anahtar değerleri olarak kullanılamaz. Listelerin, sözlük anahtar değerleri olarak kullanılamadıkları tek kısıtlama da budur.
Bu sözlük oluşturma yönteminin, sıradan ve ve oluşturuğu sözlüklerin diğer metotlarla da yapılabileceği düşünülebilir. Küçük çapta sözlükler için bu düşünce doğru da olabilir. Fakat, biraz düşününce, bu yöntemin inanılmaz bir olanak sağladığı anlaşılacaktır. Sözlük değerlerinin aynı zamanda nesne sınıf örneklerinden oluşabileceği gözönüne alınmalıdır. İstenilen bir veri yapısı sınıfı yaratarak, bunun binlerce sınıf örneğini bir disk dosyasına yerleştirip, bir koleksiyon tipi verinin elemanları olarak okutmak ve bir başka dosyadan okutulan anahtar değerleri ile akuple ederek, tüm bu anahtar:değer çiftlerini, zip () fonksiyonu ile, bir sözlükte birleştirmek büyük çapta bir veri temeli yaratmak anlamına gelmektedir. Böyle bir veri temelinde, çoklu anahtar değerlerinin her bir anahtarının, nesne örneği değerin bir başka özelliğine denk getirilmesi inanılmaz yetenekli bir dinamik veri temelinin geliştirilmesi anlamına gelir. Bu veri temeli dinamik olacaktır çünkü, disk dosyalarında veriler her an güncellenebilir niteliktedir. Veri temeli de statik olmayıp, her çağrıldığında değişik disk dosyaları okunup zip () fonksiyonu ile çalışma sürecinde (runtime) olarak birleştirildiğnden tam dinamik karakterde olacaktır. Yine de, bu bir amatör veri temelidir ve verilere erişim çok hızlı olmayabilir. Bu yüzden erişim hızı çok kritik ise, Python programlama dilinin, çok kullanışlı veri temeli bağlantılarından yararlanarak profesyonel bir veri temeli ile, örnek olarak MySql ile çalışmak çok daha iyi olabilir.
Sözlükler, değişebilir tipte veriler olduklarından, aynı zamanda dictionary comprehensions denilen yöntemle de yaratılabilirler. Bu yöntemi, topluluklar ile de incelemiştik. Burada da tekrar edelim. Topluluklardan farklı olarak, sözlüklerde, hem anahtar, hem değer vermek gerekir. Anahtarları bir listeye, değerleri bir başka listeye yerleştirirsek ister zip() fonksiyonu ile, istersek iki içiçe for in döngüleri ie bunları bir sözlükte birleştirebiliriz. Örnek:
Anahtar = (('Beşiktaş', 'Akaretler'), ('Fatih', 'Malta' ), ('Feneryolu', 'Kadıköy'))
Değer = (23, 34, 48)
sözlük = {}
x = 0
for i,j in Anahtar:
item = {((i,j), Değer[x])}
sözlük.update(item)
x+=1
print(sözlük)
Program Sonucu :
{('Fatih', 'Malta'): 34, ('Beşiktaş', 'Akaretler'): 23, ('Feneryolu', 'Kadıköy'): 48}
Öntanımlı zip() fonksiyonu ile daha da pratik:
Anahtar = (('Beşiktaş', 'Akaretler'), ('Fatih', 'Malta' ), ('Feneryolu', 'Kadıköy'))
Değer = (23, 34, 48)
sözlük = dict(zip(Anahtar,Değer))
print(sözlük)
Program Sonucu :
{('Fatih', 'Malta'): 34, ('Beşiktaş', 'Akaretler'): 23, ('Feneryolu', 'Kadıköy'): 48}
Sözlüklerin yapılanması sırasında belirli koşullar da belirleyebiliriz. Örnek:
Anahtar = (('Beşiktaş', 'Akaretler'), ('Fatih', 'Malta' ), ('Feneryolu', 'Kadıköy'))
Değer = (23, 34, 48)
sözlük = {}
x = 0
for i,j in Anahtar:
if Değer[x] < 40:
item = {((i,j), Değer[x])}
sözlük.update(item)
x+=1
print(sözlük)
Program Sonucu :
{('Fatih', 'Malta'): 34, ('Beşiktaş', 'Akaretler'): 23}
Eleman değerleri belirli koşulları sağlayan sözlüklerin oluşturulması, zip() ile kolaydır. Örnek:
Anahtar = (('Beşiktaş', 'Akaretler'), ('Fatih', 'Malta' ), ('Feneryolu', 'Kadıköy'))
Değer = (23, 34, 48)
sözlük = dict( zip(Anahtar,Değer))
seri = dict( zip(Anahtar,Değer))
for item in seri.items():
if item[1] > 40:
sözlük.pop(item[0])
del(seri)
print(sözlük)
Program Sonucu :
{('Fatih', 'Malta'): 34, ('Beşiktaş', 'Akaretler'): 23}
Burada sözlük iki terimli anahtar ve tek değerden oluşuyor. Önce zip() fonksiyonunu uygulayarak sözlük ve seri adlı iki bağımsız sözlük verisi oluşturuyoruz. Sonra seri sözlüğünün elemanlarını tarayarak değeri 40 dan büyük olan elemanın anahtar değerini saptayarak, bu anahtar:veri çiftini, sözlük sözlüğünden çıkartıyoruz. Eleman sayısı tamamlanınca, sözlük sözlüğünde istediğimiz özellikleri sağlayan elemanlar kalmış oluyor.
Dictionary comprehensions yöntemi yukarıdaki işlemleri daha kısaltmak için gerçekleştirilmiştir. Ne yazık ki bu basit yöntem, ratladığım hiçbir kaynakta açık ve adım adım anlatılamamış ve bu nedenle kullanıcılar çoğu kez bu kolay yöntemi kullanmaktan kaçınmaktadırlar. Oysa ilk kural ile başlayalım:
Bu durumda, dictionary comprehensions yöntemini uygulamak için, ilk önce sözlüğün yaratılması için yararlanılacak koleksiyonun (liste, topluluk, küme, donmuş küme) daha önce dikkatle hazırlanması gereklidir.
Sözlüklerin yaratılması için gerekli dosyanın yaratılması hiç zor değildir. Bu koleksiyon, oluşacak sözlüğün anahtar : veri çiftlerinin oluşturulabilmesi için gerekli değerleri sağlamalıdır. Yani, bu dosyanın her elemanı, sözlük oluşturulması için yeterli bilgiyi sağlamalıdır. Bu da çok basit olarak sağlanabilir. Bazı olasılıkları gözden geçirelim:
Bir anahtar listesi
z = [12, 3, 5, 14]
Bu liste sadece anahtar bilgilerini içermektedir. Eğer böyle bir listenin elemanları ile bir sözlük oluşturulacaksa, bu liste sadece anahtar değerlerini sağlayabilecektir. Durum aşağıda görüldüğü gibi olacaktır:
12 : ? , 3 : ? , 5 : ?, 14 : ?
Anahtarlar bulundu, ama bu anahtarlara karşı gelecek değerler bulunumazsa sözlük oluşturulamaz. Değerler önceden belirlenmişse, sözlük oluşturulabilir. Bu değerlerin nasıl belirlenebilecekleri belirli olasılıklarla belirlenebiir.
Bir olasılık, bu anahtar değerleri ile veriler arasında, matematik bir bağıntı olabileceği ve değerlerin, verilerin anahtar değerlerinden saptanabileceğidir. Örnek olarak veri = sin(anahtar) olabilir. Bu durumda, sözlük dosyası tamamlanmıştır. Görevin geri kalanını, dictionary comprehensions üstlenip sözlüğü oluşturacaktır.
Bir başka olasılık, her bir anahatar değerine karşı, bir gözlem yapılmış olduğu ve bu gözlem değerlerinin bir veri listesine kaydedilmiş olmasıdır. Bu da fizikte çok rastlanan ikili bir ilişki anlamına gelir. Örnek olarak, belirli sıcaklıklara karşı gelen su buharı basınçları okunup bir listeye kaydedilmiş olabilir. O zaman da, anahtar ve veri dosyalarını zipleyerek (anahtar, veri), (anahtar, veri) çiftlerini oluşturmuş oluruz. Ziplenmiş verileri bir listeye yerleştiririz ve bundan sonrasını dictionary comprehension halleder.
Dictionary comprehension yöntemi iki türlü uygulama prosedürünü destekler. Bunlar,
{anahtarifadesi : değerifadesi for anahtar, değer in iterable}
{anahtarifadesi : değerifadesi for anahtar, değer in iterable if koşul}
şeklindedir. Bu yöntemlerden ilkinin açıklanmasına tanımın sonundan başlayalım: for anahtar, değer in iterable... Burada iterable, oluşturulmuş olan, sözlük tanım koleksiyonudur. Bu koleksiyon, iki döngü değişkeni (anahtar, değer) ile tarandığına göre, en az iki boyutlu olması gerekir. koleksiyonun yapısı,
xy = ((12, 0.20), (3, 0.02), ...)
şeklindedir. Her iterasyonda, elemanlar hedeflenirse,
fofor i in xy:
print(i)
Program Sonucu : (12, 0.2) (3, 0.02) ...
olacaktır. Eğer, elemanlarından anahtar:değer çiftleri oluşturulabiliyorsa, bu veri koleksiyonu, sözlük yapmaya uygundur. Sözlük yapabilmek için, en az bir anahtar ve bir değere gereksinme duyululur. Oysa, veri koleksiyonunda bu yapılanma, açık bir şekilde kendini göstermektedir. Veri koleksiyonunun her elemanı, iki elemanlı topluluklardan oluşmaktadır. Her bir elemanın ilk iç elemanı anahtar, ikinci iç elemanı da değer olarak tanımlanırsa, sözlük yapılanması gerçekleşmiş olacaktır. Veri koleksiyonun her bir elemanı, oluşacak sözlüğün anahtar:değer çiftlerininden birini tanımlayacaktır. Her bir veri koleksiyonu elemanı için, oluşacak sözlüğün değer çiftlerinden birisinin anahtar değerini eleman[0], değerini de eleman[1] şeklinde tanımlarsak olay çözümlenir. Sözlük yapılanması,
xy = ((12, 0.20), (3,0.02))
sözlük = {eleman[0]:eleman[1] for eleman in xy}
print(sözlük)
Program Sonucu : {3: 0.02, 12: 0.2}
Topluluk verilerine erişimi incelerken, bir topluluk homojen ve elemanları iki elemanlı topluluklardan oluşuyorsa, i, j şeklinde iki döngü değişkenli iterasyonlarla, elemanların her iki iç elemanına erişmek olanağı olduğunu görmüştük bu yöntemi, yukarıdaki örnekteki xy topluluğuna uygularsak, x ve y birer iterasyon değişkeni olarak,
xy = ((12, 0.20), (3, 0.02))
sözlük = {x : y for x,y in xy}
print(sözlük)
Program Sonucu : {3: 0.02, 12: 0.2}
Görüldüğü gibi, çok kolay ve çok kısa bir tanımlama ile örnek olara iki elemanlı bir sözcüğü, iki elemanlı ve iki düzeyli bir koleksiyondan oluşturduk. Bu koleksiyon binlerce elemanlı olabilir ve binlerce elemanlı tek anahtarlı bir sözlük oluşturulabilirdi.
Çoklu anahtar değerli sözlüklerde, her anahtar kombinasyonu için bir değer atanabilir. Olayın çekici tarafı, anahatar kombinasyonlarının farklı olabilmesi ve bir anahtar sabit kalarak (pivot) diğer anahtarların değişebilmesidir. Örnek olaka üç anahtarlı bir sözcükle, her şehrin, her ilçesinin, her mahallesindeki nufus değerlerini kaydetmek isteyelim. Kayıtlar istenildiği kadar gelişigüzel olabilir. Okunurken pivot olarak şehir anahtarını alırsak, ikinci pivot olarak ilçe anahtarı olacaktır. Bu iki pivot sabit kalaraki beklirli bir şehrin (ilk pivot), belirli bir ilçesinin (kinci pivot) tüm mahallelerindeki nüfus sayısı (değişen üçüncü anahtar) saptamak olanğı bulunabilir. Tüm değişebilecek üçüncü anahtar değerleri sona erince, yani, belirli bir ilin, belirli bir ilçesinin tüm mahalleleri tükenince, ikinci pivota yeni bir değer verilebilir, yanı il aynı kalır ama ilçe değişir, bu kez değişen ikinci pivot için tüm mahallaer taranır. En sonunda, belirli bir il için tüm ilçeler (ikinci pivot değerleri) tükenince, başka bir ile geçilir (ilk pivot değiştirilir). Yeni il için de bir öncesinin işlemleri aynen tekrarlanır. Sonunda il seçenekleri de tamamlanınca tüm sözlük değerlerine erişim tamamlanmış olur. Burdan çoklu anahtarlı sözlüklerin ne kadar büyük potansiyelleri olduğu açıkça görülebilir.
Eğer iki anahtar, bir değer, yani (a, b) : c isteminde bir sözlük oluşturmak istenirse, uygun veri yapısından (data structure) yola çıkılmalıdır. Örnek,
doluluk = (((2014, 'Ocak'), 35), ((2014, 'Temmuz'), 12), ((2015, 'Ocak'),56))
rapor = {(eleman[0][0] , eleman[0][1]) : eleman[1] for eleman in doluluk}
print(rapor)
Program Sonucu : {(2015, 'Ocak'): 56, (2014, 'Ocak'): 35, (2014, 'Temmuz'): 12}
Görüldüğü gibi, rapor sözlüğü başarı ile ve çok pratik bir yöntemle oluşturuldu. Şimdi yöntemi analiz edelim. Veri yapısı ile başlayalım. Burada veri yapısı iki düzeylidir. İlk düzey eleman düzeyidir ve buna aşağıdaki gibi erişilebilir.
doluluk = (((2014, 'Ocak'), 35), ((2014, 'Temmuz'), 12), ((2015, 'Ocak'),56))
for i in doluluk:
print (i)
Program Sonucu : ((2014, 'Ocak'), 35) ((2014, 'Temmuz'), 12) ((2015, 'Ocak'), 56)
Bu sonuçlar doğal olarak, sözlük oluşturmaya yönelik değil, veri yapısı üzerine bilgi edinmeye yöneliktir. Burada, veri yapısının elemanlarını görebiliyoruz. Herşeyden önce verilerin tekdüzey (monoton) olduğu ve eleman yapılarının birbirlerinin aynısı olduğu görülüyor. Sözlük oluşturmada bu olmazsa olmaz bir koşuldur. Böylece sözlük oluşturmaya esas veri yapısının uyması gereken ikinci koşulu açıklayabiliriz.
Dicitionary comprehensions yöntemi ile sözlük oluşturmaya yönelik bir koleksiyonda eleman yapıları birbirbirlerinin aynı olmalıdır (şekil koşulu).
Örneğimizdeki veri koleksiyonu bu kriteryumu sağlayabildiğine göre, şimdi her elemanın iç yapılarını inceleyelim. Her eleman, iki iç elemandan oluşuyor. Elemanlardan birisi iki elemanlı bir topluluk, ki bu anahtar oluyor, diğeri de tek bir sayısal değer ki bu da değer oluyor. Buradan, sözlük oluşturacak veri yapısı için, olmazsa olmaz ikinci kuralı algılıyoruz:
Dicitionary comprehensions yöntemi ile sözlük oluşturmaya yönelik bir koleksiyonda, koleksiyonun her elemanı, oluşturulacak sözlüğün anahtar:değer çiftini tanımlayacak bilgiye sahip olmalıdır.
Bu bilgi, yukarıdaki uygulamadaki veri yapısında olduğu gibi, veri yapısının içinde olabilir. Veya biraz sonra görülecek bir literatür uygulaması gibi, değer, anahtarın argümanı olduğu bir fonksiyonun geri dönüş değeri olabilir ama, her koşulda, veri yapısının her elemanının oluşacak sözlüğün bir anahtar : değer çiftini tanımlayacak bilgiyi içermesi gerekli olacaktır. Şimdi bu kriteryumu sağlayan, yukarıdaki veri yapısı ile bir dictionary comprehension organize edelim:
doluluk = (((2014, 'Ocak'), 35), ((2014, 'Temmuz'), 12), ((2015, 'Ocak'),56))
rapor = {(eleman[0][0] , eleman[0][1]) : eleman[1] for eleman in doluluk}
print(rapor)
Program Sonucu : {(2015, 'Ocak'): 56, (2014, 'Ocak'): 35, (2014, 'Temmuz'): 12}
Örneklerde de görülebildiği gibi herşey veri yapısına bağlıdır. Şimdi farklı bir veri yapısı ile aynı sözlüğü oluşturmaya çalışalım :
doluluk = ((2014, 'Ocak', 35), (2014, 'Temmuz', 12), (2015, 'Ocak',56))
rapor = {(x,y) : z for x, y , z in doluluk}
print(rapor)
Program Sonucu : {(2015, 'Ocak'): 56, (2014, 'Ocak'): 35, (2014, 'Temmuz'): 12}
Veri yapısı farklı olmasına karşın, bilinçli bir veri kullanımı ile kolaylıkla aynı sözlüğü oluşturabiliyoruz. Veri yapısı faklı olmasına karşın, tekdüze (monoton) ve veri yapısının her elementinin, bir sözlüğün anahtar: değer çiftlerinin tanımlanması için yeterli olduğu görülüyor.
Aşağıdaki literatür uygulamasında, veri yapısının her elementi, sözlüğün anahtar : değer çiftinin değer kısmının tanımı için, anahtar değerinin argüman olarak kullanıldığı bir fonksiyonun geri dönüş değerinden yararlanıyor.
import os
file_sizes = {name: os.path.getsize(name) for name in os.listdir(".")}
print(file_sizes)
Program Sonucu: {'Ders 21.ipynb': 7304, 'deneme.ipynb': 3541, 'ders 20.ipynb': 11636, 'Ders19.ipynb': 37753, '.ipynb_checkpoints': 4096}
Aşağıdaki program, koşullu bir dictionary comprehension uygulamasıdır. Bu program, bir klasördeki de bit sayısı 10000 nin altında olan dosyaların adlarını ve bit sayılarını bir sözlükte toplamaktadır.
import os
file_sizes1 = {name: os.path.getsize(name) for name in os.listdir(".") if os.path.getsize(name)<10000}
print(file_sizes1)
Program Sonucu : {'Ders 21.ipynb': 6221, 'deneme.ipynb': 3541, '.ipynb_checkpoints': 4096}
Bu program, bir klasördeki bit sayısı 10000 den az olan dosyaların adlarını ve bit sayılarını bir sözlükte toplar. (Programming in Python 3 sec.Ed. Mark Summerfield)
Bu yöntemler, tek boyutlu sözlüklerde daha kolaylıkla uygulanabilir. Örnek:
f1=[3,4,6]
f2 = [25, 30, 45]
d1 = {item for item in zip(f1,f2)}
print(d1)
Program Sonucu : {(3, 25), (4, 30), (6, 45)}
Bir koşul olması durumunda,
f1=[3,4,6]
f2 = [25, 30, 45]
d1 ={item for item in zip(f1,f2) if item[0] < 4}
print(d1)
Program Sonucu : {(3, 25)}
3.3.2 - Sözlük Tipi Verilerin Elemanlarına Erişim
Sözlükler belirli bir sıra düzeni ile oluşturulmadıklarından ve indis tanımı olmadığından, elemanlarına sadece anahtar değerleri ile erişim sağlanabilir.
Anahtar değerleri tek ise,
data = {0.25 : 16, 0.50 : 20, 0.75 : 40}
print(data[0.25])
Program Sonucu :
16
Anahtar değerleri birden çok ise,
q = {('Istanbul', 1) :'Beşiktaş', ('Istanbul', 2): 'Kadıköy', ('Istanbul', 3): 'Bakırköy', ('Istanbul', 4): 'Adalar'}
print(q)
print("\n",q['Istanbul' , 4])
Program Sonucu :
Adalar
Sözlüklerin elemanlarına daha çok iteratif yolla erişilebilir. Bunları, sözlüklere uygulanan öntanımlı metotlar konusunda daha yakından inceleyeceğiz.
3.3.2 - Sözlük Tipi Verilere Uygulanabilen Metotlar
Sözlükler, belirli anahtar:değer topluluklarından, sıralanma olmadan oluşturulmuş koleksiyonlardır. Bu koleksiyonların anahtar değerleri, indis görevini yapar. Sözlüklerde, değer anahtarları veya başka türlü bir söylem ile değer indisleri, sözlük içinde gelişigüzel dağılmışlardır. Bir kez listelenen bir sözlüğün anahtar:değer çiftleri, bir kez daha bir daha listelendiğinde aynı sırada olmayabilir.
Sözlüklerin değer içeriklerine en basit olarak anahtarları aracılığı ile erişilir. Bu erişim, bir topluluk elemanlarına indisleri ile erişmek ile aynıdır. Örnek:
ispanyolca = {}
ispanyolca['Merhaba'] = 'Hola'
ispanyolca['Mavi'] = 'Azul'
ispanyolca['Evet'] = 'Si'
ispanyolca['Bay'] = 'Senõr'
ispanyolca['Bayan'] = 'señora'
ispanyolca['Bayan'] = 'señora'
ispanyolca['Kadın'] = 'Muher'
ispanyolca['Erkek'] = 'Hombre'
ispanyolca['Bir Amerikalı'] = 'Un Gringo'
print(ispanyolca['Bir Amerikalı'] + " " + ispanyolca['Kadın'])
Program Sonucu :
Un Gringo Muher
Görüldüğü gibi, sözlük elemanlarına aynı JavaScript ilişkisel dizileri gibi, anahtar değerleri ile erişim sağlanıyor. Tümsözlük içeriğini görüntülemek için, print( <sözlük adı>) yazılması yeterlidir. Örnek
print(ispanyolca)
Program Sonucu : {'Bay': 'Senõr', 'Mavi': 'Azul', 'Evet': 'Si', 'Merhaba': 'Hola', 'Bayan': 'señora', 'Kadın': 'Muher', 'Erkek': 'Hombre', 'Bir Amerikalı': 'Un Gringo'}
Görüntülenen sözlük içeriğinin, anahtarlarına göre belirli bir sıra düzeni gözetilmediğine dikkat edelim.
Sözlük anahtarları sayısal olursa, elemanlarına erişim, herhangibir koleksiyonun elemanlarına erişimden farksız olur. Örnek :
okuma = {34: 56, 48: 67, 70: 88}
print(okuma[48])
Program Sonucu :
67
3.3.3 - Sözlük Tipi Verilere Uygulanabilen Metotlar
Sözlükler, öntanımlı len() metodunu destekler. Örnek:
# ispanyolca adlı sözlük yukarıda oluşturulmuştu
print (len(ispanyolca)) Program Sonucu : 8
Sözlük tipi metotlara uygulanan item () metodu, sözlüğün tüm elemanlarını bir topluluk içinde toplar ve bu topluluğu görüntüler. Örnekler:
q = {('Istanbul', 1) :'Beşiktaş', ('Istanbul', 2): 'Kadıköy', ('Istanbul', 3): 'Bakırköy', ('Istanbul', 4): 'Adalar'}
print(q.items())
Program Sonucu :
dict_items([(('Istanbul', 1), 'Beşiktaş'), (('Istanbul', 4), 'Adalar'), (('Istanbul', 2), 'Kadıköy'), (('Istanbul', 3), 'Bakırköy')])
data = {0.25 : 16, 0.50 : 20, 0.75 : 40}
print(data.items())
Program Sonucu :
dict_items([(0.25, 16), (0.5, 20), (0.75, 40)])
Sözlüklere uygulanan items() metodu, anahtar değeri tekli olsun, çoklu olsun, sözlükteki tüm elemanları bir topluluk içinde bir liste olarak geri döndürüyor. Bu topluluğun tek elemanı, sözlüğün tüm anahtar: değer verilerini eleman olarak içeren bir listedir. Bu listenin elemanlarına erişim olanağı yoktur. Örnek:
q = {('Istanbul', 1) :'Beşiktaş', ('Istanbul', 2): 'Kadıköy', ('Istanbul', 3): 'Bakırköy', ('Istanbul', 4): 'Adalar'}
qt = q.items() # qt tek elemanlı bir topluluktur.
qtl= qt[1] # qtl tüm sözlük elemanlarını içeren bir listedir.
print(qtl)
Program Sonucu :
TypeError Traceback (most recent call last)
<ipython-input-34-6275969c9f7a> in <module>()
3 qt = q.items() # qt tek elemanlı bir topluluktur.
4
----> 5 qtl= qt[1] # qtl tüm sözlük elemanlarını içeren bir listedir.
6
7 print(qtl)
TypeError: 'dict_items' object does not support indexing
Sözlüklere uygulanan items() metodunun geri döndürdüğü koleksiyonun elemanlarına indisleri ile erişim sağlanamasının nedeni, bu koleksiyonun,"görüntü (view)" olarak adlandırılan bir tipte olmasıdır. Görüntü tipleri sadece sonucun görüntülenmesi için oluşturulurlar. Bu tipi kolaeksiyonlar küme (set) tipindedir ve kümelere uyulanan metotlar ugulanarak elemanlarına erişilebilirler. BU yöntemler belirli değerlerin belirli bir sözlükte olup olmadığı sorgulanabilir. Bu metotları, kümeleri incelediğimizde, görüntü kümelerine de uygulayarak sonuçları alabileceğiz.
Buna rağmen, items() metodunun geri döndürdüğü koleksiyonfor in döngüleri ile iterasyon yapılmasına uygundur ve bu yöntemle sözlük elemanlarına erişilebilir. Örnekler:
for item in q.items():
print(item[0],item[1])
Program Sonucu : ('Istanbul', 3) Bakırköy
('Istanbul', 4) Adalar
('Istanbul', 1) Beşiktaş
('Istanbul', 2) Kadıköy
for item in q.items():
print(item[0][0],item[0][1],item[1])
Program Sonucu : Istanbul 3 Bakırköy
Istanbul 4 Adalar
Istanbul 1 Beşiktaş
Istanbul 2 Kadıköy
Sözlük anahtarlarının görüntülenmesi için keys() metodu uygulanabilir. Örnek:
q = {('Istanbul', 1) :'Beşiktaş', ('Istanbul', 2): 'Kadıköy', ('Istanbul', 3): 'Bakırköy', ('Istanbul', 4): 'Adalar'}
qkeys = q.keys() # qt sözlüğünün anahtar değerlerinin görüntü kümesi
print(qkeys
Program Sonucu :
dict_keys([('Istanbul', 1), ('Istanbul', 4), ('Istanbul', 2), ('Istanbul', 3)])
Sonuç, sözlüğün tüm anahtarlarının görüntüsünü içeren bir görüntü kümesidir. Bu kümenin erişim metotlarını, kümeler ile birlikte inceleyeceğiz. Buna rağmen bu koleksiyonfor in döngüleri ile taranmaya uygundur. Örnek:
q = {('Istanbul', 1) :'Beşiktaş', ('Istanbul', 2): 'Kadıköy', ('Istanbul', 3): 'Bakırköy', ('Istanbul', 4): 'Adalar'}
qkeys = q.keys() # qt sözlüğünün anahtar değerlerinin görüntü kümesi
for anahtar in q.keys():
if anahtar[1]<4:
print(anahtar[0], anahtar[1])
Program Sonucu :
Istanbul 3
Istanbul 1
Istanbul 2
Öntanımlı del metodu, bellekteki bir veriyi bellekten kaldırır. Örnekler:
sx = {'ocak': 16, 'şubat': 18}
del(sx)
print(sx)
Program Sonucu :
NameError Traceback (most recent call last)
<ipython-input-33-b48448a69a43> in <module>()
1 sx = {'ocak': 16, 'şubat': 18}
2 del sx
----> 3 print(sx)
NameError: name 'sx' is not defined
sx = {'ocak': 16, 'şubat': 18}
del sx['ocak']
print(sx)
Program Sonucu :
{'şubat': 18}
Sözlüklere uygulanan len () metodu, sözcük uzunluğunu döndürür. Örnek:
sx = {'ocak': 16, 'şubat': 18}
n = len(sx)
print('sx sözlüğünün uzunluğu : {0}'.format(n))
Program Sonucu :
2
Öntanımlı fromkeys() metodu, hash edilebilen bir koleksiyondan yani float, frozenset, int, str, and hash edilebilen toplulukların elemanlarını anahtar olarak kullanarak, sözlükler oluşturan, son derece yararlı bir metottur. Kullanılışı,
sözlük.fromkeys(s ,v)
şeklindedir. Burada,