Python Dictionary Comprehension: Hal-Hal Penting yang Perlu Anda Ketahui

Apa itu Python Dictionary?

Dictionary di Python adalah kumpulan item yang diakses dengan key tertentu, bukan dengan indeks. Apa artinya ini?

Bayangkan sebuah kamus di dunia nyata. Saat Anda perlu mencari arti sebuah kata, Anda mencarinya menggunakan kata itu sendiri, bukan indeks kemungkinan dari kata tersebut. Dictionary Python bekerja dengan konsep yang sama: Kata yang artinya Anda cari adalah key, dan arti kata tersebut adalah value. Anda tidak perlu mengetahui indeks kata dalam kamus untuk menemukan artinya.

Inisialisasi dictionary di Python

Anda dapat menginisialisasi dictionary di Python seperti ini:

a = {'apple': 'fruit', 'beetroot': 'vegetable', 'cake': 'dessert'}
a['doughnut'] = 'snack'
print(a['apple'])

fruit

print(a[0])

---------------------------------------------------------------------------

KeyError                                  Traceback (most recent call last)

<ipython-input-9-00d4a978143a> in <module>()
----> 1 print(a[0])


KeyError: 0

Pertama, kita membuat dictionary bernama a yang memiliki tiga pasangan key-value: 'apple': 'fruit', 'beetroot': 'vegetable', dan 'cake': 'dessert'. Key berupa string yang merepresentasikan nama item, dan value berupa string yang merepresentasikan tipe atau kategori item.

Selanjutnya, kita menambahkan pasangan key-value baru ke dictionary a menggunakan sintaks a ['doughnut'] = 'snack'. Ini menambahkan key 'doughnut' ke dictionary dengan value 'snack' yang sesuai.

Baris ketiga kode mencetak value yang terkait dengan key 'apple' dalam dictionary a. Karena 'apple' adalah key dalam dictionary, kode mencetak value 'fruit'.

Baris keempat kode mencoba mencetak value yang terkait dengan key 0 dalam dictionary a, yang bukan key yang valid di dictionary tersebut. Ini menghasilkan KeyError, yang muncul saat mencoba mengakses key yang tidak ada dalam dictionary.

Tipe data pada dictionary Python

Item dalam dictionary dapat memiliki tipe data apa pun. Lihat beberapa contoh dictionary di bawah ini untuk memahaminya:

Buat dictionary a dengan empat pasangan key-value:

a = {'one': 1, 'two': 'to', 'three': 3.0, 'four': [4,4.0]}
print(a)

Perbarui value yang terkait dengan key 'one' dalam dictionary a menjadi 1.0.

# Update a dictionary
a['one'] = 1.0 
print(a)

{'four': [4, 4.0], 'two': 'to', 'three': 3.0, 'one': 1.0}

Hapus pasangan key-value yang terkait dengan key 'one' dari dictionary a.

# Delete a single element
del a['one'] 
print(a)

{'four': [4, 4.0], 'two': 'to', 'three': 3.0}

Hapus semua pasangan key-value dari dictionary a menggunakan metode clear().

# Delete all elements in the dictionary
a.clear()
print(a)

{}

Hapus dictionary a menggunakan keyword del.

# Delete the dictionary
del a 
print(a)

---------------------------------------------------------------------------

NameError                                 Traceback (most recent call last)

<ipython-input-12-701c9d6596da> in <module>()
      1 del a #Deletes the dictionary
----> 2 print(a)


NameError: name 'a' is not defined

Penting untuk diingat bahwa sebuah key harus unik dalam dictionary; duplikasi tidak diizinkan. Namun, jika ada key duplikat, alih-alih menghasilkan error, Python akan menganggap kemunculan key terakhir sebagai yang valid dan mengabaikan pasangan key-value pertama. Buktikan sendiri:

sweet_dict = {'a1': 'cake', 'a2':'cookie', 'a1': 'icecream'}
print(sweet_dict['a1'])

icecream

Python Dictionary Comprehension

Dictionary comprehension adalah metode untuk mentransformasikan satu dictionary menjadi dictionary lain. Selama transformasi ini, item dalam dictionary asli dapat disertakan secara kondisional dalam dictionary baru, dan setiap item dapat diubah sesuai kebutuhan.

List comprehension yang bagus dapat membuat kode Anda lebih ekspresif dan, dengan demikian, lebih mudah dibaca. Kuncinya adalah jangan sampai comprehension menjadi begitu kompleks hingga membuat pusing saat mencoba menebak apa yang sebenarnya dikerjakannya. Tetap pegang prinsip "mudah dibaca".

Cara melakukan dictionary comprehension di Python adalah dengan dapat mengakses objek key dan objek value dari sebuah dictionary.

Bagaimana cara melakukannya?

