Python’un veri yapıları ailesinde özel bir yere sahip olan kümeler (Sets), matematiksel küme teorisinden ilham alan, benzersiz öğelerden oluşan, sırasız ve değiştirilebilir koleksiyonlardır. Listeler ve demetler gibi sıralı yapıların aksine, kümelerin temel amacı bir öğenin bir koleksiyonda var olup olmadığını hızla kontrol etmek ve kümeler arası matematiksel işlemleri (birleşim, kesişim, fark gibi) verimli bir şekilde gerçekleştirmektir.

Kümeler, özellikle veri temizleme (yinelenenleri kaldırma), üyelik testi ve iki veya daha fazla veri grubu arasındaki ilişkileri analiz etme gibi görevlerde parlar. Bu rehberde, Python kümelerinin ne olduğunu, temel özelliklerini (benzersizlik, sırasızlık, değiştirilebilirlik), nasıl oluşturulduklarını, öğe ekleme/çıkarma yöntemlerini ve en önemlisi, kümeler üzerinde gerçekleştirilebilen güçlü matematiksel işlemleri ayrıntılı örneklerle keşfedeceğiz. Ayrıca, kümelerin değiştirilemez versiyonu olan frozenset’e de değineceğiz.

Bölüm 1: Küme (Set) Nedir? Temel Kavramlar
Python’da bir küme (set), süslü parantezler {} içinde tanımlanan (veya set() yapıcısı ile oluşturulan), virgülle ayrılmış, benzersiz (unique) ve değiştirilemez (immutable) öğelerden oluşan, sırasız (unordered) ve kendisi değiştirilebilir (mutable) bir koleksiyondur.

Bu tanımı açalım:

Benzersiz Öğeler (Unique): Bir küme içindeki her öğe sadece bir kez bulunabilir. Aynı öğeyi kümeye tekrar eklemeye çalışmak, kümenin içeriğini değiştirmez. Bu, kümelerin en temel ve ayırt edici özelliğidir.
sayilar = {1, 2, 3, 2, 1, 4, 3} # Tekrarlanan değerler otomatik olarak yok sayılır print(sayilar) # Çıktı: {1, 2, 3, 4} (Sıra garanti değil)
Sırasız (Unordered): Listeler ve demetlerin aksine, kümelerdeki öğelerin belirli bir sırası yoktur. Bu nedenle, öğelere indeks numaralarıyla (kume[0] gibi) erişilemez. Küme üzerinde iterasyon yapıldığında öğelerin hangi sırada geleceği garanti edilmez (ancak genellikle belirli bir iç tutarlılık gösterir).
harfler = {'a', 'c', 'b'} print(harfler) # Çıktı örneğin {'c', 'a', 'b'} veya {'b', 'a', 'c'} olabilir # print(harfler[0]) # TypeError: 'set' object is not subscriptable (indekslenemez)
Sırasız olmaları, kümelerin öğe ekleme, çıkarma ve özellikle üyelik testi (bir öğenin kümede olup olmadığını kontrol etme) işlemlerini çok hızlı (ortalama O(1) zaman karmaşıklığı) yapmasını sağlayan hash tablosu uygulamasından kaynaklanır.
Değiştirilebilir (Mutable): Kümenin kendisi değiştirilebilir. Oluşturulduktan sonra kümeye yeni öğeler eklenebilir veya var olan öğeler çıkarılabilir.
Değiştirilemez (Immutable) Öğeler Gerektirir: Kümelerin içerebileceği öğeler, sözlük anahtarları gibi, değiştirilemez (immutable) ve hash’lenebilir (hashable) olmalıdır. Sayılar (int, float), stringler (str), booleanlar (bool) ve içinde sadece değiştirilemez öğeler barındıran demetler (tuple) küme öğesi olabilir. Listeler, diğer kümeler veya sözlükler gibi değiştirilebilir tipler bir kümenin öğesi olamaz.
gecerli_kume = {1, "metin", 3.14, True, (1, 2)} print(gecerli_kume) # Geçersiz öğe denemesi: try: gecersiz_kume = {1, 2, [3, 4]} # Liste öğesi olamaz except TypeError as e: print(f"\nHata (Liste Öğesi): {e}") # Hata: unhashable type: 'list' try: gecersiz_kume_2 = {1, 2, {3, 4}} # Küme öğesi olamaz except TypeError as e: print(f"Hata (Küme Öğesi): {e}") # Hata: unhashable type: 'set'
Bölüm 2: Küme Oluşturma
Python’da küme oluşturmanın iki ana yolu vardır:

