Mengenal Set dan Operasi Set di Python

# Membuat set menggunakan kurung kurawal
buah = {"apel", "jeruk", "mangga", "apel"}  # Perhatikan "apel" dimasukkan dua kali

# Membuat set dari list
angka = set([1, 2, 3, 2, 1])

# Membuat set kosong
# Perhatikan: {} akan membuat dictionary kosong, bukan set kosong
kosong = set()  

print("Set buah:", buah)
print("Set angka:", angka)
print("Set kosong:", kosong)
print("Tipe data kosong:", type(kosong))

Set buah: {'mangga', 'apel', 'jeruk'}
Set angka: {1, 2, 3}
Set kosong: set()
Tipe data kosong: <class 'set'>

# Set tidak berurutan
set_saya = {"python", "java", "javascript", "c++"}
print(set_saya)  # Urutan elemen bisa berbeda setiap kali dijalankan

# Mencoba mengakses elemen dengan indeks (akan error)
try:
    print(set_saya[0])
except TypeError as e:
    print("Error:", e)

{'python', 'java', 'javascript', 'c++'}
Error: 'set' object is not subscriptable

# Menghilangkan duplikat dari list
angka_duplikat = [1, 2, 3, 2, 1, 4, 5, 4, 3]
angka_unik = set(angka_duplikat)
print("List awal:", angka_duplikat)
print("Setelah dikonversi ke set:", angka_unik)

# Menghitung jumlah nilai unik
print("Jumlah nilai unik:", len(angka_unik))

# Konversi kembali ke list jika diperlukan
list_unik = list(angka_unik)
print("Kembali ke list:", list_unik)

List awal: [1, 2, 3, 2, 1, 4, 5, 4, 3]
Setelah dikonversi ke set: {1, 2, 3, 4, 5}
Jumlah nilai unik: 5
Kembali ke list: [1, 2, 3, 4, 5]

# Elemen valid untuk set
valid_set = {1, "hello", (1, 2, 3)}
print("Set dengan elemen valid:", valid_set)

# Mencoba memasukkan elemen mutable (akan error)
try:
    invalid_set = {1, [2, 3, 4], "hello"}
except TypeError as e:
    print("Error:", e)

try:
    invalid_set2 = {1, {"a": 1, "b": 2}, "hello"}
except TypeError as e:
    print("Error:", e)

Set dengan elemen valid: {1, 'hello', (1, 2, 3)}
Error: unhashable type: 'list'
Error: unhashable type: 'dict'

# Membuat set awal
buah = {"apel", "jeruk", "mangga"}
print("Set awal:", buah)

# Menambah satu elemen dengan add()
buah.add("pisang")
print("Setelah add():", buah)

# Menambah multiple elemen dengan update()
buah.update(["anggur", "kiwi", "semangka"])
print("Setelah update():", buah)

# update() juga bisa menerima tuple, set, atau dictionary
buah.update(("melon", "pepaya"))
print("Setelah update() dengan tuple:", buah)

# Menambah elemen yang sudah ada (tidak ada efek)
buah.add("apel")
print("Setelah add() elemen yang sudah ada:", buah)

Set awal: {'mangga', 'apel', 'jeruk'}
Setelah add(): {'mangga', 'apel', 'jeruk', 'pisang'}
Setelah update(): {'kiwi', 'mangga', 'jeruk', 'pisang', 'anggur', 'apel', 'semangka'}
Setelah update() dengan tuple: {'kiwi', 'mangga', 'pepaya', 'jeruk', 'pisang', 'melon', 'anggur', 'apel', 'semangka'}
Setelah add() elemen yang sudah ada: {'kiwi', 'mangga', 'pepaya', 'jeruk', 'pisang', 'melon', 'anggur', 'apel', 'semangka'}

buah = {"apel", "jeruk", "mangga", "pisang", "anggur"}
print("Set awal:", buah)

# Menghapus elemen dengan remove() - error jika elemen tidak ada
buah.remove("jeruk")
print("Setelah remove():", buah)

