Ders 23
Ders 23
3.4 - Kümeler (Sets)
Python Programlama dili, iki türlü küme nesnesini destekler. Bunlardan ilki, değişebilir bir tip olan set (küme) diğeri de değişmez (immutable) bir tip olan frozenset (donmuş küme) veri tipleridir. Bu iki tipin değişme (mutability) özelliği dışında oluşturulmaları ve elemanlarına erişim yöntemleri aynıdır. Tek farkettikleri alan, uygulanabilecek öntanımlı metotların değişme yeteneğine göre seçilmesidir.
Öntanımlı bir küme veri tipi, Python programlama dilinin matemetikçilere armağanı sayılabilir. Çok az sayıda bilgisayar dili, kümeleri öntanımlı olarak desteklemektedir.
Küme elemanları, tanım gereği sıralı değillerdir. Kümelerin elemanlarına iteratif yöntemlerle gelişigüzel olarak erişilebilir. Küme elemanları, tüm diğer koleksiyon tiplerinde olduğu gibi, in aidiyet testlerini ve len() uzunluk saptamasını desteklerler.
Küme elemanları, sadece hash edilebilen nesneleri elaman olarak içerebilir. Bunun sonucunda sadece int, float, string ve topluluk tipinde veriler küme elemanları olabilirler. Fakat, liste, sözlük ve bizatihi küme tipleri küme elamanı olamazlar.
3.4.1 - Küme Oluşumu
Kümelerin oluşturulması diğer koleksiyon tiplerinden farksızdır. Eleman içeren bir kümenin literal olarak oluşturulması için, süslü parantezlerin arasına virgülle ayrılmış elemanların yazılması yeterlidir.
küme1 = {1, 2, 3, 3, 4}
print(küme1)
Program Sonucu :
{1, 2, 3, 4}
şeklinde olur. Görüldüğü gibi, oluşan küme sadece bir tek 3 içermektedir. Literal olarak bir kümeye iki tane yanı değerde eleman yerleştirmek istesek de Python derleyicisi bu isteği kabul etmeyerek, kümenin, kuramın öngördüğü gibi, her eşit değerden sadece bir tek eleman içerecek şekilde oluşturmuştur.
Kümeler, öntanımlı küme oluşturucu fonksiyon set() kullanımı ile de oluşturulabilirler. Bu fonksiyon tek bir hash edilebilecek elemanı argüman olarak kabul eder. Örnek,
küme2 = set(['Aslı', 45, 6.98, ('Önder', 48)])
print(küme2)
Program Sonucu :
{('Önder', 48), 45, 6.98, 'Aslı'}
Veya, listenin ayrı olarak belirtilmesine de olanak bulunmaktadır. Örnek,
liste3 = ['Aslı', 45, 6.98, ('Önder', 48)]
küme3 = set(liste1)
print(küme3)
Program Sonucu :
{('Önder', 48), 45, 6.98, 'Aslı'}
Program çıktıları incelendiğinde, eleman sıralarının gözetilmediği görülecektir.
Sadece hash edilebilen topluluklar bir kümenin elemanı olabilirler. Bunlar, içeriklerinde hiç değişebilen tipte eleman içermeyen topluluklardır. Örnek olarak, aşağıda görülen tipte bir topluluk, bir kümenin elemanı olamaz.
liste6 = [22, 56, 89, 'Ali',(23, [67,56])]
küme6= set( i for i in liste6)
print(küme6)
Program Sonucu : TypeError Traceback (most recent call last)
<ipython-input-1-95a49338dd71> in <module>()
1 liste6 = [22, 56, 89, 'Ali',(23, [67,56])]
----> 2 küme6= set( i for i in liste6)
3 print(küme6)
TypeError: unhashable type: 'list'
Boş bir küme, ∅ olarak gösterilir. Boş küme, literal olarak, boş {} olarak yaratılamaz. Boş kümenin mutlaka argümansız set() fonksiyonu kullanılarak, d = set() şeklinde yaratılması gerekir. Bu şekilde d ye ∅ atanmış olur.
Kümeler, diğer koleksiyon tipleri gibi set comprehension yöntemi ile de oluşturulabilirler. Örnek,
liste4 = [22, 56, 89, 'Ali']
küme4 = set( i for i in liste4)
print(küme4)
Program Sonucu : {56, 89, 22, 'Ali'}
Küme içerikleri (set comprehension) belirli bir koşulu sağlayabilecek elemanları da seçebilir. Örnek,
liste5 = liste = [12, 5, 33, 2]
küme5 = set( i for i in liste5 if i < 30)
print(küme5)
Program Sonucu : {2, 12, 5}
Tekrar hatırlayalım. Bu ifadede, ilk i, oluşacak kümenin bir elamanını, for i in <uygun iteratör> daki i ise, taranan iteratördeki bir elemanı belirtmektedir. İfadenin değerlendirilmesi sağdan başlar ve ilk olarak ikinci i tanımlanmaya çalışılır. İkinci i tanımlanmış olduğunda, küme elemanı olan i de tanımlanmmış olur ve küme oluşturulabilirse oluşturulur. Örnek olarak yukarıdaki ifade, küme4 = set( j for i in liste4) olarak belirtilirse, Python derleyicisi bu ifadeyi kabul etmez ve J nin tanımlı olmadığı yanıtını verir.
3.4.2 - Küme Elemanlarına Erişim
Kümeler, koleksiyon ailesi içinde olan bir veri türüdür. Buna rağmen, küme tipi verilerin elemanları kuramsal olarak sıralı değillerdir ve buna uygun olarak Python derleyicisi, küme elemanlarına indis değeri vermez. Bu durumda, küme elemanlarının elemanlarına sıralı erişim, sadece o andaki sıralama için geçerlidir ve görüntülendiğinde de sonuçlar o anda geçerli olan sıralamayı bile yansıtmaz, Python derleyicisi, görüntülemeden önce, görüntülenecek sonuçta, eleman sırasını karıştırır ve karıştırılmış sonucu görüntüler. Örnek olarak,
A = {23, 16, 45}
for i in A:
print(i ," ", end="")
Program Sonucu :
16 45 23
şeklinde erişim standarttır. Alınan görüntü, küme elemanlarına erişim sonucunun, eleman sırası karıştırılarak kullanıcıya yansıtılmasıdır. Doğal olarak kümenin eleman sayısı artar veya eksilirse, görüntülenen karıştırılmış eleman indisleri de değişecektir.
Küme elemanlarının anlık sıralamasını enumerate() fonksiyonunu uygulayarak alabiliriz. Fakat, enumerate () fonksiyonu da sadece küme elemanlarının o anki kompozisyonuna göre karıştırılmış sonuçları verir. Kümenin eleman sayısı artar veya eksilirse, eleman indisleri de değişecektir. Örnek:
L = {22, 44, 56, 77, 55, 44}
L= enumerate(L)
for i, j in L:
print('indis = {0} Eleman = {1}'.format(i, j))
Program Sonucu :
indis = 0 Eleman = 56
indis = 1 Eleman = 44
indis = 2 Eleman = 77
indis = 3 Eleman = 22
indis = 4 Eleman = 55
Küme elemanlarının yerleşim sıralarının belli olması ve elemanlara değişmeyen sıra numaraları ile erişim amaçlanıyorsa, frozenset veri tipi ile çalışılmalıdır.
3.4.3 - Kümelere Uygulanabilecek Metotlar
Küme veri sınıfı, matematikte tanımmlı ve işlem kuralları belli olan bir veri tipidir. Bu nedenle, Python programlama dilinde tanımlı tüm küme işlemlerinin yapılabilmesini sağlayacak öntanımlı fonksiyonlar sağlanmıştır.
Kümelere eleman eklenmesi, add() fonksiyonundan yararlanılarak yapılabilir. Bufonksiyon eklenmesi istenen elemanı inceler ve bu eleman zaten kümenin bir elemanı ise, ekleme isteğini geri çevirir. Örnek : (Eğer eklenecek elaman kümenin bir elemanı ile aynı ise)
küme22 = {2, (3, 6, 8), 33, 47}
küme22.add(3)
print(küme22)
Program Sonucu :
{33, 2, 3, (3, 6, 8), 47}
Eğer eklenecek eleman daha önce kümede bulunuyorsa,
küme22 = {2, (3, 6, 8), 33, 47}
küme22.add((3, 6, 8))
print(küme22)
Program Sonucu :
{33, 2, (3, 6, 8), 47}
Görüldüğü gibi, hiçbir uyarı veya kabul etmeme mesajı yok. Elemanın eklenip eklemedğini bilmiyoruz. Kümenin yapısı değişmemiş gibi duruyor.
Küme lemenlarından birini kümeden çıkarmak için, discard() fonksiyonu kullanılır. Örnek:
DF = {i**2 for i in {2, 3, 4}}
DF.discard(17)
print(DF)
Program Sonucu :
{16, 9, 4}
Yukarıdaki örnekte görüldüğü gibi, discard() foksiyonu, çıkartılmak istenen eleman kümede bulunmuyorsa, hiçbir işlem yapmaz ve hiçbir mesaj vermez. Oysaki remove() fonksiyonu, aşağıdaki örnekte görüldüğü gibi, eğer eleman kümede yoksa bir hata mesajı verir.
topluluk = (66, 77, 88, 99)
FG = set (topluluk)
FG.remove(26)
print(FG)
Program Sonucu : ---------------------------------------------------------------------------
KeyError Traceback (most recent call last)
<ipython-input-51-edd9a8f8c5f0> in <module>()
1 topluluk = (66, 77, 88, 99)
2 FG = set (topluluk)
----> 3 FG.remove(26)
4 print(FG)
KeyError: 26
Bir kümedeki tüm elemanların kaldırılması için, aşağıdaki örnekte görüldüğü gibi, clear() metodu çağrılır.
VT = {7, 'Niğde', 8, 'Adana'}
VT.clear()
print(VT)
Program Sonucu :
set()
Program sonucundan da görüldüü gibi, clear() metodu uygulandığında, VT kümesi, boş küme ∅ ye eşit olmaktadır.
Bir kümenin, sığ kopyalanması için, copy() metodu çağrılabilir.
P = {pow(i ,3) for i in {2,3,4,5}}
T = P.copy()
print(T)
Program Sonucu :
{8, 64, 27, 125}
Tanımlı A ve B kümelerinin farkı, A-B ifadesi ile gerçekleştirilebilir. Bu ifade hem A hem de B kümesinde bulunan her elemanı, A kümesinden çıkartarak, yeni bir kümeyi sonuç olarak geri dönürür.
A = {34, 55, 66, 12,}
B = {12, 34, 54, 42, 25,}
print(A-B)
Program Sonucu :
{66, 55}
Aynı sonuç, difference() metodu çağrılarak da alınır. Örnek,
A = {34, 55, 66, 12,}
B = {12, 34, 54, 42, 25,}
print(A.difference(B))
Program Sonucu :
{66 55}
A ve B kümelerinin farkı, A-=B ifadesi ile gerçekleştirilebilir. Bu işlem sonucunda, hem A hem de B kümesinde bulunan her eleman, A kümesinden çıkartılarak A kümesinin içeriği güncellenmiş olur. Örnek:
A = {34, 55, 66, 12,}
B = {12, 34, 54, 42, 25,}
A = A-B
print(A)
Program Sonucu :
{66, 55}
Aynı sonuç, difference_update() metodu çağrılarak da alınır. Fakat dikkat, önce güncelleştirmek sonra görüntülemek gerekir. Örnek,
A = {34, 55, 66, 12,}
B = {12, 34, 54, 42, 25,}
A.difference_update(B)
for i in A:
print(i)
Program Sonucu :
66
55
Eğer, print(A.difference_update(B)) dersek, geriye None döner, çünkü, tüm update metotlerı veriyi güncelleştirir ve geriye None döndürür fakat hiçbir zaman bu fonksiyonların geri döndürdükleri değer kullanılmaz. Bu fonksiyonlar güncellemelerini yaptıktan sonra, güncellenen nesne ile işlem yapılır. Aynen, yukarıdaki program da olduğu gibi, küme nesnesi önce güncelleniyor, sonra da güncellenen değeri görüntüleniyor. Eğer A = A.difference_update(B) sonra da print(A) denilirse yine None yanıtı alınır. Çünkü, A kümesinin değeri None olarak güncellenmiş olur ve bu da hiç istenmeyen bir şeydir.
A ve B kümelerinin kesişmeleri A & B , A.intersection(B) ve A.intersection_update(B) metotları ile incelenir. Dikkatli kullanılırsa her üçü de aynı sonucu verir.
A = {34, 55, 66, 12,}
B = {12, 34, 54, 42, 25,}
print(A & B)
print(A)
Program Sonucu :
set([34, 12])
set([66, 12, 34, 55])
A kümesinin güncellenmemiş oduğu görülüyor.
A = {34, 55, 66, 12,}
B = {12, 34, 54, 42, 25,}
print (A.intersection(B))
print(A)
Program Sonucu :
set([34, 12])
set([66, 12, 34, 55])
A kümesinin güncellenmemiş oduğu görülüyor.
A = {34, 55, 66, 12,}
B = {12, 34, 54, 42, 25,}
A &=B # intersection_update(B) anlamında
print(A)
Program Sonucu :
A = {34, 55, 66, 12,}
B = {12, 34, 54, 42, 25,}
A.intersection_update(B)
print(A)
Program Sonucu :
set([34, 12])
A kümesinin güncellenmiş oduğu görülüyor. Diğer metotlar A kümesini olduğu gibi bırakıyor sadece sonucu sanal ortamda oluşturup görüntülüyor. Bir tek A.intersection update(B) metodu A kümesini güncelliyor.
A ve B kümelerinin ayrık kümeler olup olmadıkları, isdisjoint() metodu çağrılarak saptanabilir.
Program Sonucu : A = {34, 55, 66, 12,} B = {12, 34, 54, 42, 25,} print(A.isdisjoint(B)) False
A ve B kümelerinin ortak elemanları olduğu böylece belirlenmiş olmaktadır.
A ve B kümelerinin birbirlerinin alt kümeleri olduğu, simgesel olarak, A >= B ve fonksiyon olarak A.issubset(B) ifadeleri ile sınanabilir. Bu fonksiyon, eğer A kümesi B ye eşit veya A kümesi B kümesinin bir alt kümesi ise True aksi halde False sonucunu verir.
A = {34, 55, 66, 12,}
B = {12, 34, 54, 42, 25,}
print(A >=B)
Program Sonucu :
False
A = {34, 55, 66, 12,}
B = {12, 34, 54, 42, 25,}
print(A. issubset(B))
Program Sonucu :
False
Bir A kümesinin bir B kümesinin özalt kümesi olup olmadığı s < t karşılaştırılması yapılarak saptanabilir. Örnek,
A = {34, 55, 66, 12,}
B = {12, 34, 54, 42, 25,}
print(A < B)
Program Sonucu :
False
Bir A kümesinin, bir B kümesinin üst kümesi olup olmadığı, simgesel olarak A > = B ifadesi ile, fonksiyonel olarak da A.issuperset(B) şekli,nde sınanabilir. Örnek,
A = {34, 55, 66, 12,}
B = {12, 34, 54, 42, 25,}
print(A >= B)
Program Sonucu :
False
A = {34, 55, 66, 12,}
B = {12, 34, 54, 42, 25,}
print(A.issuperset(B))
Program Sonucu :
False
Bir A kümesinin, bir B kümesinin özüst kümesi olup olmadığı, simgesel olarak A > B ifadesi ile sınanır. Örnek,
A = {34, 55, 66, 12,}
B = {12, 34, 54, 42, 25,}
print(A < B)
Program Sonucu :
False
Bir A kümesinin, bir B kümesi ile simetrik farkı, simgesel olarak, A ^ B ifadesi ile, fonksiyonel olarak da A.symmetric_difference(B) ifadesi ile sınanabilir. Bu ifade uygulandığında, elemanları ayrı ayrı A ve B kümelerinde bulunan, fakat her iki kümede birden bulunan elemanlar dışındaki elemanları içeren yeni bir küme oluşturulur. Örnek,
A = {34, 55, 66, 12,}
B = {12, 34, 54, 42, 25,}
print(A ^ B)
Program Sonucu :
set([66, 42, 54, 55, 25])
A = {34, 55, 66, 12,}
B = {12, 34, 54, 42, 25,}
print(A.symmetric_difference(B))
Program Sonucu :
set([66, 42, 54, 55, 25])
Abir A kümesinin içeriğinin, bir B kümesi ile simetrik fark sonucu ile güncellenmesi, simgesel olarak A ^= B veya fonksiyonel olarak, A.symmetric_difference_update(B) şeklinde gerçekleştirilebilir. Örnek,
A = {34, 55, 66, 12,}
B = {12, 34, 54, 42, 25,}
A ^= B
print(A)
Program Sonucu :
set([66, 42, 54, 55, 25])
A = {34, 55, 66, 12,}
B = {12, 34, 54, 42, 25,}
A.symmetric_difference_update(B)
print(A)
Program Sonucu :
set([66, 42, 54, 55, 25])
Bir A kümesi ile bie B kümesinin birleşimi, A daki tüm elamanları ve B deki, A da bulunmayan elemanları içeren yeni bir kümedir. Bu küme , simgesel olarak A | B ve fonksiyonel olarak da, A.union(B) şeklinde oluşturulur. Örnek,
A = {34, 55, 66, 12,}
B = {12, 34, 54, 42, 25,}
print(A | B)
Program Sonucu :
set([66, 42, 12, 34, 54, 55, 25])
A = {34, 55, 66, 12,}
B = {12, 34, 54, 42, 25,}
print(A.union(B))
Program Sonucu :
set([66, 42, 12, 34, 54, 55, 25])
Bir A kümesinin bir B kümesinin içeriği ile güncellenmesi, A nın elemanlarına A olan tüm elamanların ve B de olan fakat A da olmayan elemanların eklenerek genişletilmesidir. Bu olay simgesel olarak A |= B veya fonksiyonel olarak, A.update(B) şeklinde gerçekleştirilir. Örnek:
A = {34, 55, 66, 12,}
B = {12, 34, 54, 42, 25,}
A |= B
print(A)
Program Sonucu :
set([66, 42, 12, 34, 54, 55, 25])
A = {34, 55, 66, 12,}
B = {12, 34, 54, 42, 25,}
A.update(B)
print(A)
Program Sonucu :
set([66, 42, 12, 34, 54, 55, 25])