2.1. Süslü Parantez Kullanarak ({}) - Boş Olmayan Kümeler İçin
Boş olmayan bir küme oluşturmak için öğeleri süslü parantezler içine virgülle ayırarak yazabilirsiniz.

Sayılardan oluşan küme

sayi_kumesi = {10, 20, 30, 40, 20} # 20 sadece bir kez yer alır
print(f"Sayı Kümesi: {sayi_kumesi}") # {10, 20, 30, 40} (sıra farklı olabilir)

Stringlerden oluşan küme

meyve_kumesi = {"elma", "armut", "çilek", "elma"}
print(f"Meyve Kümesi: {meyve_kumesi}") # {'armut', 'elma', 'çilek'} (sıra farklı olabilir)

Karışık tiplerden oluşan küme

karma_kume = {1, "a", 3.5, True, (1, 'x')}
print(f"Karma Küme: {karma_kume}")
2.2. set() Yapıcı Fonksiyonu Kullanarak
set() fonksiyonu:

Boş Küme Oluşturmak İçin Zorunludur: Boş bir küme oluşturmak için süslü parantez {} kullanamazsınız, çünkü bu boş bir sözlük oluşturur. Boş küme için mutlaka set() kullanmalısınız.
Yinelenebilir Nesnelerden Küme Oluşturmak İçin: Bir liste, tuple, string veya başka bir yinelenebilir nesneyi argüman olarak alıp, bu nesnedeki benzersiz öğelerden oluşan yeni bir küme oluşturur.

Boş küme oluşturma

bos_kume = set()
print(f"Boş Küme: {bos_kume}, Tipi: {type(bos_kume)}")

Boş sözlük (karşılaştırma için)

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

Listeden küme oluşturma (yinelenenler atılır)

my_list = [1, 2, 2, 3, 1, 4, 5, 4]
kume_from_list = set(my_list)
print(f"Listeden Küme: {kume_from_list}") # {1, 2, 3, 4, 5}

String'den küme oluşturma (benzersiz harfler)

kume_from_string = set("programlama")
print(f"String'den Küme: {kume_from_string}") # {'g', 'o', 'r', 'l', 'm', 'a', 'p'} (sıra farklı olabilir)

Tuple'dan küme oluşturma

my_tuple = ('x', 'y', 'z', 'x')
kume_from_tuple = set(my_tuple)
print(f"Tuple'dan Küme: {kume_from_tuple}") # {'y', 'x', 'z'}
Boş küme oluştururken {} yerine set() kullanmayı unutmak yaygın bir başlangıç hatasıdır.

Bölüm 3: Temel Küme İşlemleri ve Metotları
Kümeler değiştirilebilir olduğu için, öğe ekleme ve çıkarma işlemleri için çeşitli metotlar sunarlar.

3.1. Öğğe Ekleme
add(item)
Ne Yapar: Verilen item'ı (öğeyi) kümeye ekler. Eğer öğe zaten kümede varsa, küme değişmez (hata vermez).
Değişiklik: Kümeyi yerinde (in-place) değiştirir.
Dönüş Değeri: None
Kısıtlama: Eklenen item değiştirilemez (immutable) ve hash'lenebilir olmalıdır.
renkler = {"kırmızı", "mavi"}
print(f"Başlangıç: {renkler}")
renkler.add("yeşil")
print(f"add('yeşil') sonrası: {renkler}") # {'mavi', 'kırmızı', 'yeşil'}
renkler.add("kırmızı") # Zaten var, küme değişmez
print(f"add('kırmızı') sonrası: {renkler}") # {'mavi', 'kırmızı', 'yeşil'}

renkler.add([1, 2]) # TypeError: unhashable type: 'list'

