# Python Dersleri #25: Kümelerde Matematiksel İşlemler

Kaynak: https://webodasi.com/python-dersleri-25-kumelerde-matematiksel-islemler/
Yazar: Uzmoon
Yayın: 2026-11-13
Güncelleme: 2026-11-13

> Python kümelerinde kesişim, birleşim, fark, simetrik fark, alt/üst küme ve ayrık küme kontrolü gibi matematiksel işlemlerin operatör ve metotlarla nasıl yapıldığını anlatır.

## Bu Dersin Amacı

 

Bu derste kümeler üzerinde kesişim, birleşim, fark ve simetrik fark gibi matematiksel işlemleri hem operatörler hem de metotlarla nasıl gerçekleştireceğinizi öğreneceksiniz.

 

## Kesişim (Intersection)

 

İki kümenin ortak elemanlarını bulmak için `&` operatörü veya `intersection()` metodu kullanılır. Her iki yöntem de yeni bir küme döndürür; orijinal kümeler değişmez.

 

```
kume_a = {1, 2, 3, 4, 5}
kume_b = {4, 5, 6, 7, 8}

# Operatör ile kesişim
kesisim_op = kume_a & kume_b
print("Operatör:", kesisim_op)  # {4, 5}

# Metot ile kesişim
kesisim_metot = kume_a.intersection(kume_b)
print("Metot:", kesisim_metot)  # {4, 5}

# Orijinal kümeler korunur
print("kume_a:", kume_a)  # {1, 2, 3, 4, 5}
```

 

## Birleşim (Union)

 

İki kümenin tüm elemanlarını (tekrarsız) birleştirmek için `|` operatörü veya `union()` metodu kullanılır.

 

```
kume_a = {1, 2, 3}
kume_b = {3, 4, 5}

# Operatör ile birleşim
birlesim_op = kume_a | kume_b
print("Operatör:", birlesim_op)  # {1, 2, 3, 4, 5}

# Metot ile birleşim
birlesim_metot = kume_a.union(kume_b)
print("Metot:", birlesim_metot)  # {1, 2, 3, 4, 5}

# Birden fazla küme birleştirme
kume_c = {5, 6, 7}
coklu_birlesim = kume_a.union(kume_b, kume_c)
print("Çoklu:", coklu_birlesim)  # {1, 2, 3, 4, 5, 6, 7}
```

 

## Fark (Difference)

 

Bir kümede olup diğerinde olmayan elemanları bulmak için `-` operatörü veya `difference()` metodu kullanılır. Sıra önemlidir: `kume_a - kume_b`, `kume_a`'da olup `kume_b`'de olmayanları verir.

 

```
kume_a = {1, 2, 3, 4, 5}
kume_b = {4, 5, 6, 7}

# kume_a'da olup kume_b'de olmayanlar
fark_ab = kume_a - kume_b
print("A - B:", fark_ab)  # {1, 2, 3}

# kume_b'de olup kume_a'da olmayanlar
fark_ba = kume_b - kume_a
print("B - A:", fark_ba)  # {6, 7}

# Metot kullanımı
fark_metot = kume_a.difference(kume_b)
print("Metot:", fark_metot)  # {1, 2, 3}
```

 

## Simetrik Fark (Symmetric Difference)

 

İki kümenin birleşiminden kesişimi çıkarmak; yani sadece birinde bulunan elemanları almak için `^` operatörü veya `symmetric_difference()` metodu kullanılır.

 

```
kume_a = {1, 2, 3, 4}
kume_b = {3, 4, 5, 6}

# Operatör ile simetrik fark
sym_fark_op = kume_a ^ kume_b
print("Operatör:", sym_fark_op)  # {1, 2, 5, 6}

# Metot ile simetrik fark
sym_fark_metot = kume_a.symmetric_difference(kume_b)
print("Metot:", sym_fark_metot)  # {1, 2, 5, 6}
```

 

## Alt Küme ve Üst Küme Kontrolleri

 

Bir kümenin diğerinin alt kümesi (`<=`, `issubset()`) veya üst kümesi (`>=`, `issuperset()`) olup olmadığını test edebilirsiniz. Eşitsiz operatörler (`<`, `>`) kesin alt/üst küme için kullanılır.

 