Python sudah menyiapkannya! Anda cukup menggunakan metode bawaan berikut:

dict1 = {'a': 1, 'b': 2, 'c': 3, 'd': 4}
# Put all keys of `dict1` in a list and returns the list
dict1.keys()

dict_keys(['c', 'd', 'a', 'b'])

# Put all values saved in `dict1` in a list and returns the list
dict1.values()

dict_values([3, 4, 1, 2])

Kode di atas membuat dictionary Python bernama dict1 dengan empat pasangan key-value. Metode keys() dipanggil pada dictionary, yang mengembalikan objek view berisi semua key dalam dictionary.

Metode values() juga dipanggil pada dictionary, yang mengembalikan objek view berisi semua value dalam dictionary.

Kedua objek view berperilaku seperti himpunan dan dapat digunakan untuk melakukan operasi himpunan pada key dan value, masing-masing.

Perhatikan bahwa urutan key dan value dalam objek view tidak dijamin sama dengan urutan saat ditambahkan ke dictionary.

Transformasi value dasar 

Mari mulai dengan dictionary comprehension sederhana:

dict1 = {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5}
# Double each value in the dictionary
double_dict1 = {k:v*2 for (k,v) in dict1.items()}
print(double_dict1)

{'e': 10, 'a': 2, 'c': 6, 'b': 4, 'd': 8}

Pada kode comprehension di atas, kita membuat dictionary baru double_dict1 dari dictionary dict1 dengan menggandakan setiap valuenya.

Anda juga dapat membuat perubahan pada key. Misalnya, mari buat dictionary yang sama seperti di atas namun juga mengubah nama key.

dict1_keys = {k*2:v for (k,v) in dict1.items()}
print(dict1_keys)

{'dd': 4, 'ee': 5, 'aa': 1, 'bb': 2, 'cc': 3}

Menggunakan metode items()

Sekarang setelah Anda tahu cara mengakses semua key dan valuenya dalam dictionary. Anda juga dapat mengakses setiap pasangan key-value dalam dictionary menggunakan metode items():

dict1.items()

dict_items([('c', 3), ('d', 4), ('a', 1), ('b', 2)])

Ini adalah templat umum yang dapat Anda ikuti untuk dictionary comprehension di Python:

dict_variable = {key:value for (key,value) in dictonary.items()}

Ini bisa berfungsi sebagai templat paling dasar dan sederhana. Ini bisa menjadi semakin kompleks saat Anda menambahkan kondisi.

Menggunakan metode fromkeys()

Python juga menawarkan metode fromkeys(), yang memungkinkan Anda membuat dictionary dengan value seragam untuk himpunan key tertentu. Metode ini berguna saat menginisialisasi dictionary dengan nilai default. Perhatikan contoh berikut:

# Create a dictionary with keys ranging from 0 to 4, all set to True
my_dict = dict.fromkeys(range(5), True)
print(my_dict)

{0: True, 1: True, 2: True, 3: True, 4: True}

Pada contoh ini, metode fromkeys() membuat dictionary di mana key adalah angka dari 0 hingga 4, dan setiap key diberi value True. Pendekatan ini menyederhanakan tugas seperti menginisialisasi dictionary untuk pembaruan atau pemrosesan selanjutnya.

Mengapa Menggunakan Dictionary Comprehension?

Dictionary comprehension adalah konsep yang kuat dan dapat digunakan untuk menggantikan for loop dan fungsi lambda. Namun, tidak semua for loop dapat ditulis sebagai dictionary comprehension, tetapi semua dictionary comprehension dapat ditulis dengan for loop.

Pertimbangkan masalah berikut di mana Anda ingin membuat dictionary baru dengan key berupa angka yang habis dibagi 2 dalam rentang 0–10, dan valuenya adalah kuadrat dari angka tersebut.

Mari lihat bagaimana Anda dapat menyelesaikan masalah yang sama menggunakan for loop dan dictionary comprehension:

numbers = range(10)
new_dict_for = {}

# Add values to `new_dict` using for loop
for n in numbers:
    if n%2==0:
        new_dict_for[n] = n**2

print(new_dict_for)

{0: 0, 8: 64, 2: 4, 4: 16, 6: 36}

# Use dictionary comprehension
new_dict_comp = {n:n**2 for n in numbers if n%2 == 0}

print(new_dict_comp)

{0: 0, 8: 64, 2: 4, 4: 16, 6: 36}

Alternatif untuk for loop

For loop digunakan untuk mengulang operasi tertentu atau blok instruksi dalam program sejumlah kali. Namun, nested for loop (for loop di dalam for loop lainnya) dapat membingungkan dan kompleks. Dictionary comprehension lebih baik dalam situasi seperti ini dan dapat menyederhanakan keterbacaan serta pemahaman Anda terhadap kode.

