# Bab 1P. Himpunan dengan Python
## 1. Menuliskan Himpunan
Cara pertama untuk mendefinisikan himpunan dalam Python adalah dengan menuliskan elemen-elemen himpunan dalam tanda kurung kurawal dan memisahkan setiap elemen dengan tanda koma. Sebagai contoh, untuk menuliskan himpunan:
$$ A = \{1, 2, 3, 4, 5\} $$
pada kode Python, kita menuliskan:
```python
A = {1, 2, 3, 4, 5}
```
Cara kedua untuk menuliskan himpunan dalam Python adalah dengan menggunakan fungsi `set`. Himpunan $A$ di atas dalam kode Python dapat didefinisikan sebagai berikut:
```python
A = set([1, 2, 3, 4, 5])
```
### 1.1 Keanggotaan Himpunan
Untuk mengetahui keanggotaan suatu himpunan kita dapat membentuk sebuah ekspresi menggunakan operator `in`. Sebagai contoh, misalkan kita ingin mengetahui apakah 8 adalah anggota himpunan $A$, atau $8 \in A$ kita menuliskan:
```
8 in A
```
Ekspresi di atas akan menghasilkan nilai Boolean `False`, karena 8 bukanlah elemen dari himpunan $A$.
:::info
***Contoh 1. Mengetahui Keanggotaan Himpunan Menggunakan Python.***
Kode Python berikut memeriksa apakah 5 dan 0 adalah elemen dari himpunan $A = \{-2, 0, 1, 4\}$.
```python
A = {-2, 0, 1, 4}
print(5 in A)
print(0 in A)
```
Karena $5 \notin A$ dan $0 \in A$, maka kode di atas akan memberikan output:
```
False
True
```
:::
:::info
***Contoh 2. Menampilkan Semua Elemen-elemen dalam Sebuah Himpunan.***
Kode berikut menampilkan semua elemen-elemen dalam himpunan $A = \{-2, 0, 1, 4\}$.
```python
A = {-2, 0, 1, 4}
for x in A:
print(x, "adalah elemen dari himpunan.")
```
Output dari kode di atas:
```
0 adalah elemen dari himpunan.
1 adalah elemen dari himpunan.
4 adalah elemen dari himpunan.
-2 adalah elemen dari himpunan.
```
:::
### 1.2 Menuliskan Himpunan dengan Notasi Pembentuk Himpunan
Python juga mendukung pendefinisian himpunan menggunakan notasi set-builder.
:::info
***Contoh 3. Menuliskan Notasi Set Builder dalam Python.***
Kode berikut mendefinisikan himpunan $B = \{x^2 \ | \ x \in \{1, 2, 3, 4, 5\}\}$ menggunakan set-builder dan menampilkan semua elemen dari himpunan tersebut.
```python
B = {x**2 for x in {1, 2, 3, 4, 5}}
for y in B:
print(y, "adalah elemen dari himpunan.")
```
Output dari kode di atas;
```
1 adalah elemen dari himpunan.
4 adalah elemen dari himpunan.
9 adalah elemen dari himpunan.
16 adalah elemen dari himpunan.
25 adalah elemen dari himpunan.
```
:::
### 1.3 Kardinalitas
Kardinalitas dari sebuah himpunan dapat dicari dengan menggunakan fungsi built-in `len()`. Misalkan, untuk mencari kardinalitas dari himpunan `A`, kita menuliskan `len(A)`.
:::info
***Contoh 4. Kardinalitas dari Himpunan***
Kardinalitas dari himpunan $A = \{1, 2, 3, 4\}$ dan himpunan $B = \{x^2 \ | \ x \in \{1, 2, 3, 4, 5\}\}$ dapat dicari menggunakan kode Python berikut:
```python
A = {1, 2, 3, 4}
B = {x**2 for x in {1, 2, 3, 4, 5}}
# Untuk mencari kardinalitas gunakan fungsi len()
print('|A|=', len(A))
print('|B|=', len(B))
```
Output dari kode di atas;
```
|A|= 4
|B|= 5
```
:::
### 1.4 Subset
Untuk mengetahui apakah suatu himpunan adalah subset dari himpunan lain kita dapat menggunakan method `issubset()`. Misalkan untuk mengetahui apakah himpunan `A` adalah subset dari himpunan `b`, kita menuliskan `A.issubset(B)`. Ekspresi ini akan mengembalikan `true` jika A adalah subset dari B dan mengembalikan `false` jika sebaliknya.
:::info
***Contoh 5. Subset***
Kode berikut memeriksa:
- $A = \{1, 2, 3, 4, 5\}$ dan $B = \{1, 2, 3\}$. Apakah $A \subseteq B$ ? Apakah $B \subseteq C$ ?
- $C = \{a, b, c, d, e, f, g\}$ dan $D = \{a, b, c\}$. Apakah $C \subseteq D$ ? Apakah $D \subseteq C$ ?
```python
A = {1, 2, 3, 4, 5}
B = {1, 2, 3}
C = {'a', 'b', 'c', 'd', 'e'}
D = {'a', 'b', 'c'}
# Apakah A subset B?
print('A subset B:', A.issubset(B))
# Apakah B subset A?
print('B subset A:', B.issubset(A))
# Apakah C subset D?
print('C subset D:', C.issubset(D))
# Apakah D subset C?
print('D subset C:', D.issubset(C))
```
Output dari kode di atas;
```
A subset B: False
B subset A: True
C subset D: False
D subset C: True
```
:::
### 1.5 Operasi Himpunan
#### Gabungan (*Union*)
Kita dapat menuliskan operasi union dalam Python dengan dua cara. Misalkan, operasi $A \cup B$, dapat dituliskan dengan dua cara berikut:
```python
A.union(B)
```
atau
```python
A | B
```
:::info
***Contoh 6. Operasi Union.***
Kode berikut mencontohkan operasi union pada himpunan $A$ dan $B$:
```python
A = {-3, -1, 2, 5}
B = {-1, 0, 2}
print(A.union(B))
print(A | B)
```
Kode di atas akan memberikan output:
```
{0, 2, 5, -3, -1}
{0, 2, 5, -3, -1}
```
:::
#### Irisan (*Intersection*)
Intersection dari himpunan $A$ dan $B$ dinotasikan dengan $A \cap B$ dalam Python dituliskan dengan dua cara:
```python
A.intersection(B)
```
atau
```python
A & B
```
:::info
***Contoh 7. Operasi Irisan.***
Kode berikut mencontohkan operasi irisan pada himpunan $A$ dan $B$:
```python
A = {-3, -1, 2, 5}
B = {-1, 0, 2}
print(A.intersection(B))
print(A & B)
```
Kode di atas akan memberikan output:
```
{2, -1}
{2, -1}
```
:::
#### Selisih
Selisih dari himpunan $A$ dan $B$, dinotasikan dengan $A - B$ dalam Python dituliskan dengan dua cara:
```python
A.difference(B)
```
atau
```python
A - B
```
:::info
***Contoh 8. Operasi Selisih.***
Kode berikut mencontohkan operasi selisih pada himpunan $A$ dan $B$:
```python
A = {-3, -1, 2, 5}
B = {-1, 0, 2}
print(A.difference(B))
print(B - A)
```
Kode di atas akan memberikan output:
```
{-3, 5}
{0}
```
:::
#### Komplemen
Komplemen dari suatu himpunan dalam Python dapat dicari dengan mencari selisih himpunan semesta dengan himpunan tersebut.
:::info
***Contoh 9. Operasi Komplemen.***
Misalkan $S = \{1, 2, 3, 4, 5, 6, 7, 8, 9\}$ dan $A = \{1, 3, 7, 9\}$, kode berikut mencari $A^c$:
```python
S = {1, 2, 3, 4, 5, 6, 7, 8, 9}
A = {1, 3, 7, 9}
print(S - A)
```
Output dari kode di atas:
```
{2, 4, 5, 6, 8}
```
:::
#### Perkalian Kartesian
Tidak ada fungsi built-in dalam Python untuk perkalian kartesian. Untuk mencari perkalian kartesian dari dua himpunan kita dapat menulis fungsi Python berikut:
```python
def kali_kartesian(A, B):
# Inisialisasi himpunan kosong untuk menaruh hasil perkalian kartesian
product = set()
for a in A:
for b in B:
product.add((a, b))
return product
```
Berikut adalah kode yang mencontohkan operasi perkalian kartesian.
:::info
***Contoh 10. Operasi Komplemen.***
Misal $C = \{1, 2, 3\}$ dan $D = \{a, b\}$. Cari $C \times D$, $D \times C$, $C \times C$, dan $D \times D$.
```python
def kali_kartesian(A, B):
# Inisialisasi himpunan kosong untuk menaruh hasil perkalian kartesian
product = set()
for a in A:
for b in B:
product.add((a, b))
return product
def main():
C = {1, 2, 3}
D = {'a', 'b'}
C_x_D = kali_kartesian(C, D)
print('C x D =', C_x_D)
D_x_C = kali_kartesian(D, C)
print('D x C =', D_x_C)
C_x_C = kali_kartesian(C, C)
print('C x C =', C_x_C)
D_x_D = kali_kartesian(D, D)
print('D x D =', D_x_D)
main()
```
Output dari kode di atas:
```shell
C x D = {(2, 'a'), (3, 'a'), (1, 'a'), (2, 'b'), (3, 'b'), (1, 'b')}
D x C = {('a', 1), ('b', 1), ('a', 3), ('b', 3), ('a', 2), ('b', 2)}
C x C = {(1, 2), (2, 1), (3, 1), (1, 1), (2, 3), (3, 3), (2, 2), (3, 2), (1, 3)}
D x D = {('a', 'b'), ('b', 'b'), ('a', 'a'), ('b', 'a')}
```
:::
### 1.6 Diagram Venn
Untuk menggambar diagram Venn dalam Python, kita membutuhkan dua module: `matplotlib` dan `matplotlib-venn`. Module `matplotlib` adalah module untuk menggambar grafik sedangkan module `matplotlib-venn` adalah module untuk menggambar diagram Venn.
Instalasi kedua module dengan menjalankan perintah berikut pada command prompt:
```
pip install matplotlib matplotlib-venn
```
> Catatan.
Jika perintah tersebut gagal dieksekusi, periksa apakah `pip` terinstall di komputer Anda. Jika tidak, lakukan instalasi `pip`.
Pada module `matplotlib` kita membutuhkan fungsi `pyplot` yang digunakan untuk menggambar grafik dan pada module `matplotlib-venn` kita membutuhkan fungsi `venn2` untuk menggambar diagram Venn dari dua himpunan dan fungsi `venn3` untuk menggambar diagram Venn dari tiga himpunan.
Kode berikut mencontohkan menggambar diagram Venn dari dua himpunan.
```python=
from matplotlib import pyplot as plt
from matplotlib_venn import venn2
Basket = {'Andi', 'Eko', 'Anto', 'Zara'}
Voli = {'Julia','Kirana','Deby','Anto'}
plt.figure(1)
venn2([Basket,Voli],set_labels=('Basket','Voli'))
plt.show()
```
Penjelasan kode di atas;
- Baris 1 mengimport fungsi `pyplot` yang berada dalam module `matplotlib` dan menamakan ulang fungsi tersebut sebagai `plt`.
- Baris 2 mengimport fungsi `venn2` dari module `matplotlib_venn`
- Baris 4 dan 5 berisi inisialisasi variabel berupa dua himpunan (tipe struktur data set)
- Baris 7 membuat diagram venn pada window gambar `1`.
- Baris 8 berisi inisialisasi venn diagram dengan memasukkan variabel pada baris 4 dan 5 serta memberikan label pada tiap himpunan
- Baris 9 menampilkan window gambar yang telah berisi diagram Venn.
Kode di atas menghasilkan output sebuah window dengan gambar diagram Venn dari himpunan Basket dan Voli seperti terlihat pada gambar berikut:
Perhatikan angka di dalam lingkaran. Angka tersebut bukanlah anggota dari himpunan dalam wilayah namun banyaknya anggota yang berada dalam wilayah.
:::info
***Contoh 11. Diagram Venn***
Kode berikut:
```pyton
from matplotlib_venn import venn3,venn2
from matplotlib import pyplot as plt
A = {2, 3, 5, 7, 9}
B = {0, 1, 2, 4, 5, 6}
C = {1, 14, 4}
plt.figure(1)
venn3([A,B,C],set_labels=('A','B','C'))
plt.figure(2)
venn2([A,B],set_labels=('A','B'))
plt.figure(3)
venn2([A,C],set_labels=('A','C'))
plt.show()
```
Output kode di atas adalah tiga window yang berisi gambar seperti berikut:
:::
Sign in with Wallet
Connect another wallet