BAB 18: Dictionary

Di akhir bab sebelumnya, kita menyinggung keterbatasan list, tuple, dan set: ketiganya mengharuskan kita mengakses data lewat posisi numerik atau mengiterasi seluruh isinya. Kalau kamu punya data peserta kuis — nama, skor, dan status kelulusan — mengaksesnya lewat peserta[0], peserta[1], peserta[2] memang bisa, tapi tidak memberi petunjuk apa-apa tentang isi data tersebut. Siapa yang ingat bahwa index 1 adalah skor dan index 2 adalah status?

Dictionary menyelesaikan masalah ini. Alih-alih posisi numerik, dictionary menggunakan key — label bermakna yang kamu tentukan sendiri — untuk mengakses setiap nilai. peserta["nama"] jauh lebih jelas daripada peserta[0].

Membuat Dictionary

Dictionary dibuat dengan kurung kurawal {}, sama seperti set. Perbedaannya: setiap elemen di dictionary adalah pasangan key-value yang dipisahkan tanda titik dua :.

# kuis.py — data satu peserta kuis
peserta = {
    "nama": "Rina",
    "skor": 85,
    "lulus": True,
}
print(peserta)
print(type(peserta))

{'nama': 'Rina', 'skor': 85, 'lulus': True}
<class 'dict'>

Setiap key harus unik di dalam satu dictionary — mirip set yang tidak mengizinkan duplikat. Tapi berbeda dari set, dictionary mempertahankan urutan penyisipan sejak Python 3.7. Elemen yang dimasukkan pertama akan tetap berada di posisi pertama saat diiterasi.

Dictionary Kosong

Ingat bahwa {} menghasilkan dictionary kosong, bukan set kosong? Sekarang konteks itu masuk akal — karena kurung kurawal memang milik dictionary secara historis.

# kuis.py
kosong = {}
print(type(kosong))
print(len(kosong))

<class 'dict'>
0

Fungsi dict() juga bisa dipakai untuk membuat dictionary, termasuk dari list of tuple yang sudah kita kenal dari BAB 16:

# kuis.py — membuat dictionary dari list of tuple
data = dict([("nama", "Budi"), ("skor", 72), ("lulus", True)])
print(data)

# atau dengan keyword arguments
data2 = dict(nama="Sari", skor=91, lulus=True)
print(data2)

{'nama': 'Budi', 'skor': 72, 'lulus': True}
{'nama': 'Sari', 'skor': 91, 'lulus': True}

Pendekatan dict() dengan keyword arguments terlihat bersih, tapi ada batasan: key harus berupa identifier Python yang valid (tanpa spasi, tidak diawali angka). Untuk key yang lebih fleksibel, gunakan sintaks kurung kurawal.

Mengakses Nilai

Ada dua cara mengakses nilai di dictionary: operator kurung siku [] dan method get().

# kuis.py
peserta = {"nama": "Rina", "skor": 85, "lulus": True}

# akses dengan kurung siku
nama = peserta["nama"]
print(f"Peserta: {nama}")

# akses dengan get()
skor = peserta.get("skor")
print(f"Skor: {skor}")

Peserta: Rina
Skor: 85

Perbedaan krusial muncul ketika key yang dicari tidak ada:

# kuis.py — key tidak ditemukan
peserta = {"nama": "Rina", "skor": 85}

# kurung siku: melempar KeyError
# peserta["lulus"]  # KeyError: 'lulus'

# get(): mengembalikan None (atau nilai default)
status = peserta.get("lulus")
print(f"Status: {status}")

# get() dengan nilai default
status = peserta.get("lulus", "belum ditentukan")
print(f"Status: {status}")

Status: None
Status: belum ditentukan

Mengubah dan Menambah Data

Dictionary bersifat mutable. Mengubah nilai yang sudah ada dan menambah key baru dilakukan dengan sintaks yang sama: penugasan langsung.

# kuis.py — update dan tambah data peserta
peserta = {"nama": "Rina", "skor": 85, "lulus": True}

# ubah nilai yang sudah ada
peserta["skor"] = 90
print(f"Skor diperbarui: {peserta['skor']}")

# tambah key baru
peserta["kelas"] = "XII-IPA"
print(peserta)

Skor diperbarui: 90
{'nama': 'Rina', 'skor': 90, 'lulus': True, 'kelas': 'XII-IPA'}

Tidak perlu method khusus seperti append() pada list — cukup tugaskan nilai ke key baru dan dictionary otomatis berkembang.

Method update()

Untuk menambah atau mengubah beberapa key sekaligus, gunakan update():

# kuis.py — update beberapa key sekaligus
peserta = {"nama": "Rina", "skor": 85}

peserta.update({
    "skor": 90,
    "lulus": True,
    "kelas": "XII-IPA",
})
print(peserta)

{'nama': 'Rina', 'skor': 90, 'lulus': True, 'kelas': 'XII-IPA'}