Tip: lihat tutorial DataCamp Loops in Python untuk informasi lebih lanjut tentang loop di Python.

Alternatif untuk fungsi lambda

Fungsi lambda adalah cara membuat fungsi kecil tanpa nama. Ini adalah fungsi tanpa nama. Fungsi-fungsi ini bersifat sekali pakai, hanya diperlukan di tempat mereka dibuat. Fungsi lambda terutama digunakan bersama fungsi filter(), map() dan reduce().

Mari lihat fungsi lambda bersama fungsi map():

# Initialize `fahrenheit` dictionary 
fahrenheit = {'t1':-30, 't2':-20, 't3':-10, 't4':0}

#Get the corresponding `celsius` values
celsius = list(map(lambda x: (float(5)/9)*(x-32), fahrenheit.values()))

#Create the `celsius` dictionary
celsius_dict = dict(zip(fahrenheit.keys(), celsius))

print(celsius_dict)

{'t2': -28.88888888888889, 't3': -23.333333333333336, 't1': -34.44444444444444, 't4': -17.77777777777778}

Contoh Terperinci Python Dictionary Comprehension

Mari lihat situasi lain di mana Anda ingin mengonversi dictionary suhu Fahrenheit menjadi Celsius.

Mari kita uraikan kodenya: pertama, Anda perlu mendefinisikan rumus matematis yang melakukan konversi dari Fahrenheit ke Celsius.

Dalam kode, ini dilakukan dengan bantuan fungsi lambda. Anda kemudian meneruskan fungsi ini sebagai argumen ke fungsi map(), yang kemudian menerapkan operasi ke setiap item dalam daftar fahrenheit.values().

Ingat fungsi values()? Fungsi ini mengembalikan daftar yang berisi item yang disimpan dalam dictionary.

Sekarang Anda memiliki daftar yang berisi nilai suhu dalam celsius, tetapi solusinya membutuhkan sebuah dictionary.

Python memiliki fungsi bawaan bernama zip() yang menelusuri elemen iterator dan mengagregasikannya. Anda dapat membaca lebih lanjut tentang fungsi zip() dalam contoh Python ini.

Pada contoh di atas, fungsi zip mengagregasikan item dari fahrenheit.keys() dan daftar celsius, menghasilkan pasangan key-value yang dapat Anda gabungkan dalam dictionary menggunakan fungsi dict, yang merupakan hasil yang diinginkan.

Sekarang, mari coba selesaikan masalah yang sama menggunakan dictionary comprehension:

# Initialize the `fahrenheit` dictionary 
fahrenheit = {'t1': -30,'t2': -20,'t3': -10,'t4': 0}

# Get the corresponding `celsius` values and create the new dictionary
celsius = {k:(float(5)/9)*(v-32) for (k,v) in fahrenheit.items()}

print(celsius_dict)

{'t2': -28.88888888888889, 't3': -23.333333333333336, 't1': -34.44444444444444, 't4': -17.77777777777778}

Berikut uraian dari apa yang kita buat pada kode di atas: 

1. Buat dictionary bernama fahrenheit dengan empat pasangan key-value yang merepresentasikan pembacaan suhu dalam Fahrenheit.

2. Definisikan dictionary baru bernama celsius.

3. Gunakan dictionary comprehension untuk melakukan iterasi pada dictionary fahrenheit dan mengonversi pembacaan suhu Fahrenheit ke Celsius menggunakan rumus (5/9) * (F-32).

4. Untuk setiap pasangan key-value di fahrenheit, key ditetapkan ke variabel k dan value ditetapkan ke variabel v.

5. Nilai suhu Celsius yang sesuai dengan setiap suhu Fahrenheit dihitung menggunakan rumus di atas dan ditambahkan sebagai pasangan key-value ke dictionary celsius.

6. Dictionary celsius yang dihasilkan dicetak ke konsol.

Seperti yang Anda lihat, masalah tersebut dapat diselesaikan dengan satu baris kode menggunakan dictionary comprehension dibandingkan proses dua langkah dan pemahaman cara kerja tiga fungsi (lambda, map() dan zip()) pada implementasi pertama.

Selain itu, solusinya intuitif dan mudah dipahami dengan dictionary comprehension. Oleh karena itu, dictionary comprehension dapat menjadi alternatif yang baik untuk fungsi lambda.

Menambahkan Kondisi ke Dictionary Comprehension

Sering kali Anda perlu menambahkan kondisi ke solusi saat mengatasi masalah. Mari jelajahi bagaimana Anda dapat menambahkan kondisi ke dalam dictionary comprehension agar lebih kuat.

Kondisi if

Misalkan Anda perlu membuat dictionary baru dari dictionary yang diberikan tetapi hanya dengan item yang lebih besar dari 2. Ini berarti Anda perlu menambahkan kondisi ke templat asli yang Anda lihat di atas...