try:
    buah.remove("durian")  # Akan error karena "durian" tidak ada dalam set
except KeyError as e:
    print("Error remove():", e)

# Menghapus elemen dengan discard() - tidak error jika elemen tidak ada
buah.discard("mangga")
print("Setelah discard():", buah)
buah.discard("durian")  # Tidak ada error meskipun "durian" tidak ada
print("Setelah discard() elemen yang tidak ada:", buah)

# Menghapus dan mengembalikan elemen acak dengan pop()
elemen = buah.pop()
print("Elemen yang di-pop:", elemen)
print("Set setelah pop():", buah)

# Menghapus semua elemen dengan clear()
buah.clear()
print("Set setelah clear():", buah)

Set awal: {'jeruk', 'anggur', 'mangga', 'apel', 'pisang'}
Setelah remove(): {'anggur', 'mangga', 'apel', 'pisang'}
Error remove(): 'durian'
Setelah discard(): {'anggur', 'apel', 'pisang'}
Setelah discard() elemen yang tidak ada: {'anggur', 'apel', 'pisang'}
Elemen yang di-pop: anggur
Set setelah pop(): {'apel', 'pisang'}
Set setelah clear(): set()

bahasa = {"Python", "Java", "JavaScript", "C++", "Ruby"}

print("Daftar bahasa pemrograman:")
for bahasa_item in bahasa:
    print("-", bahasa_item)

# Menggunakan list comprehension dengan set
print("\nDaftar bahasa dalam huruf besar:")
bahasa_upper = {lang.upper() for lang in bahasa}
print(bahasa_upper)

# Filter bahasa yang namanya lebih dari 4 karakter
print("\nBahasa dengan nama lebih dari 4 karakter:")
bahasa_panjang = {lang for lang in bahasa if len(lang) > 4}
print(bahasa_panjang)

Daftar bahasa pemrograman:
- Python
- Java
- JavaScript
- C++
- Ruby

Daftar bahasa dalam huruf besar:
{'RUBY', 'PYTHON', 'JAVASCRIPT', 'JAVA', 'C++'}

Bahasa dengan nama lebih dari 4 karakter:
{'Python', 'JavaScript', 'Ruby'}

A = {1, 2, 3, 4, 5}
B = {4, 5, 6, 7, 8}

print("Set A:", A)
print("Set B:", B)

Set A: {1, 2, 3, 4, 5}
Set B: {4, 5, 6, 7, 8}

A = {1, 2, 3, 4, 5}
B = {4, 5, 6, 7, 8}

# Cara 1: Menggunakan operator |
union1 = A | B
print("A | B:", union1)

# Cara 2: Menggunakan method union()
union2 = A.union(B)
print("A.union(B):", union2)

# Union lebih dari dua set
C = {7, 8, 9, 10}
union3 = A | B | C
print("A | B | C:", union3)

union4 = A.union(B, C)
print("A.union(B, C):", union4)

