# # Python Kümeler

Python koleksiyonlar (diziler) altında yer alan **küme (set)** veri tipimiz *sıralanamayan* , değiştirilemeyen, *indekslenemeyen ve çoğul elemana izin vermeyen* bir veri tipidir. Süslü parantezlerle `{ }` oluşturulur.

```python
kume = {"elma","armut","çilek"}
```

{% hint style="warning" %}
Eleman olmadan sadece parantezlerle boş bir küme oluşturamazsınız.
{% endhint %}

```python
kume = {} # !!! Küme değil Sözlük veri tipi !!!

print(type(kume)) # <class 'dict'>
```

Kümeler aynı zamanda bir **set()** fonksiyonu ile de oluşturulabilir ve constructor yöntemiyle başlangıçta elemanları ayarlanabilir.

```python
kume = set()

kume = set(("Ankara","İstanbul","Kayseri"))
```

Oluşturduğumuz `küme` değişkenlerinin tipini kontrol edelim.

```python
print(type(kume)) # <class 'set'>
```

## 1. Küme Elemanlarına Erişim

Başlangıçta küme veri tipinin indekslenemeyeceğini söylemiştik. Bu nedenle bir indeks numarası belirterek herhangi bir elemana erişemezsiniz. Bunun yerine kümemizi **for** ile bir döngüye sokarak elemanları yazdırabiliriz.

```python
kume = {"elma","armut","çilek"}

for x in kume: 
    print(x)
```

Bu şekilde kümenin tüm elemanları x değeri üzerinden otomatik olarak listelenecek ve dizi elemanı bittiğinde döngü duracaktır.

## 2. Küme Eleman Sayısını Öğrenme

Elinizde olan bir kümenin eleman sayısını öğrenmek için **len()** fonksiyonunu kullanacağız.

```python
kume = {"a","b","c","d"}

print(len(kume)) #4
```

## 3. Bir Elemanın Varlığını Kontrol Etme

Kümede bir elemanın olup olmadığını kontrol etmek için in terimini kullanacağız. Eğer eleman varsa `True` , yoksa `False` değerini alırız.

```python
kume = {"a","b","c","d"}

print("b" in kume) # True 
print("f" in kume) # False
```

## 4. Küme Elemanının Değerini Değiştirme

{% hint style="warning" %}
Bir küme oluşturduğunuzda tıpkı demetlerde olduğu gibi artık elemanlarını değiştiremezsiniz.
{% endhint %}

## 5. Kümeye Yeni Eleman Ekleme

Oluşturduğumuz kümeye yeni bir eleman eklemek için **add()** fonksiyonunu kullanabilirsiniz.

```python
kume = {"a","b","c"}

kume.add("g")

print(kume) # {"b","c","g","a"}
```

Eğer tek seferde birden fazla eleman eklemek istiyorsanız **update()** fonksiyonunu kullanabilirsiniz.

```python
kume = {"a","b","c"}

kume.update(["x","y","z"])

print(kume) # {'y', 'c', 'b', 'x', 'z', 'a'}
```

Kümeye toplu eleman eklerken `update()` fonksiyonuna bir liste veya demet göndererek de ekleme işlemi yapabilirsiniz.

```python
kume = {"a","b","c"}
liste = ["x","y","z"] 
demet = (1,2,3)

kume.update(liste) 
kume.update(demet)

print(kume) # {1, 2, 3, 'y', 'a', 'x', 'c', 'b', 'z'}
```

{% hint style="info" %}
Küme elemanlarını ekrana yazdırdığınızda elemanların karışık bir halde geldiğini görürsünüz. Kümeler sıralanamayan bir veri tipi olduğu için her seferinde elemanların yeri değişir.
{% endhint %}

## 6. Kümeden Bir Eleman Çıkarmak

Kümemizden bir elemanı çıkarmak istediğimizde **remove()** veya **discard()** fonksiyonlarını kullanabiliriz. Her iki fonksiyonda işlevsellik olarak aynıdır.

```python
kume = {"a","b","c","d"}

kume.remove("b")

print(kume) # {'a', 'c', 'd'}
```

````python
```py kume = {"a","b","c","d"}

kume.discard("b")

print(kume) # {'d', 'c', 'a'}
````

{% hint style="info" %}
Her iki fonksiyonda işlevsel olarak aynı olmasına rağmen kümede olmayan bir elemanı kaldırmaya çalıştığınızda `remove()` fonksiyonu **hata mesajı verirken** , `discard()` fonksiyonu **hata mesajı vermez** .
{% endhint %}

Bu iki fonksiyonun dışında kümenin sondaki elemanını çıkarmak için **pop()** fonksiyonunu kullanabiliriz. Fakat kümeler **sıralanamayan** bir veri tipi olduğundan ve her seferinde elemanların yeri değişeceğinden hangi elemanın kümeden çıkarılacağı `pop()` fonksiyonunda **belli olmaz.**

```python
kume = {"a","b","c","d"}

kume.pop()