update(iterable)
Ne Yapar: Verilen iterable (liste, tuple, string, başka bir küme vb.) içindeki tüm öğeleri mevcut kümeye ekler. Yinelenen öğeler veya kümede zaten var olan öğeler sadece bir kez yer alır.
Değişiklik: Kümeyi yerinde (in-place) değiştirir.
Dönüş Değeri: None
Kısıtlama: iterable içindeki tüm öğeler değiştirilemez ve hash'lenebilir olmalıdır.
kume1 = {1, 2}
liste1 = [2, 3, 4]
kume2 = {4, 5, 6}
metin = "abc"
print(f"Başlangıç kume1: {kume1}") # {1, 2}
kume1.update(liste1) # liste1'deki öğeleri ekle (2 zaten var)
print(f"update(liste1) sonrası: {kume1}") # {1, 2, 3, 4}
kume1.update(kume2) # kume2'deki öğeleri ekle (4 zaten var)
print(f"update(kume2) sonrası: {kume1}") # {1, 2, 3, 4, 5, 6}
kume1.update(metin) # metin'deki karakterleri ekle
print(f"update(metin) sonrası: {kume1}") # {1, 2, 3, 4, 5, 6, 'c', 'a', 'b'}

update metodu birleşim (|) operatörünün in-place versiyonu gibi düşünülebilir ( |= )

kume1 |= kume2 # kume1.update(kume2) ile aynı işi yapar

3.2. Öğğe Çıkarma
remove(item)
Ne Yapar: Belirtilen item'ı kümeden çıkarır.
Değişiklik: Kümeyi yerinde (in-place) değiştirir.
Dönüş Değeri: None
Hata: Eğer belirtilen item kümede bulunmuyorsa KeyError hatası verir.
rakamlar = {0, 1, 2, 3, 4}
print(f"Başlangıç: {rakamlar}")
rakamlar.remove(3)
print(f"remove(3) sonrası: {rakamlar}") # {0, 1, 2, 4}

Olmayan öğeyi çıkarmaya çalışmak:

try:
rakamlar.remove(9)
except KeyError as e:
print(f"\nHata (remove): Öğğe bulunamadı - {e}")
discard(item)
Ne Yapar: Belirtilen item'ı kümeden çıkarır.
Değişiklik: Kümeyi yerinde (in-place) değiştirir.
Dönüş Değeri: None
Farkı: Eğer belirtilen item kümede bulunmuyorsa, remove'dan farklı olarak hata vermez, hiçbir şey yapmaz. Bu, bir öğenin kümede olup olmadığından emin olmadığınızda daha güvenli bir çıkarma yöntemidir.
harfler = {'x', 'y', 'z'}
print(f"Başlangıç: {harfler}")
harfler.discard('y')
print(f"discard('y') sonrası: {harfler}") # {'x', 'z'}

Olmayan öğeyi çıkarmaya çalışmak (hata vermez):

harfler.discard('a')
print(f"discard('a') sonrası: {harfler}") # {'x', 'z'} (Değişiklik yok)
pop()
Ne Yapar: Kümeden rastgele (arbitrary) bir öğeyi çıkarır ve bu öğeyi döndürür. Kümeler sırasız olduğu için hangi öğenin çıkarılacağı önceden bilinemez.
Değişiklik: Kümeyi yerinde (in-place) değiştirir.
Dönüş Değeri: Çıkarılan rastgele öğe.
Hata: Eğer küme boşsa KeyError hatası verir.
kume = {10, 20, 30, 40}
print(f"Başlangıç: {kume}")
try:
cikarilan1 = kume.pop()
print(f"Pop 1 sonrası küme: {kume}")
print(f"Çıkarılan öğe 1: {cikarilan1}") # Hangi öğenin çıktığı belli değil
cikarilan2 = kume.pop()
print(f"Pop 2 sonrası küme: {kume}")
print(f"Çıkarılan öğe 2: {cikarilan2}")
except KeyError:
print("Küme zaten boş.")

Boş kümeden pop denemesi

bos_kume = set()
try:
bos_kume.pop()
except KeyError as e:
print(f"\nBoş küme hatası (pop): {e}") # 'pop from an empty set'
clear()
Ne Yapar: Kümedeki tüm öğeleri siler, kümeyi boşaltır.
Değişiklik: Kümeyi yerinde (in-place) değiştirir.
Dönüş Değeri: None
silinecek_kume = {1, 'a', True}
print(f"Başlangıç: {silinecek_kume}")
silinecek_kume.clear()
print(f"Clear sonrası: {silinecek_kume}") # set()
3.3. Diğer Temel İşlemler
Üyelik Testi (in / not in)
Bir öğenin kümede olup olmadığını kontrol etmek için kullanılır. Kümeler bu işlem için hash tabloları sayesinde optimize edilmiştir ve çok hızlıdır (ortalama O(1)).