A | B: {1, 2, 3, 4, 5, 6, 7, 8}
A.union(B): {1, 2, 3, 4, 5, 6, 7, 8}
A | B | C: {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
A.union(B, C): {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}

A = {1, 2, 3, 4, 5}
B = {4, 5, 6, 7, 8}

# Cara 1: Menggunakan operator &
intersection1 = A & B
print("A & B:", intersection1)

# Cara 2: Menggunakan method intersection()
intersection2 = A.intersection(B)
print("A.intersection(B):", intersection2)

# Intersection lebih dari dua set
C = {5, 6, 7, 9}
intersection3 = A & B & C
print("A & B & C:", intersection3)  # Hanya 5 yang ada di ketiga set

intersection4 = A.intersection(B, C)
print("A.intersection(B, C):", intersection4)

A & B: {4, 5}
A.intersection(B): {4, 5}
A & B & C: {5}
A.intersection(B, C): {5}

A = {1, 2, 3, 4, 5}
B = {4, 5, 6, 7, 8}

# Cara 1: Menggunakan operator -
difference1 = A - B
print("A - B:", difference1)  # Elemen yang ada di A tapi tidak di B

difference2 = B - A
print("B - A:", difference2)  # Elemen yang ada di B tapi tidak di A

# Cara 2: Menggunakan method difference()
difference3 = A.difference(B)
print("A.difference(B):", difference3)

difference4 = B.difference(A)
print("B.difference(A):", difference4)

# Difference dari lebih dari dua set
C = {3, 5, 7, 9}
difference5 = A.difference(B, C)
print("A.difference(B, C):", difference5)  # Elemen di A tapi tidak di B dan tidak di C

A - B: {1, 2, 3}
B - A: {8, 6, 7}
A.difference(B): {1, 2, 3}
B.difference(A): {8, 6, 7}
A.difference(B, C): {1, 2}

A = {1, 2, 3, 4, 5}
B = {4, 5, 6, 7, 8}

# Cara 1: Menggunakan operator ^
sym_diff1 = A ^ B
print("A ^ B:", sym_diff1)

# Cara 2: Menggunakan method symmetric_difference()
sym_diff2 = A.symmetric_difference(B)
print("A.symmetric_difference(B):", sym_diff2)

# Ekuivalen dengan (A - B) | (B - A)
sym_diff3 = (A - B) | (B - A)
print("(A - B) | (B - A):", sym_diff3)

A ^ B: {1, 2, 3, 6, 7, 8}
A.symmetric_difference(B): {1, 2, 3, 6, 7, 8}
(A - B) | (B - A): {1, 2, 3, 6, 7, 8}

A = {1, 2, 3, 4, 5}
B = {1, 2, 3}
C = {1, 2, 3, 4, 5, 6}

# Memeriksa apakah B adalah subset dari A
is_subset1 = B.issubset(A)
is_subset2 = B <= A
print("B.issubset(A):", is_subset1)
print("B <= A:", is_subset2)

# Memeriksa apakah B adalah proper subset dari A (subset tapi tidak sama)
is_proper_subset = B < A
print("B < A:", is_proper_subset)

# Memeriksa apakah A adalah superset dari B
is_superset1 = A.issuperset(B)
is_superset2 = A >= B
print("A.issuperset(B):", is_superset1)
print("A >= B:", is_superset2)

# Memeriksa apakah A adalah proper superset dari B (superset tapi tidak sama)
is_proper_superset = A > B
print("A > B:", is_proper_superset)

# Contoh dengan set yang sama
D = {1, 2, 3}
E = {1, 2, 3}
print("D <= E:", D <= E)  # True (subset)
print("D < E:", D < E)    # False (bukan proper subset karena sama)
print("D >= E:", D >= E)  # True (superset)
print("D > E:", D > E)    # False (bukan proper superset karena sama)

B.issubset(A): True
B <= A: True
B < A: True
A.issuperset(B): True
A >= B: True
A > B: True
D <= E: True
D < E: False
D >= E: True
D > E: False

A = {1, 2, 3, 4}
B = {5, 6, 7, 8}
C = {4, 5, 6}

# Memeriksa apakah dua set disjoint
is_disjoint1 = A.isdisjoint(B)
print("A.isdisjoint(B):", is_disjoint1)

is_disjoint2 = A.isdisjoint(C)
print("A.isdisjoint(C):", is_disjoint2)

# Alternatif: memeriksa apakah irisan kosong
print("A & B == set():", A & B == set())
print("A & C == set():", A & C == set())

A.isdisjoint(B): True
A.isdisjoint(C): False
A & B == set(): True
A & C == set(): False

# Membuat frozenset
normal_set = {1, 2, 3, 4}
frozen = frozenset([1, 2, 3, 4])

print("Normal set:", normal_set)
print("Frozenset:", frozen)
print("Tipe:", type(frozen))

# Operasi yang diperbolehkan
print("Operasi yang diperbolehkan:")
print("Union:", frozen | {5, 6})  # Menghasilkan frozenset baru
print("Intersection:", frozen & {3, 4, 5})
print("Difference:", frozen - {3, 4})
print("Symmetric difference:", frozen ^ {3, 4, 5, 6})

# Operasi yang tidak diperbolehkan
try:
    frozen.add(5)
except AttributeError as e:
    print("\nOperasi yang tidak diperbolehkan:")
    print("frozen.add(5) error:", e)

try:
    frozen.remove(1)
except AttributeError as e:
    print("frozen.remove(1) error:", e)

# Frozenset bisa menjadi elemen set
set_of_sets = {frozenset({1, 2}), frozenset({3, 4})}
print("\nSet of frozensets:", set_of_sets)

# Set biasa tidak bisa menjadi elemen set
try:
    invalid_set = {{1, 2}, {3, 4}}
except TypeError as e:
    print("Set of normal sets error:", e)

Normal set: {1, 2, 3, 4}
Frozenset: frozenset({1, 2, 3, 4})
Tipe: <class 'frozenset'>
Operasi yang diperbolehkan:
Union: frozenset({1, 2, 3, 4, 5, 6})
Intersection: frozenset({3, 4})
Difference: frozenset({1, 2})
Symmetric difference: frozenset({1, 2, 5, 6})

Operasi yang tidak diperbolehkan:
frozen.add(5) error: 'frozenset' object has no attribute 'add'
frozen.remove(1) error: 'frozenset' object has no attribute 'remove'

Set of frozensets: {frozenset({1, 2}), frozenset({3, 4})}
Set of normal sets error: unhashable type: 'set'

# Daftar siswa dalam beberapa kelas
kelas_matematika = ["Andi", "Budi", "Cici", "Dodi", "Edi"]
kelas_fisika = ["Budi", "Cici", "Fifi", "Gigi", "Hani"]
kelas_kimia = ["Andi", "Cici", "Edi", "Gigi", "Intan"]

# Menggabungkan semua siswa (dengan duplikat)
semua_siswa_dengan_duplikat = kelas_matematika + kelas_fisika + kelas_kimia
print("Total siswa dengan duplikat:", len(semua_siswa_dengan_duplikat))
print(semua_siswa_dengan_duplikat)

# Menggunakan set untuk mendapatkan daftar unik
semua_siswa_unik = set(semua_siswa_dengan_duplikat)
print("\nTotal siswa unik:", len(semua_siswa_unik))
print(semua_siswa_unik)

# Kembali ke list jika diperlukan
daftar_siswa_unik = list(semua_siswa_unik)
print("\nDaftar siswa unik (sorted):", sorted(daftar_siswa_unik))

Total siswa dengan duplikat: 15
['Andi', 'Budi', 'Cici', 'Dodi', 'Edi', 'Budi', 'Cici', 'Fifi', 'Gigi', 'Hani', 'Andi', 'Cici', 'Edi', 'Gigi', 'Intan']

Total siswa unik: 9
{'Andi', 'Cici', 'Hani', 'Budi', 'Intan', 'Dodi', 'Edi', 'Fifi', 'Gigi'}

Daftar siswa unik (sorted): ['Andi', 'Budi', 'Cici', 'Dodi', 'Edi', 'Fifi', 'Gigi', 'Hani', 'Intan']

kelas_matematika = {"Andi", "Budi", "Cici", "Dodi", "Edi"}
kelas_fisika = {"Budi", "Cici", "Fifi", "Gigi", "Hani"}
kelas_kimia = {"Andi", "Cici", "Edi", "Gigi", "Intan"}

# Siswa yang mengambil semua mata pelajaran
siswa_all_subjects = kelas_matematika & kelas_fisika & kelas_kimia
print("Siswa yang mengambil semua mata pelajaran:", siswa_all_subjects)

# Siswa yang mengambil matematika dan fisika
siswa_math_and_physics = kelas_matematika & kelas_fisika
print("Siswa yang mengambil matematika dan fisika:", siswa_math_and_physics)

# Siswa yang mengambil matematika atau kimia (atau keduanya)
siswa_math_or_chemistry = kelas_matematika | kelas_kimia
print("Siswa yang mengambil matematika atau kimia:", siswa_math_or_chemistry)

# Siswa yang hanya mengambil matematika (tidak mengambil fisika dan kimia)
siswa_math_only = kelas_matematika - (kelas_fisika | kelas_kimia)
print("Siswa yang hanya mengambil matematika:", siswa_math_only)

# Siswa yang mengambil tepat dua mata pelajaran
siswa_math_physics = (kelas_matematika & kelas_fisika) - kelas_kimia
siswa_math_chemistry = (kelas_matematika & kelas_kimia) - kelas_fisika
siswa_physics_chemistry = (kelas_fisika & kelas_kimia) - kelas_matematika
siswa_exactly_two = siswa_math_physics | siswa_math_chemistry | siswa_physics_chemistry

print("Siswa yang mengambil tepat dua mata pelajaran:", siswa_exactly_two)

Siswa yang mengambil semua mata pelajaran: {'Cici'}
Siswa yang mengambil matematika dan fisika: {'Budi', 'Cici'}
Siswa yang mengambil matematika atau kimia: {'Andi', 'Cici', 'Budi', 'Intan', 'Dodi', 'Edi', 'Gigi'}
Siswa yang hanya mengambil matematika: {'Dodi'}
Siswa yang mengambil tepat dua mata pelajaran: {'Andi', 'Budi', 'Gigi', 'Edi'}

def is_anagram(str1, str2):
    """Memeriksa apakah dua string adalah anagram (menggunakan set)."""
    # Hilangkan spasi dan ubah ke lowercase
    str1 = str1.replace(" ", "").lower()
    str2 = str2.replace(" ", "").lower()
    
    # Cek apakah keduanya memiliki karakter yang sama
    # Perhatikan: ini hanya memeriksa KARAKTER yang ada, bukan jumlahnya
    return set(str1) == set(str2)

def is_anagram_strict(str1, str2):
    """Memeriksa apakah dua string adalah anagram (dengan jumlah karakter yang sama)."""
    # Hilangkan spasi dan ubah ke lowercase
    str1 = str1.replace(" ", "").lower()
    str2 = str2.replace(" ", "").lower()
    
    # Cek apakah panjangnya sama
    if len(str1) != len(str2):
        return False
    
    # Hitung frekuensi karakter dengan dictionary
    char_count1 = {}
    for char in str1:
        char_count1[char] = char_count1.get(char, 0) + 1
    
    char_count2 = {}
    for char in str2:
        char_count2[char] = char_count2.get(char, 0) + 1
    
    # Bandingkan dictionary
    return char_count1 == char_count2

# Tes fungsi
print("'listen' dan 'silent':", is_anagram("listen", "silent"))
print("'triangle' dan 'integral':", is_anagram("triangle", "integral"))
print("'hello' dan 'world':", is_anagram("hello", "world"))

print("\nDengan metode strict:")
print("'listen' dan 'silent':", is_anagram_strict("listen", "silent"))
print("'aab' dan 'abb':", is_anagram_strict("aab", "abb"))  # Tidak anagram dalam definisi strict
print("'aab' dan 'abb' (non-strict):", is_anagram("aab", "abb"))  # Anagram dalam definisi non-strict

'listen' dan 'silent': True
'triangle' dan 'integral': True
'hello' dan 'world': False

Dengan metode strict:
'listen' dan 'silent': True
'aab' dan 'abb': False
'aab' dan 'abb' (non-strict): True

def calculator_set():
    print("===== Kalkulator Set =====")
    print("Masukkan elemen set dipisahkan dengan koma (,)")
    
    input_a = input("Set A: ")
    input_b = input("Set B: ")
    
    # Konversi input string ke set
    try:
        # Pisahkan dengan koma, hapus spasi, konversi ke integer jika angka
        elements_a = input_a.split(",")
        elements_b = input_b.split(",")
        
        set_a = set()
        set_b = set()
        
        for elem in elements_a:
            elem = elem.strip()
            try:
                # Coba konversi ke integer jika mungkin
                set_a.add(int(elem))
            except ValueError:
                # Jika bukan integer, simpan sebagai string
                if elem:  # Abaikan string kosong
                    set_a.add(elem)
        
        for elem in elements_b:
            elem = elem.strip()
            try:
                set_b.add(int(elem))
            except ValueError:
                if elem:
                    set_b.add(elem)
        
        print("\nSet A:", set_a)
        print("Set B:", set_b)
        
        print("\nHasil operasi:")
        print("A ∪ B (union):", set_a | set_b)
        print("A ∩ B (intersection):", set_a & set_b)
        print("A - B (difference):", set_a - set_b)
        print("B - A (difference):", set_b - set_a)
        print("A △ B (symmetric difference):", set_a ^ set_b)
        
        print("\nRelasi set:")
        print("A ⊆ B (A subset dari B):", set_a.issubset(set_b))
        print("B ⊆ A (B subset dari A):", set_b.issubset(set_a))
        print("A ∩ B = ∅ (A dan B disjoint):", set_a.isdisjoint(set_b))
        
    except Exception as e:
        print("Error:", e)

# Contoh penggunaan
# Set A: 1, 2, 3, 4
# Set B: 3, 4, 5, 6
calculator_set()

===== Kalkulator Set =====
Masukkan elemen set dipisahkan dengan koma (,)
Set A: 1, 2, 3, 4
Set B: 3, 4, 5, 6

Set A: {1, 2, 3, 4}
Set B: {3, 4, 5, 6}

Hasil operasi:
A ∪ B (union): {1, 2, 3, 4, 5, 6}
A ∩ B (intersection): {3, 4}
A - B (difference): {1, 2}
B - A (difference): {5, 6}
A △ B (symmetric difference): {1, 2, 5, 6}

Relasi set:
A ⊆ B (A subset dari B): False
B ⊆ A (B subset dari A): False
A ∩ B = ∅ (A dan B disjoint): False

import time

# Buat list dan set dengan elemen yang sama
my_list = list(range(10000))
my_set = set(range(10000))

# Mencari elemen yang ada (ada di akhir list)
start_time = time.time()
9999 in my_list
end_time = time.time()
print(f"Waktu pencarian dalam list: {(end_time - start_time) * 1000:.6f} ms")

start_time = time.time()
9999 in my_set
end_time = time.time()
print(f"Waktu pencarian dalam set: {(end_time - start_time) * 1000:.6f} ms")

# Mencari elemen yang tidak ada
start_time = time.time()
20000 in my_list
end_time = time.time()
print(f"Waktu pencarian (tidak ada) dalam list: {(end_time - start_time) * 1000:.6f} ms")

start_time = time.time()
20000 in my_set
end_time = time.time()
print(f"Waktu pencarian (tidak ada) dalam set: {(end_time - start_time) * 1000:.6f} ms")

Waktu pencarian dalam list: 0.128031 ms
Waktu pencarian dalam set: 0.010967 ms
Waktu pencarian (tidak ada) dalam list: 0.159979 ms
Waktu pencarian (tidak ada) dalam set: 0.009060 ms

data = [1, 2, 2, 3, 3, 3, 4, 5, 5]
unique_data = list(set(data))

allowed_users = {"admin", "manager", "moderator"}
if user_role in allowed_users:  # Lebih cepat daripada list
    # Berikan akses

user_permissions = {
    frozenset({"read", "write"}): ["file1.txt", "file2.txt"],
    frozenset({"read"}): ["file3.txt", "file4.txt"]
}

# Menemukan elemen yang sama di beberapa dataset
common_elements = set1 & set2 & set3

# Menemukan elemen unik di dataset pertama
unique_to_first = set1 - (set2 | set3)