update() menimpa key yang sudah ada dan menambahkan key yang belum ada — semuanya dalam satu operasi.

Menghapus Data

Beberapa cara menghapus elemen dari dictionary:

# kuis.py — menghapus data peserta
peserta = {
    "nama": "Rina",
    "skor": 90,
    "lulus": True,
    "kelas": "XII-IPA",
}

# pop() — hapus key dan kembalikan nilainya
kelas = peserta.pop("kelas")
print(f"Kelas dihapus: {kelas}")
print(peserta)

# del — hapus key tanpa mengembalikan nilai
del peserta["lulus"]
print(peserta)

# clear() — kosongkan seluruh dictionary
peserta.clear()
print(peserta)

Kelas dihapus: XII-IPA
{'nama': 'Rina', 'skor': 90, 'lulus': True}
{'nama': 'Rina', 'skor': 90}
{}

Sama seperti set.remove(), pop() dan del melempar KeyError jika key tidak ditemukan. Untuk amannya, pop() menerima argumen kedua sebagai nilai default:

# kuis.py — pop() aman dengan default
peserta = {"nama": "Rina", "skor": 90}
kelas = peserta.pop("kelas", "tidak ada")
print(f"Kelas: {kelas}")

Kelas: tidak ada

Iterasi Dictionary

Dictionary punya tiga view object yang masing-masing memberi perspektif berbeda terhadap data: keys(), values(), dan items().

Iterasi Key

Loop for pada dictionary secara default mengiterasi key:

# kuis.py — iterasi key
peserta = {"nama": "Rina", "skor": 85, "lulus": True}

for key in peserta:
    print(f"{key}: {peserta[key]}")

nama: Rina
skor: 85
lulus: True

Method keys() menghasilkan hal yang sama secara eksplisit, tapi loop langsung seperti di atas sudah cukup idiomatis.

Iterasi Value

Jika hanya butuh nilai tanpa key:

# kuis.py — iterasi values
peserta = {"nama": "Rina", "skor": 85, "lulus": True}

for value in peserta.values():
    print(value)

Rina
85
True

Iterasi Key dan Value Bersamaan

items() mengembalikan pasangan tuple (key, value) di setiap iterasi — dan ini bisa langsung di-unpack berkat teknik tuple unpacking dari BAB 16:

# kuis.py — iterasi key-value dengan unpacking
peserta = {"nama": "Rina", "skor": 85, "lulus": True}

for key, value in peserta.items():
    print(f"{key:>8}: {value}")

    nama: Rina
    skor: 85
   lulus: True

Format {key:>8} memastikan label rata kanan dengan lebar 8 karakter — trik f-string kecil yang membuat output tabular lebih rapi.

Cek Keanggotaan Key

Operator in yang sudah kita pakai di list, tuple, dan set juga bekerja di dictionary — tapi yang dicek adalah key, bukan value:

# kuis.py — cek apakah key ada
peserta = {"nama": "Rina", "skor": 85, "lulus": True}

print("nama" in peserta)
print("kelas" in peserta)
print("Rina" in peserta)  # "Rina" adalah value, bukan key

True
False
False

Perhatikan baris terakhir: "Rina" memang ada di dictionary, tapi sebagai value, bukan key. Operator in hanya memeriksa key.

Nested Dictionary

Data di dunia nyata jarang sesederhana satu level key-value. Dictionary bisa menyimpan dictionary lain sebagai value — menciptakan struktur bertingkat.

# kuis.py — data lengkap kuis dengan nested dictionary
hasil_kuis = {
    "Rina": {
        "skor": [85, 90, 78],
        "rata_rata": 84.3,
        "lulus": True,
    },
    "Budi": {
        "skor": [76, 68, 82],
        "rata_rata": 75.3,
        "lulus": True,
    },
    "Dimas": {
        "skor": [68, 72, 65],
        "rata_rata": 68.3,
        "lulus": False,
    },
}

Ingat nested tuple di BAB 16 yang menyimpan data serupa? Bandingkan akses datanya:

# kuis.py — akses nested dictionary vs nested tuple
# dengan tuple: peserta[0][1] — apa itu index 1? skor? nama?
# dengan dictionary:
print(f"Rata-rata Rina: {hasil_kuis['Rina']['rata_rata']}")
print(f"Skor ketiga Budi: {hasil_kuis['Budi']['skor'][2]}")

Rata-rata Rina: 84.3
Skor ketiga Budi: 82

hasil_kuis['Rina']['rata_rata'] langsung memberi tahu apa yang diakses tanpa perlu mengingat urutan index. Ini adalah keunggulan utama dictionary dibanding tuple dan list untuk data terstruktur.

Iterasi Nested Dictionary

Gabungkan loop for dengan items() untuk mengiterasi seluruh data:

# kuis.py — cetak rekap seluruh peserta
BATAS_LULUS = 70  # konstanta dari BAB 7