k = {10, 20, 30, "a"}
print(f"20 kümede var mı? {20 in k}") # True
print(f"'b' kümede var mı? {'b' in k}") # False
print(f"40 kümede yok mu? {40 not in k}") # True
Uzunluk (len())
Kümedeki benzersiz öğe sayısını döndürür.

k = {10, 20, 30, "a"}
print(f"Küme uzunluğu: {len(k)}") # 4
İterasyon (for Döngüsü)
Kümenin öğeleri üzerinde for döngüsü ile gezinebilirsiniz. Ancak öğelerin hangi sırada geleceği garanti edilmez.

k = {10, 20, 30, "a"}
print("Küme öğeleri (sırasız):")
for eleman in k:
print(f"- {eleman}")
Kopyalama (copy())
Listenin sığ bir kopyasını (shallow copy) oluşturur. İçeride değiştirilebilir nesneler (ki küme elemanı olamazlar, ancak frozenset içinde olabilirler) varsa dikkatli olunmalıdır.

orijinal_kume = {1, 2, 3}
kopya_kume = orijinal_kume.copy()
print(f"Orijinal: {orijinal_kume}")
print(f"Kopya: {kopya_kume}")
print(f"Orijinal is Kopya? {orijinal_kume is kopya_kume}") # False (Farklı nesneler)
kopya_kume.add(4)
print(f"\nKopya değiştirildi: {kopya_kume}")
print(f"Orijinal (etkilenmedi): {orijinal_kume}")
Bölüm 4: Matematiksel Küme İşlemleri
Kümelerin asıl gücü, matematikteki küme teorisi operasyonlarını doğrudan desteklemelerinden gelir. Bu işlemler, veri setleri arasındaki ilişkileri bulmak ve verileri birleştirmek/ayırmak için çok kullanışlıdır.

Aşağıdaki örnekler için şu kümeleri kullanalım:

kume_A = {1, 2, 3, 4, 5}
kume_B = {4, 5, 6, 7, 8}
kume_C = {1, 2}
4.1. Birleşim (Union)
Ne Yapar: Her iki kümede bulunan tüm benzersiz öğeleri içeren yeni bir küme döndürür.
Operatör: Dikey çizgi |
Metot: kume1.union(kume2, kume3, ...) (birden fazla küme ile birleştirilebilir)

Operatör ile birleşim

birlesim_ab = kume_A | kume_B
print(f"A | B: {birlesim_ab}") # {1, 2, 3, 4, 5, 6, 7, 8}

Metot ile birleşim

birlesim_ac = kume_A.union(kume_C) # veya kume_A.union({1, 2})
print(f"A.union(C): {birlesim_ac}") # {1, 2, 3, 4, 5} (C'deki elemanlar zaten A'da var)
birlesim_abc = kume_A.union(kume_B, kume_C)
print(f"A.union(B, C): {birlesim_abc}") # {1, 2, 3, 4, 5, 6, 7, 8}
4.2. Kesişim (Intersection)
Ne Yapar: Her iki kümede de ortak olarak bulunan öğeleri içeren yeni bir küme döndürür.
Operatör: Ampersand &
Metot: kume1.intersection(kume2, kume3, ...)

Operatör ile kesişim

kesisim_ab = kume_A & kume_B
print(f"A & B: {kesisim_ab}") # {4, 5}

Metot ile kesişim

kesisim_ac = kume_A.intersection(kume_C)
print(f"A.intersection(C): {kesisim_ac}") # {1, 2}

Ortak eleman yoksa boş küme döner

kesisim_bc = kume_B.intersection(kume_C)
print(f"B.intersection(C): {kesisim_bc}") # set()
4.3. Fark (Difference)
Ne Yapar: İlk kümede bulunan ancak ikinci kümede bulunmayan öğeleri içeren yeni bir küme döndürür. Sıra önemlidir (A - B ile B - A farklıdır).
Operatör: Eksi işareti -
Metot: kume1.difference(kume2, kume3, ...) (ilk kümenin diğer kümelerden farkı)