```
buyuk = {1, 2, 3, 4, 5}
kucuk = {2, 3}
esit = {1, 2, 3, 4, 5}

# Alt küme kontrolleri
print(kucuk <= buyuk)   # True (alt küme veya eşit)
print(kucuk < buyuk)    # True (kesin alt küme)
print(esit <= buyuk)    # True (eşit)
print(esit < buyuk)     # False (kesin alt küme değil)

# Metotlarla
print(kucuk.issubset(buyuk))  # True

# Üst küme kontrolleri
print(buyuk >= kucuk)   # True
print(buyuk > kucuk)    # True
print(buyuk.issuperset(kucuk))  # True
```

 

## Ayrık Kümeler (Disjoint Sets)

 

İki kümenin ortak elemanı yoksa (kesişimi boşsa) ayrık kümelerdir. `isdisjoint()` metodu bu kontrolü yapar.

 

```
kume_a = {1, 2, 3}
kume_b = {4, 5, 6}
kume_c = {3, 4, 5}

print(kume_a.isdisjoint(kume_b))  # True (ortak eleman yok)
print(kume_a.isdisjoint(kume_c))  # False (3 ortak)
```

 

## Sık Yapılan Hatalar

 

- **Birleşim için + operatörü kullanmak:** Kümelerde `+` operatörü tanımlı değildir, `|` veya `union()` kullanılmalıdır.
- **Fark işleminde sıra karıştırma:** `a - b` ile `b - a` sonuçları farklıdır; hangi kümenin diğerinden çıkarıldığına dikkat edilmelidir.
- **Metotların orijinal kümeyi değiştirdiğini sanmak:** `intersection()`, `union()`, `difference()` gibi metotlar **yeni küme döndürür** ; orijinal kümeyi değiştirmezler. Güncelleme için `intersection_update()` gibi `_update` sonlu metotlar vardır.
- **Operatörleri listelerle kullanmaya çalışmak:** `&`, `|`, `-`, `^` operatörleri sadece küme ile küme arasında çalışır; liste veya tuple ile doğrudan kullanılamaz.
- **Kesin alt küme operatörünü yanlış anlamak:** `a < b` ifadesi "a, b'nin kesin alt kümesidir" demektir; eşit kümeler için `False` döner.

 

## Alıştırma

 

İki küme tanımlayın: `ogrenciler_a = {"Ali", "Ayşe", "Can", "Deniz"}` ve `ogrenciler_b = {"Can", "Deniz", "Emre", "Fatma"}`. Aşağıdaki işlemleri yapıp sonuçları yazdırın:

 

1. Her iki derste de olan öğrenciler (kesişim).
2. En az bir derste olan tüm öğrenciler (birleşim).
3. Sadece A derste olan öğrenciler (fark A - B).
4. Sadece bir derste olan öğrenciler (simetrik fark).
5. `ogrenciler_a` kümesinin `ogrenciler_b` kümesinin alt kümesi olup olmadığı.

 

### Çözüm

 

```
ogrenciler_a = {"Ali", "Ayşe", "Can", "Deniz"}
ogrenciler_b = {"Can", "Deniz", "Emre", "Fatma"}

# 1. Kesişim
ortak = ogrenciler_a & ogrenciler_b
print("Her iki derste de olanlar:", ortak)

# 2. Birleşim
tum = ogrenciler_a | ogrenciler_b
print("Tüm öğrenciler:", tum)

# 3. Fark A - B
sadece_a = ogrenciler_a - ogrenciler_b
print("Sadece A derste olanlar:", sadece_a)

# 4. Simetrik fark
tek_derste = ogrenciler_a ^ ogrenciler_b
print("Sadece bir derste olanlar:", tek_derste)

# 5. Alt küme kontrolu
print("A, B'nin alt kümesi mi?:", ogrenciler_a <= ogrenciler_b)

# Çıktı:
# Her iki derste de olanlar: {'Can', 'Deniz'}
# Tüm öğrenciler: {'Ali', 'Ayşe', 'Can', 'Deniz', 'Emre', 'Fatma'}
# Sadece A derste olanlar: {'Ali', 'Ayşe'}
# Sadece bir derste olanlar: {'Ali', 'Ayşe', 'Emre', 'Fatma'}
# A, B'nin alt kümesi mi?: False
```

 

## Özet

 

- Kümelerde matematiksel işlemler hem operatörler (`&`, `|`, `-`, `^`) hem de metotlarla (`intersection`, `union`, `difference`, `symmetric_difference`) yapılabilir.
- Operatörler sadece küme ile küme arasında çalışır; metotlar herhangi bir yineleyici (liste, tuple vb.) kabul edebilir.
- Bu işlemler yeni küme üretir, orijinal kümeleri değiştirmez.
- Alt/üst küme ve ayrık küme kontrolleri için `<=`, `>=`, `isdisjoint()` kullanılır.