dict1 = {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5}

# Check for items greater than 2
dict1_cond = {k:v for (k,v) in dict1.items() if v>2}

print(dict1_cond)

{'e': 5, 'c': 3, 'd': 4}

Ini tidak terlalu sulit! Tetapi bagaimana jika Anda memiliki beberapa kondisi?

Beberapa kondisi if

Pada masalah di atas, bagaimana jika Anda tidak hanya harus mengambil item yang lebih besar dari 2 tetapi juga perlu memeriksa apakah item tersebut kelipatan 2 pada saat yang sama?

dict1_doubleCond = {k:v for (k,v) in dict1.items() if v>2 if v%2 == 0}
print(dict1_doubleCond)

{'d': 4}

Solusi untuk menambahkan beberapa kondisi semudah menambahkan kondisi satu per satu dalam comprehension Anda. Namun, Anda perlu berhati-hati dengan apa yang ingin Anda capai pada masalahnya. Ingat bahwa pernyataan if berurutan bekerja seolah-olah di antaranya ada klausa and.

Mari lihat satu contoh lagi dengan tiga kondisi:

dict1 = {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5, 'f':6}

dict1_tripleCond = {k:v for (k,v) in dict1.items() if v>2 if v%2 == 0 if v%3 == 0}

print(dict1_tripleCond)

{'f': 6}

Dalam for loop, ini akan setara dengan:

dict1_tripleCond = {}

for (k,v) in dict1.items():
    if (v>=2 and v%2 == 0 and v%3 == 0):
            dict1_tripleCond[k] = v

print(dict1_tripleCond)

{'f': 6}

Kondisi if-else

Menangani kondisi if-else juga mudah dengan dictionary comprehension. Lihat contoh berikut untuk membuktikannya:

dict1 = {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5, 'f':6}

# Identify odd and even entries
dict1_tripleCond = {k:('even' if v%2==0 else 'odd') for (k,v) in dict1.items()}

print(dict1_tripleCond)

{'f': 'even', 'c': 'odd', 'b': 'even', 'd': 'even', 'e': 'odd', 'a': 'odd'}

Nested dictionary comprehension

Nesting adalah konsep pemrograman di mana data diorganisasikan dalam lapisan atau objek yang berisi objek serupa lainnya. Anda pasti sering melihat struktur 'if' bertingkat, yaitu kondisi if di dalam kondisi if lainnya.

Demikian pula, dictionary dapat dibuat bertingkat, dan dengan demikian, comprehension-nya juga dapat dibuat bertingkat. Mari lihat apa artinya ini:

nested_dict = {'first':{'a':1}, 'second':{'b':2}}
float_dict = {outer_k: {float(inner_v) for (inner_k, inner_v) in outer_v.items()} for (outer_k, outer_v) in nested_dict.items()}
print(float_dict)

{'first': {1.0}, 'second': {2.0}}

Ini adalah contoh dictionary bertingkat. nested_dict adalah dictionary dengan key: first dan second, yang menyimpan objek dictionary pada valuenya. Kode bekerja dengan value dictionary bagian dalam, mengonversinya ke float, lalu menggabungkan key luar dengan value dalam bertipe float yang baru ke dalam dictionary baru.

Kode ini juga memiliki nested dictionary comprehension, yaitu dictionary comprehension di dalam comprehension lainnya. Dictionary comprehension, saat dibuat bertingkat, dapat menjadi cukup sulit dibaca dan dipahami, yang menghilangkan tujuan utama penggunaan comprehension itu sendiri.

Seiring struktur dictionary yang Anda gunakan menjadi rumit, dictionary comprehension juga mulai menjadi rumit. Untuk situasi seperti itu, sebaiknya Anda tidak menggunakan comprehension yang rumit dalam kode.

Catatan bahwa Anda juga dapat menulis ulang potongan kode di atas dengan nested for loop:

nested_dict = {'first':{'a':1}, 'second':{'b':2}}

for (outer_k, outer_v) in nested_dict.items():
    for (inner_k, inner_v) in outer_v.items():
        outer_v.update({inner_k: float(inner_v)})
nested_dict.update({outer_k:outer_v})

print(nested_dict)

{'first': {'a': 1.0}, 'second': {'b': 2.0}}

Pemikiran Akhir

Semoga sekarang Anda telah mempelajari tentang dictionary di Python, konsep comprehension, serta mengapa dan di mana Python dictionary comprehension dapat berguna. 

Latihan akan membuat Python Anda makin baik! Lihat beberapa tips dan trik Python terbaik kami untuk meningkatkan kode Anda, atau ikuti track Python Data Fundamentals kami untuk menguasai hal-hal terpenting.