Operatör ile fark

fark_a_b = kume_A - kume_B # A'da olup B'de olmayanlar
print(f"A - B: {fark_a_b}") # {1, 2, 3}
fark_b_a = kume_B - kume_A # B'de olup A'da olmayanlar
print(f"B - A: {fark_b_a}") # {6, 7, 8}

Metot ile fark

fark_a_c = kume_A.difference(kume_C)
print(f"A.difference(C): {fark_a_c}") # {3, 4, 5}
4.4. Simetrik Fark (Symmetric Difference)
Ne Yapar: Her iki kümede bulunan ancak ortak olmayan (sadece bir kümede bulunan) tüm öğeleri içeren yeni bir küme döndürür. (Birleşimden kesişimin çıkarılması gibidir: (A | B) - (A & B)).
Operatör: Şapka (caret) ^
Metot: kume1.symmetric_difference(kume2)

Operatör ile simetrik fark

sim_fark_ab = kume_A ^ kume_B # Sadece A'da veya sadece B'de olanlar
print(f"A ^ B: {sim_fark_ab}") # {1, 2, 3, 6, 7, 8}

Metot ile simetrik fark

sim_fark_ac = kume_A.symmetric_difference(kume_C) # Sadece A'da olanlar (C, A'nın alt kümesi olduğu için)
print(f"A.symmetric_difference(C): {sim_fark_ac}") # {3, 4, 5}
4.5. Yerinde (In-place) Güncelleme Metotları
Yukarıdaki matematiksel işlemlerin (birleşim, kesişim, fark, simetrik fark) sonuçlarını yeni bir küme olarak döndürmek yerine, işlemi yapan orijinal kümeyi güncelleyen metotlar da vardır. Bu metotlar _update sonekiyle biter veya ilgili operatörün atama versiyonu (|=, &=, -=, ^=) kullanılır. Bu metotlar None döndürür.

Birleşim Güncelleme: kume1.update(kume2) veya kume1 |= kume2
Kesişim Güncelleme: kume1.intersection_update(kume2) veya kume1 &= kume2
Fark Güncelleme: kume1.difference_update(kume2) veya kume1 -= kume2
Simetrik Fark Güncelleme: kume1.symmetric_difference_update(kume2) veya kume1 ^= kume2
kumeX = {1, 2, 3}
kumeY = {3, 4, 5}
print(f"Başlangıç kumeX: {kumeX}")

Kesişim Güncelleme

kumeX.intersection_update(kumeY) # veya kumeX &= kumeY
print(f"Kesişim update sonrası kumeX: {kumeX}") # {3}

Tekrar başlatalım

kumeX = {1, 2, 3}

Fark Güncelleme

kumeX.difference_update(kumeY) # veya kumeX -= kumeY
print(f"Fark update sonrası kumeX: {kumeX}") # {1, 2}
Bölüm 5: Küme İlişkileri Metotları
Kümeler arasındaki kapsama ilişkilerini kontrol etmek için kullanılan boolean metotlar vardır.

5.1. issubset(other) ve <= Operatörü
Ne Yapar: Mevcut kümenin tüm öğeleri other kümesinde de bulunuyorsa (yani alt kümesi ise) True döner.
<= operatörü de aynı işlevi görür.
5.2. Proper Subset (<)
Ne Yapar: Mevcut küme, other kümesinin alt kümesi ise ve other kümesinden farklı ise (yani en az bir elemanı eksikse) True döner.
Sadece < operatörü kullanılır, ayrı bir metodu yoktur.
5.3. issuperset(other) ve >= Operatörü
Ne Yapar: other kümesinin tüm öğeleri mevcut kümede de bulunuyorsa (yani üst kümesi ise) True döner.

= operatörü de aynı işlevi görür.
5.4. Proper Superset (>)
Ne Yapar: Mevcut küme, other kümesinin üst kümesi ise ve other kümesinden farklı ise (yani en az bir fazla elemanı varsa) True döner.
Sadece > operatörü kullanılır, ayrı bir metodu yoktur.
5.5. isdisjoint(other)
Ne Yapar: İki kümenin hiçbir ortak elemanı yoksa (kesişimleri boş küme ise) True döner.
set1 = {1, 2, 3}
set2 = {1, 2, 3, 4, 5}
set3 = {1, 2}
set4 = {4, 5, 6}
set5 = {1, 2, 3} # set1 ile aynı