print(kume) # {'a', 'c', 'b'}
```

Kümedeki tüm elemanları çıkararak kümeyi temizlemek istediğinizde boş bir küme elde etmek için **clear()** fonksiyonunu kullanabilirsiniz.

```python
kume = {"a","b","c","d"}

kume.clear()

print(kume) # set()
```

## 7. Kümeyi Tamamen Silmek

Kümeden elemanları çıkarmak veya kümeyi temizlemek yerine isterseniz kümenizi tamamen silebilirsiniz. Bunun için **del** terimini kullanabilirsiniz. Fakat kümeyi sildikten sonra kullanmaya çalışırsanız hata alacaksınızdır.

```python
kume = {"a","b","c","d"}

del kume

print(kume) # !!! HATA VERİR !!!
```

## 8.  **Küme** Kopyalamak ve Çoğaltmak

Elimizde olan bir kümeyi kopyalayarak çoğaltmak için **copy()** fonksiyonunu kullanabilirsiniz.

```python
kume = {"a","b","c","d"}

yenikume = kume.copy()

print(yenikume) # {'a', 'd', 'b', 'c'}
```

Başka bir basit yöntemde kopyalanacak kümeyi belirterek yeni bir küme oluşturmaktır.

```python
kume = {"a","b","c","d"}

yenikume = set(kume)

print(yenikume) # {'b', 'a', 'c', 'd'}
```

## 11. İki Farklı Kümeyi Birleştirmek

Birbirinden farklı veya aynı iki kümeyi birleştirmek için **union()** ve **update()** fonksiyonlarını kullanabiliriz.

```python
kume1 = {"A","B","C"} 
kume2 = {"D","E"}

kume3 = kume1.union(kume2)

print(kume3) # {'E', 'C', 'D', 'B', 'A'}
```

```python
kume1 = {"A","B","C"} 
kume2 = {"D","E"}

kume1.update(kume2)

print(kume1) # {'D', 'C', 'E', 'B', 'A'}
```

{% hint style="info" %}
Küme veri tipindeki değişkenler aynı elemandan birden fazla bulunmasına izin vermeyeceği için kümeleri birleştirirken eğer aynı elemandan mevcutsa kümeden çıkarılacaktır.
{% endhint %}

```python
kume1 = {"A","B","C"} 
kume2 = {"A"}

kume3 = kume1.union(kume2)

print(kume3) # {"A","B","C"}
```

## 12. İki Farklı Kümenin Kesişimini Almak

Öncelikle elimizdeki iki kümenin kesişimi olup olmadığını öğrenmek için **isdisjoint()** fonksiyonunu kullanabiliriz. Eğer kümelerin kesişimi varsa **False** , yoksa **True** değeri döner.

```python
 kume1 = {"A","B","C"} 
 kume2 = {"A","D"} 
 kume3 = {"F","G"}
 
print(kume1.isdisjoint(kume2)) # False 
print(kume1.isdisjoint(kume3)) # True
```

İki kümenin kesişimini almak için **intersection()** fonksiyonunu kullanabiliriz.

```python
kume1 = {"A","B","C"} 
kume2 = {"A","D"}

kesisim= kume1.intersection(kume2)

print(kesisim) # {"A"}
```

Eğer iki kümenin kesişimini aldıktan sonra kümeyi bu kesişim elemanlarıyla güncellemek isterseniz **intersection\_update()** fonksiyonunu kullanabiliriz.

```python
kume1 = {"A","B","C"} 
kume2 = {"A","D"}

kume1.intersection_update(kume2)

print(kume1) # {"A"}
```

## 13. İki Farklı Kümenin Farkını Almak

Bir kümenin diğer kümeden farkını almak için **difference()** fonksiyonunu kullanabilirsiniz.

```python
kume1 = {"A","D","G"} 
kume2 = {"A","B","C","D"}

# kume1 in kume2 den farkı
fark = kume1.difference(kume2)

print(fark) # {"G"}
```

Eğer iki kümenin farkını aldıktan sonra kümeyi bu fark elemanlarıyla güncellemek isterseniz **difference\_update()** fonksiyonunu kullanabiliriz.

```python
kume1 = {"A","D","G"} 
kume2 = {"A","B","C","D"}

#kume1 in kume2 den farkı
kume1.difference_update(kume2)

print(kume1) # {"G"}
```

## 14. Kümenin Alt Küme Olup Olmadığını Kontrol Etme

Elimizdeki kümenin başka bir kümenin alt kümesi olup olmadığını kontrol etmek için **issubset()** fonksiyonunu kullanabiliriz.

```python
kume1 = {"A","B"} 
kume2 = {"A","B","C","D"}

print(kume1.issubset(kume2)) # True
```

## 14. Kümenin Üst Küme Olup Olmadığını Kontrol Etme

Elimizdeki kümenin başka bir kümenin üst kümesi olup olmadığını kontrol etmek için **issuperset()** fonksiyonunu kullanabiliriz.

```python
kume1 = {"A","B"} 
kume2 = {"A","B","C","D"}

print(kume2.issuperset(kume1)) # True
```