Set di Python: item unik, union, intersection, dan difference

Set adalah kantong tak berurutan berisi item unik

Kalau list dan tuple peduli pada urutan, set tidak. Kalau list membiarkan duplikat menumpuk, set diam-diam membuangnya. Set adalah struktur data yang tepat saat kamu punya dua kebutuhan khusus:

1. Kamu ingin item yang unik, titik.
2. Kamu ingin memeriksa keanggotaan dengan cepat.

Tulis set dengan kurung kurawal:

colors = {"red", "green", "blue"}
print(colors)

with_dupes = {"red", "green", "red", "blue", "green"}
print(with_dupes)   # {"red", "green", "blue"}

"red" dan "green" yang dobel di set kedua langsung hilang. Itu bukan error, justru itulah intinya.

Membuat set

Dua cara yang benar-benar akan kamu pakai:

# Literal with curly braces.
primes = {2, 3, 5, 7, 11}

# From any iterable.
letters = set("banana")
print(letters)

numbers = set([1, 2, 2, 3, 3, 3])
print(numbers)

# Empty set - must use set(), not {}
empty = set()
print(empty, type(empty))

Poin terakhir itu pasti pernah menjebak semua orang: {} membuat dictionary kosong, bukan set kosong. Ambiguitas sintaksnya harus jatuh ke salah satu, dan dict yang menang.

Menambah dan menghapus

tags = {"python", "docs"}

tags.add("beginner")
print(tags)

tags.update(["seo", "tutorial", "python"])  # adds multiple, ignores dupes
print(tags)

tags.remove("seo")       # raises KeyError if the item isn't there
tags.discard("missing")  # same as remove, but silent if not present
print(tags)

popped = tags.pop()      # removes and returns an arbitrary item
print("popped:", popped, "remaining:", tags)

remove vs discard adalah perbedaan utamanya: remove mengharuskan item-nya ada; discard tidak peduli. Pilih berdasarkan apakah tidak adanya item itu seharusnya dianggap error.

Keanggotaan yang cepat

Di sinilah set benar-benar menunjukkan nilainya. x in some_set berjalan dalam waktu konstan, sebesar apa pun set-nya. x in some_list harus menelusuri list-nya, yang jadi lambat saat list-nya besar.

# Imagine this list has 1,000,000 items.
known_users = set(range(1_000_000))

# Each check is near-instant.
for user_id in [42, 999_999, 1_000_001]:
    if user_id in known_users:
        print(f"{user_id}: known")
    else:
        print(f"{user_id}: unknown")

Aturan praktis: setiap kali kamu menulis if x in some_list di dalam loop, dan list-nya berisi lebih dari beberapa lusin item, ubah list itu menjadi set lebih dulu.

Matematika set

Di sinilah set jadi benar-benar menyenangkan. Kamu bisa menggabungkannya dengan operator yang mencerminkan operasi himpunan dalam matematika:

frontend = {"html", "css", "javascript", "react"}
backend = {"python", "sql", "javascript", "docker"}

# Union: everything from both.
all_skills = frontend | backend
print(all_skills)

# Intersection: what's in both.
shared = frontend & backend
print(shared)

# Difference: in frontend but not backend.
only_frontend = frontend - backend
print(only_frontend)

# Symmetric difference: in one or the other, but not both.
unique_skills = frontend ^ backend
print(unique_skills)

Setiap operator juga punya bentuk method (.union(), .intersection(), .difference(), .symmetric_difference()). Operatornya lebih ringkas; bentuk method-nya menerima iterable apa pun, bukan hanya set lain.

Menghapus duplikat dari list

Salah satu kegunaan set yang paling umum, bahkan di luar "logika himpunan":

visits = ["alice", "bob", "alice", "carol", "bob", "alice"]
unique_visitors = list(set(visits))
print(unique_visitors)

Satu baris, duplikatnya hilang. Satu hal yang perlu dicatat: urutannya tidak dipertahankan. Kalau kamu butuh keunikan dan urutan asli, pakai dict.fromkeys() sebagai gantinya:

visits = ["alice", "bob", "alice", "carol", "bob", "alice"]
unique_in_order = list(dict.fromkeys(visits))
print(unique_in_order)

Dict mempertahankan urutan penyisipan di Python modern, dan dict.fromkeys membuat dict dengan item-item iterable sebagai key, sehingga hasilnya praktis seperti set yang berurutan.

Subset dan superset

Memeriksa apakah satu set termuat di set lain:

known = {"python", "bash", "sql"}
required = {"python", "bash"}

print(required.issubset(known))     # True - required is inside known
print(known.issuperset(required))   # True
print(required <= known)            # same as issubset, with an operator
print(known >= required)            # same as issuperset

Hal ini muncul di kasus seperti pengecekan izin ("apakah pengguna ini punya semua role yang dibutuhkan?").

Apa saja yang bisa masuk ke set

Hanya item yang hashable. Itu istilah teknis; dalam praktiknya, artinya:

• Hal yang immutable itu hashable: angka, string, tuple berisi item hashable, frozenset.
• Hal yang mutable tidak: list, dict, dan set lain tidak bisa menjadi anggota set.

ok = {1, "hello", (1, 2), 3.14}
print(ok)

# {[1, 2]}  # TypeError - lists aren't hashable

Kalau kamu butuh set berisi set, pakai frozenset, versi set yang immutable.

Iterasi tidak berurutan

Melakukan loop pada set memberimu item tanpa urutan yang dijamin:

for item in {"a", "b", "c", "d"}:
    print(item)

Jalankan beberapa kali dan kamu akan melihat urutannya berubah-ubah. Kalau urutan penting, set bukan struktur yang tepat: urutkan isinya saat kamu membutuhkannya, atau pakai list.

Kapan tidak memakai set

Kalau salah satu hal ini berlaku, list atau dict mungkin lebih cocok:

• Kamu peduli pada urutan.
• Kamu perlu menyimpan duplikat.
• Setiap item punya data terkait (pakai dict dengan item itu sebagai key).

Lanjut

Set menangani keunikan dan keanggotaan. Dictionary, yang dibahas berikutnya, menangani pola yang lebih luas "cari nilai lewat key", yang mungkin merupakan struktur data selain list yang paling berguna di Python.