Alt Küme (Subset)

print(f"set1 <= set2 ? {set1 <= set2}") # True
print(f"set3.issubset(set1)? {set3.issubset(set1)}") # True
print(f"set1 <= set5 ? {set1 <= set5}") # True (Kendisi de alt kümesidir)
print(f"set1 < set5 ? {set1 < set5}") # False (Proper subset değil)
print(f"set3 < set1 ? {set3 < set1}") # True (Proper subset)

Üst Küme (Superset)

print(f"\nset2 >= set1 ? {set2 >= set1}") # True
print(f"set1.issuperset(set3)? {set1.issuperset(set3)}") # True
print(f"set1 >= set5 ? {set1 >= set5}") # True (Kendisi de üst kümesidir)
print(f"set1 > set5 ? {set1 > set5}") # False (Proper superset değil)
print(f"set2 > set3 ? {set2 > set3}") # True (Proper superset)

Ayrık Küme (Disjoint)

print(f"\nset1.isdisjoint(set4)? {set1.isdisjoint(set4)}") # True (Ortak eleman yok)
print(f"set1.isdisjoint(set2)? {set1.isdisjoint(set2)}") # False (Ortak elemanlar var: 1, 2, 3)
print(f"set3.isdisjoint(set4)? {set3.isdisjoint(set4)}") # True
Bölüm 6: Donmuş Kümeler (frozenset)
Normal set tipi değiştirilebilir (mutable) olduğu için, hash'lenemez ve bu nedenle bir sözlük anahtarı veya başka bir kümenin öğesi olamaz. Bu kısıtlamayı aşmak için Python, kümelerin değiştirilemez (immutable) bir versiyonu olan frozenset'i sunar.

Oluşturma: frozenset(iterable) yapıcısı ile oluşturulur. Süslü parantez notasyonu yoktur.
Değişmezlik: Bir frozenset oluşturulduktan sonra öğeleri eklenemez, çıkarılamaz veya değiştirilemez. add, remove, update, pop, clear gibi değiştirici metotları yoktur.
Hash’lenebilirlik: Değişmez oldukları için hash’lenebilirler. Bu sayede sözlük anahtarı veya başka bir kümenin (veya frozenset’in) öğesi olabilirler.
Desteklenen İşlemler: Matematiksel küme işlemleri (|, &, -, ^, union, intersection vb.), ilişki metotları (issubset, isdisjoint vb.), len(), in, copy() gibi değiştirici olmayan tüm operasyonları desteklerler.

frozenset oluşturma

frozen1 = frozenset([1, 2, 3, 2]) # Listeden
frozen2 = frozenset("abc") # String'den
print(f"Frozen Set 1: {frozen1}") # frozenset({1, 2, 3})
print(f"Frozen Set 2: {frozen2}") # frozenset({'c', 'a', 'b'})

Değiştirme denemesi (hata verir):

try:
frozen1.add(4)
except AttributeError as e:
print(f"\nHata (frozenset.add): {e}")

Matematiksel işlemler çalışır (yeni frozenset döner):

birlesim_frozen = frozen1.union({3, 4, 5})
print(f"\nFrozen Birleşim: {birlesim_frozen}") # frozenset({1, 2, 3, 4, 5})

Sözlük anahtarı olarak kullanma

yetkiler = {
frozenset(["read", "write"]): "Admin",
frozenset(["read"]): "User",
frozenset(): "Guest" # Boş frozenset
}
kullanici_yetkileri = frozenset(["read"])
print(f"\nKullanıcının Rolü: {yetkiler[kullanici_yetkileri]}") # User

Küme içinde frozenset kullanma

kume_icinde_frozen = {1, "a", frozenset({8, 9})}
print(f"\nİçinde Frozenset Olan Küme: {kume_icinde_frozen}")
frozenset, içeriğinin değişmeyeceğinden emin olmak istediğiniz veya hash'lenebilir bir küme temsiline ihtiyaç duyduğunuz durumlarda kullanılır.

