05-Dictionaries-checkpoint

Python Dictionaries (Kamus)

Pengantar mapping, cara membuat & mengakses nilai, nesting, metode dasar, penjelasan penting, dan cheatsheet praktis.

Daftar Isi

1. Apa itu Mapping?
2. Membuat Dictionary
3. Nesting Dictionary
4. Metode Dasar Dictionary
5. Penjelasan Tambahan
6. Bonus Cheatsheet

Apa itu Mapping?

Mapping adalah kumpulan objek yang disimpan berdasarkan key (kunci), berbeda dengan sequence yang menyimpan objek berdasarkan posisi. Untuk mengambil nilai di mapping, Anda selalu menggunakan key, bukan indeks.

Catatan penting (Python modern): Sejak Python 3.7+, dictionary menjaga urutan penyisipan (insertion order). Namun secara konsep, dictionary tetap diakses via key, bukan indeks.

Sebuah dictionary berisi pasangan key dan value. Nilai (value) dapat berupa hampir semua objek Python.

• Key harus bisa di-hash (immutable): str, int, tuple (isinya immutable).
• Value bisa tipe apapun: angka, string, list, dict, dll.

Membuat Dictionary

Gunakan tanda kurung kurawal {} dan titik dua : untuk memisahkan key dan value.

# Membuat dictionary dan mengakses nilai lewat key
my_dict = {'key1': 'value1', 'key2': 'value2'}

my_dict['key1']
# Output: 'value1'

Dictionary fleksibel terhadap tipe data di dalamnya:

my_dict = {'key1': 123, 'key2': [12, 23, 33], 'key3': ['item0', 'item1', 'item2']}

# Memanggil item dari dictionary
my_dict['key2']
# Output: [12, 23, 33]

# Mengindeks ke value yang berupa list
my_dict['key3'][0]
# Output: 'item0'

# Memanggil method pada value tersebut
my_dict['key3'][0].upper()
# Output: 'ITEM0'

Memodifikasi Nilai

my_dict['key1']       # 123

# Kurangi 123 dari nilai 'key1'
my_dict['key1'] = my_dict['key1'] - 123
my_dict['key1']       # 0

# Operator singkat (in-place)
my_dict['key1'] -= 123
my_dict['key1']       # -123

Menambah Key Baru dengan Assignment

# Memulai dari dictionary kosong
d = {}

d['animal'] = 'Dog'
d['answer'] = 42

d
# Output: {'animal': 'Dog', 'answer': 42}

Nesting Dictionary

Anda bisa menyimpan dictionary di dalam dictionary (bahkan bertingkat):

# Dictionary di dalam dictionary di dalam dictionary
d = {'key1': {'nestkey': {'subnestkey': 'value'}}}

# Mengambil nilai paling dalam
print(d['key1']['nestkey']['subnestkey'])
print(d['key1']['nestkey'])

# Output:
# value
# {'subnestkey': 'value'}

Metode Dasar Dictionary

d = {'key1': 1, 'key2': 2, 'key3': 3}

d.keys()      # dict_keys(['key1','key2','key3'])
d.values()    # dict_values([1, 2, 3])
d.items()     # dict_items([('key1',1), ('key2',2), ('key3',3)])

d.keys()

Kembalikan semua key.

d.values()

Kembalikan semua value.

d.items()

Kembalikan pasangan (key, value) sebagai tuple.

Penjelasan Tambahan (Supaya Makin Paham)

Key harus immutable

valid = {('x', 1): 'ok'}   # tuple immutable -> valid
invalid = {[1,2]: 'no'}    # list mutable -> TypeError

Akses aman dengan .get()

user = {'name': 'Ali'}
user.get('age')        # None jika key tak ada
user.get('age', 0)     # 0 sebagai nilai default

Gabung / Update dictionary

a = {'x': 1}
b = {'y': 2}
a.update(b)            # {'x':1, 'y':2}

# Python 3.9+
c = a | {'z': 3}       # merge menjadi dictionary baru
a |= {'w': 9}          # merge in-place (ubah a)

Hapus elemen

d = {'a': 1, 'b': 2, 'c': 3}
del d['b']                 # hapus key 'b'
val = d.pop('c')           # ambil & hapus 'c' -> val = 3
last = d.popitem()         # hapus pasangan terakhir (insertion-order)
d.clear()                  # kosongkan dictionary

Iterasi

scores = {'Ali': 90, 'Budi': 85}

for k in scores:                # iterasi key
    print(k, scores[k])

for k, v in scores.items():     # iterasi pasangan
    print(k, v)

Dictionary Comprehension

squares = {n: n*n for n in range(5)}
# {0:0, 1:1, 2:4, 3:9, 4:16}

Akses bertingkat (nested) yang aman

d = {'user': {'profile': {'age': 30}}}
age = d.get('user', {}).get('profile', {}).get('age')  # 30 atau None

Bonus Cheatsheet Dictionary 🧠⚡

Membuat

d = {}                                   # kosong
d = dict()                               # kosong
d = {'a': 1, 'b': 2}
d = dict(a=1, b=2)
d = dict([('a', 1), ('b', 2)])           # dari list tuple
d = dict.fromkeys(['x','y'], 0)          # {'x':0, 'y':0}

Akses & Cek Keberadaan

d['a']                   # Value 'a' (KeyError jika tak ada)
d.get('a', 'default')   # Lebih aman dengan nilai default
'a' in d                # True jika key ada

Tambah / Ubah

d['a'] = 10
d.update({'b': 20, 'c': 30})
d |= {'d': 40}          # Python 3.9+ (merge in-place)

Hapus

del d['a']
val = d.pop('b', None)  # default jika 'b' tak ada
k, v = d.popitem()      # hapus pasangan terakhir
d.clear()               # kosongkan

Dapatkan Koleksi

d.keys()       # dict_keys([...])
d.values()     # dict_values([...])
d.items()      # dict_items([...])

Iterasi

for k in d: ...
for v in d.values(): ...
for k, v in d.items(): ...

Comprehension & Nested Access

{k: v for k, v in iterable if condition}
d.get('lvl1', {}).get('lvl2', {}).get('lvl3')

Tips: Gunakan tipe immutable untuk key (str, int, tuple). Hindari KeyError dengan .get() atau cek 'key' in d. Untuk struktur bertingkat yang sering bertambah otomatis, pertimbangkan collections.defaultdict.

© Belajar Python — Dictionaries (Kamus). Dibuat rapi untuk Blogger.