for nama, data in hasil_kuis.items():
    status = "lulus" if data["lulus"] else "tidak lulus"
    print(f"{nama}: rata-rata {data['rata_rata']:.1f} ({status})")

Rina: rata-rata 84.3 (lulus)
Budi: rata-rata 75.3 (lulus)
Dimas: rata-rata 68.3 (tidak lulus)

Dictionary Comprehension

Sama seperti list comprehension (BAB 15) dan set comprehension (BAB 17), dictionary juga punya bentuk comprehension sendiri. Sintaksnya menggunakan kurung kurawal dengan pasangan key: value:

# kuis.py — buat dictionary dari dua list terpisah
nama_peserta = ["Rina", "Budi", "Sari", "Dimas"]
skor_peserta = [85, 72, 91, 68]

rekap = {nama: skor for nama, skor in zip(nama_peserta, skor_peserta)}
print(rekap)

{'Rina': 85, 'Budi': 72, 'Sari': 91, 'Dimas': 68}

Fungsi zip() menggabungkan dua list menjadi pasangan-pasangan tuple — ("Rina", 85), ("Budi", 72), dan seterusnya — yang kemudian di-unpack menjadi nama dan skor di comprehension.

Dictionary comprehension juga mendukung filter:

# kuis.py — hanya peserta yang lulus
BATAS_LULUS = 70

peserta_lulus = {
    nama: skor
    for nama, skor in zip(nama_peserta, skor_peserta)
    if skor >= BATAS_LULUS
}
print(peserta_lulus)

{'Rina': 85, 'Budi': 72, 'Sari': 91}

Menggabungkan Dictionary

Dua dictionary bisa digabung menggunakan operator | (sejak Python 3.9) atau method update():

# kuis.py — gabungkan data dari dua sumber
sesi_pagi = {"Rina": 85, "Budi": 72}
sesi_siang = {"Sari": 91, "Dimas": 68}

# operator | (Python 3.9+)
semua = sesi_pagi | sesi_siang
print(semua)

# jika ada key yang sama, dictionary di kanan menang
sesi_koreksi = {"Budi": 78}
terbaru = semua | sesi_koreksi
print(terbaru)

{'Rina': 85, 'Budi': 72, 'Sari': 91, 'Dimas': 68}
{'Rina': 85, 'Budi': 78, 'Sari': 91, 'Dimas': 68}

Operator | untuk dictionary berbeda dari | untuk set: pada set ia menggabungkan elemen unik, pada dictionary ia menggabungkan key-value pair dengan key di sisi kanan sebagai pemenang jika ada konflik.

Method-Method Penting

Ringkasan method dictionary yang paling sering digunakan:

Latihan

Tiga tantangan yang menggabungkan dictionary dengan konsep dari bab-bab sebelumnya:

1. Buat dictionary mapel_skor yang menyimpan 5 mata pelajaran sebagai key dan skor (integer) sebagai value. Gunakan loop for dengan items() untuk mencetak setiap mata pelajaran dan skornya. Kemudian, gunakan dictionary comprehension untuk membuat dictionary baru yang hanya berisi mata pelajaran dengan skor di atas 75.

2. Kamu punya data kuis dalam bentuk list of tuple: hasil = [("Rina", 85), ("Budi", 72), ("Sari", 91), ("Dimas", 68)]. Konversi data ini menjadi dictionary menggunakan dict(). Lalu tambahkan key "Lina" dengan skor 88, hapus "Dimas" menggunakan pop(), dan cetak dictionary hasilnya. Terakhir, gunakan values() dan fungsi sum() untuk menghitung rata-rata skor semua peserta yang tersisa.

3. Buat nested dictionary kelas yang berisi 3 peserta, masing-masing memiliki key "skor" (list berisi 3 nilai) dan "mapel" (set berisi mata pelajaran yang diikuti). Iterasi dictionary untuk mencetak nama, rata-rata skor, dan jumlah mata pelajaran setiap peserta. Kemudian, gunakan operasi set dari BAB 17 untuk menemukan mata pelajaran yang diikuti oleh semua peserta (intersection dari semua set "mapel").

Dictionary melengkapi empat tipe data kolektif bawaan Python — list, tuple, set, dan dictionary — masing-masing dengan kekuatan dan kegunaan yang berbeda. Dengan keempat tipe ini, kamu sudah bisa memodelkan hampir semua struktur data yang dibutuhkan program sehari-hari. Tapi ada satu tipe data yang sudah kita gunakan sejak BAB 4 tanpa pernah benar-benar mendalaminya: string. Kita sudah mencetak string, menyimpannya di variabel, bahkan menjadikannya key di dictionary — tapi bagaimana cara memotong, menggabungkan, mencari, atau mengubah isi string? Ternyata string punya kemampuan yang jauh lebih kaya daripada sekadar menyimpan teks.

Referensi

1. 1Python Docs — Mapping Types: dict
2. 2Python Tutorial — Dictionaries
3. 3Real Python — Dictionaries in Python