Bölüm 7: Kümelerin Kullanım Alanları
Kümeler, benzersizlik ve hızlı üyelik testi özellikleri sayesinde birçok pratik uygulamada kullanılır:

Yinelenenleri Kaldırma (Deduplication): Bir listedeki veya başka bir yinelenebilirdeki tekrar eden öğeleri kaldırmanın en kolay ve hızlı yollarından biridir.

tekrarli_liste = [1, 5, 2, 8, 5, 1, 9, 2, 10] benzersiz_ogeler_kumesi = set(tekrarli_liste) print(f"Benzersiz Öğeler (Küme): {benzersiz_ogeler_kumesi}") # {1, 2, 5, 8, 9, 10} benzersiz_liste = list(benzersiz_ogeler_kumesi) # İstenirse tekrar listeye çevrilebilir print(f"Benzersiz Öğeler (Liste): {benzersiz_liste}") # Tek satırda: list(set(tekrarli_liste))
Hızlı Üyelik Testi (Fast Membership Testing): Bir öğenin büyük bir koleksiyonda bulunup bulunmadığını çok hızlı bir şekilde kontrol etmek gerektiğinde kümeler listelere göre çok daha verimlidir.

buyuk_liste = list(range(1000000)) buyuk_kume = set(buyuk_liste) aranan_sayi = 999999 # Listede arama (yavaş olabilir) # %timeit aranan_sayi in buyuk_liste # Jupyter/IPython'da zaman ölçümü # Kümede arama (çok hızlı) # %timeit aranan_sayi in buyuk_kume # Jupyter/IPython'da zaman ölçümü print(f"{aranan_sayi} kümede var mı? {aranan_sayi in buyuk_kume}") # True
Matematiksel Küme İşlemleri: İki veya daha fazla veri grubu arasındaki ortak öğeleri (kesişim), farklı öğeleri (fark), birleşik öğeleri (birleşim) veya sadece birinde bulunan öğeleri (simetrik fark) bulmak için idealdir. Örneğin:

İki kullanıcının ortak arkadaşlarını bulma (kesişim).
Bir grupta olup diğerinde olmayan üyeleri bulma (fark).
İki listedeki tüm benzersiz öğeleri birleştirme (birleşim).
grup_A_uyeler = {"ali", "veli", "ayşe", "can"} grup_B_uyeler = {"ayşe", "fatma", "can", "bora"} ortak_uyeler = grup_A_uyeler.intersection(grup_B_uyeler) print(f"Ortak Üyeler: {ortak_uyeler}") # {'can', 'ayşe'} sadece_A_da_olanlar = grup_A_uyeler.difference(grup_B_uyeler) print(f"Sadece A'da Olanlar: {sadece_A_da_olanlar}") # {'veli', 'ali'} tum_benzersiz_uyeler = grup_A_uyeler.union(grup_B_uyeler) print(f"Tüm Benzersiz Üyeler: {tum_benzersiz_uyeler}") # {'can', 'bora', 'fatma', 'ayşe', 'veli', 'ali'}
Veri Temizleme ve Doğrulama: Geçerli değerler kümesi tanımlayıp, gelen verinin bu kümede olup olmadığını kontrol etmek için kullanılabilir.

Sonuç
Python kümeleri (set) ve onların değiştirilemez ikizi frozenset, benzersiz öğelerle çalışmak ve matematiksel küme operasyonlarını verimli bir şekilde gerçekleştirmek için tasarlanmış güçlü veri yapılarıdır. Sırasız olmaları ve sadece değiştirilemez öğeleri barındırabilmeleri gibi kendilerine özgü kuralları olsa da, bu özellikler onlara özellikle yinelenenleri kaldırma ve hızlı üyelik testi gibi alanlarda büyük avantajlar sağlar.

Birleşim, kesişim, fark gibi matematiksel işlemler, veri setleri arasındaki ilişkileri analiz etmede ve verileri filtrelemede önemli araçlardır. Doğru yerde kullanıldığında kümeler, kodunuzu daha kısa, daha okunaklı ve genellikle daha performanslı hale getirebilir.

Listelerin, demetlerin ve sözlüklerin yanında kümeleri de anlamak ve ne zaman kullanılacağını bilmek, Python’daki veri yapıları bilginizi tamamlar ve daha etkili çözümler üretmenize olanak tanır.

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