Pada artikel ini, saya akan berbicara tentang kamus. Ini adalah artikel kedua dalam seri berjudul "Struktur Data dengan Python". Bagian pertama dari seri ini adalah tentang daftar
Kamus adalah struktur data penting dalam Python yang menggunakan kunci untuk pengindeksan. Mereka adalah urutan item yang tidak diurutkan (pasangan kunci-nilai), yang berarti urutannya tidak dipertahankan. Kuncinya tidak berubah. Sama seperti daftar, nilai kamus dapat menyimpan data yang heterogen i. e. , integer, float, string, NaN, Boolean, daftar, array, dan bahkan kamus bersarang
Artikel ini akan memberi Anda pemahaman yang jelas dan memungkinkan Anda untuk bekerja secara mahir dengan kamus Python
Topik berikut dibahas dalam artikel ini
- Membuat kamus dan menambahkan elemen
- Mengakses elemen kamus
- Menghapus elemen kamus
- Menambahkan/menyisipkan elemen baru
- Menggabungkan/menggabungkan kamus
- Memodifikasi kamus
- Menyortir kamus
- Pemahaman kamus
- Cara alternatif untuk membuat kamus
- Menyalin kamus
- Mengganti nama kunci yang ada
- kamus bersarang
- Memeriksa apakah ada kunci dalam kamus
1) Membuat kamus dan menambahkan elemen
Daftar serupa diinisialisasi menggunakan tanda kurung siku ([ ]), kamus diinisialisasi menggunakan tanda kurung kurawal ({ }). Kamus kosong tentu saja memiliki panjang nol
dic_a = {} # An empty dictionarytype(dic_a)>>> dictlen(dic_a)
>>> 0
Kamus memiliki dua fitur karakteristik. kunci dan nilai. Setiap kunci memiliki nilai yang sesuai. Keduanya, kunci dan nilainya, bisa bertipe string, float, integer, NaN, dll. Menambahkan elemen ke kamus berarti menambahkan pasangan kunci-nilai. Kamus terdiri dari satu atau beberapa pasangan nilai kunci
Mari kita tambahkan beberapa elemen ke kamus kosong kita. Berikut ini adalah salah satu cara untuk melakukannya. Di sini, dic_b = {1: 'Ace', 'B': 123, np.nan: 99.9, 'D': np.nan, 'E': np.inf}_7 adalah kuncinya dan dic_b = {1: 'Ace', 'B': 123, np.nan: 99.9, 'D': np.nan, 'E': np.inf}8 adalah nilainya. Anda dapat menambahkan elemen sebanyak yang Anda suka
# Adding the first elementdic_a['A'] = 'Apple'print (dic_a)
>>> {'A': 'Apple'}# Adding the second element
dic_a['B'] = 'Ball'print (dic_a)
>>> {'A': 'Apple', 'B': 'Ball'}
Catatan. Python sensitif terhadap huruf besar-kecil, dic_b = {1: 'Ace', 'B': 123, np.nan: 99.9, 'D': np.nan, 'E': np.inf}7 dan dic_a = {'A': 'Apple', 'B': 'Ball', 'C': 'Cat'}dic_a.keys()
>>> dict_keys(['A', 'B', 'C'])dic_a.values()
>>> dict_values(['Apple', 'Ball', 'Cat'])dic_a.items()
>>> dict_items([('A', 'Apple'), ('B', 'Ball'), ('C', 'Cat')])0 bertindak sebagai dua kunci yang berbeda
>>> {'A': 'Apple', 'B': 'Ball', 'a': 'apple'}_
Menginisialisasi kamus sekaligus
Jika Anda merasa metode penambahan elemen satu per satu di atas melelahkan, Anda juga dapat menginisialisasi kamus sekaligus dengan menentukan semua pasangan nilai kunci
dic_a = {'A': 'Apple', 'B': 'Ball', 'C': 'Cat'}Kamus heterogen
Sejauh ini kamus Anda memiliki string sebagai kunci dan nilai. Kamus juga dapat menyimpan data dari tipe campuran. Berikut ini adalah kamus Python yang valid
dic_b = {1: 'Ace', 'B': 123, np.nan: 99.9, 'D': np.nan, 'E': np.inf}_Anda harus menggunakan nama yang bermakna untuk kunci karena menunjukkan indeks kamus. Secara khusus, hindari penggunaan float dan np. nan sebagai kunci
2) Mengakses elemen kamus
Setelah membuat kamus kita, mari kita lihat bagaimana kita bisa mengakses elemen mereka
Mengakses kunci dan nilai
Anda dapat mengakses kunci dan nilai masing-masing menggunakan fungsi ________5______1 dan dic_a = {'A': 'Apple', 'B': 'Ball', 'C': 'Cat'}dic_a.keys()
>>> dict_keys(['A', 'B', 'C'])dic_a.values()
>>> dict_values(['Apple', 'Ball', 'Cat'])dic_a.items()
>>> dict_items([('A', 'Apple'), ('B', 'Ball'), ('C', 'Cat')])2. Anda juga dapat mengakses kunci dan nilai dalam bentuk tuple menggunakan fungsi dic_a = {'A': 'Apple', 'B': 'Ball', 'C': 'Cat'}dic_a.keys()
>>> dict_keys(['A', 'B', 'C'])dic_a.values()
>>> dict_values(['Apple', 'Ball', 'Cat'])dic_a.items()
>>> dict_items([('A', 'Apple'), ('B', 'Ball'), ('C', 'Cat')])3
>>> dict_keys(['A', 'B', 'C'])dic_a.values()
>>> dict_values(['Apple', 'Ball', 'Cat'])dic_a.items()
>>> dict_items([('A', 'Apple'), ('B', 'Ball'), ('C', 'Cat')])
Alternatifnya, Anda juga dapat menggunakan loop "untuk" untuk mengakses/mencetaknya satu per satu
# Printing keysfor key in dic_a.keys():
print (key, end=' ')
>>> A B C############################## Printing values
for key in dic_a.values():
print (key, end=' ')
>>> Apple Ball Cat
Anda dapat menghindari dua putaran "untuk" dan mengakses kunci dan nilai menggunakan dic_a = {'A': 'Apple', 'B': 'Ball', 'C': 'Cat'}dic_a.keys()
>>> dict_keys(['A', 'B', 'C'])dic_a.values()
>>> dict_values(['Apple', 'Ball', 'Cat'])dic_a.items()
>>> dict_items([('A', 'Apple'), ('B', 'Ball'), ('C', 'Cat')])3. Loop "untuk" akan mengulang melalui pasangan kunci-nilai yang dikembalikan oleh dic_a = {'A': 'Apple', 'B': 'Ball', 'C': 'Cat'}dic_a.keys()
>>> dict_keys(['A', 'B', 'C'])dic_a.values()
>>> dict_values(['Apple', 'Ball', 'Cat'])dic_a.items()
>>> dict_items([('A', 'Apple'), ('B', 'Ball'), ('C', 'Cat')])3. Di sini, dic_a = {'A': 'Apple', 'B': 'Ball', 'C': 'Cat'}dic_a.keys()
>>> dict_keys(['A', 'B', 'C'])dic_a.values()
>>> dict_values(['Apple', 'Ball', 'Cat'])dic_a.items()
>>> dict_items([('A', 'Apple'), ('B', 'Ball'), ('C', 'Cat')])6 dan dic_a = {'A': 'Apple', 'B': 'Ball', 'C': 'Cat'}dic_a.keys()
>>> dict_keys(['A', 'B', 'C'])dic_a.values()
>>> dict_values(['Apple', 'Ball', 'Cat'])dic_a.items()
>>> dict_items([('A', 'Apple'), ('B', 'Ball'), ('C', 'Cat')])7 adalah nama variabel arbitrer
print (key, value)
>>> A Apple
B Ball
C Cat
Mengakses elemen individu
Item kamus tidak dapat diakses menggunakan pengindeksan seperti daftar
dic_a = {'A': 'Apple', 'B': 'Ball', 'C': 'Cat'}dic_a[0]>>> ----> 1 dic_a[0] KeyError: 0
Anda perlu menggunakan kunci untuk mengakses nilai yang sesuai dari kamus
# Accessing the value "Apple"dic_a['A']
>>> 'Apple'# Accessing the value "Cat"
dic_a['C']
>>> 'Cat'
Anda akan mendapatkan error jika kunci tidak ada di kamus
# Adding the first elementdic_a['A'] = 'Apple'print (dic_a)
>>> {'A': 'Apple'}# Adding the second element
dic_a['B'] = 'Ball'print (dic_a)
>>> {'A': 'Apple', 'B': 'Ball'}0
Jika Anda ingin menghindari kesalahan kunci seperti itu jika kunci tidak ada, Anda dapat menggunakan fungsi dic_a = {'A': 'Apple', 'B': 'Ball', 'C': 'Cat'}dic_a.keys()
>>> dict_keys(['A', 'B', 'C'])dic_a.values()
>>> dict_values(['Apple', 'Ball', 'Cat'])dic_a.items()
>>> dict_items([('A', 'Apple'), ('B', 'Ball'), ('C', 'Cat')])8. Ini mengembalikan dic_a = {'A': 'Apple', 'B': 'Ball', 'C': 'Cat'}dic_a.keys()
>>> dict_keys(['A', 'B', 'C'])dic_a.values()
>>> dict_values(['Apple', 'Ball', 'Cat'])dic_a.items()
>>> dict_items([('A', 'Apple'), ('B', 'Ball'), ('C', 'Cat')])_9 saat kunci tidak ada. Anda juga dapat menggunakan pesan khusus untuk dikembalikan
dic_a['A'] = 'Apple'print (dic_a)
>>> {'A': 'Apple'}# Adding the second element
dic_a['B'] = 'Ball'print (dic_a)
>>> {'A': 'Apple', 'B': 'Ball'}1
Mengakses elemen kamus seperti dalam daftar
Jika Anda ingin mengakses elemen kamus (baik kunci atau nilai) menggunakan indeks, Anda harus terlebih dahulu mengonversinya menjadi daftar
# Adding the first elementdic_a['A'] = 'Apple'print (dic_a)
>>> {'A': 'Apple'}# Adding the second element
dic_a['B'] = 'Ball'print (dic_a)
>>> {'A': 'Apple', 'B': 'Ball'}2
3) Menghapus elemen kamus
Menghapus elemen dari kamus berarti menghapus pasangan nilai kunci secara bersamaan
Menggunakan del
Anda dapat menghapus elemen kamus menggunakan kata kunci # Printing keys
for key in dic_a.keys():
print (key, end=' ')
>>> A B C############################## Printing values
for key in dic_a.values():
print (key, end=' ')
>>> Apple Ball Cat0 dan kunci yang nilainya ingin Anda hapus. Penghapusan ada di tempat, yang berarti Anda tidak perlu menetapkan ulang nilai kamus setelah penghapusan
dic_a['A'] = 'Apple'print (dic_a)
>>> {'A': 'Apple'}# Adding the second element
dic_a['B'] = 'Ball'print (dic_a)
>>> {'A': 'Apple', 'B': 'Ball'}_3
Menggunakan pop()
Anda juga dapat menggunakan fungsi “pop()” untuk menghapus elemen. Ini mengembalikan nilai yang muncul (dihapus) dan kamus dimodifikasi di tempat
# Adding the first elementdic_a['A'] = 'Apple'print (dic_a)
>>> {'A': 'Apple'}# Adding the second element
dic_a['B'] = 'Ball'print (dic_a)
>>> {'A': 'Apple', 'B': 'Ball'}_4
Dalam kedua metode yang dijelaskan di atas, Anda akan mendapatkan KeyError jika kunci yang akan dihapus tidak ada dalam kamus. Dalam kasus "pop ( )", Anda dapat menentukan pesan kesalahan untuk muncul jika kuncinya tidak ada
# Adding the first elementdic_a['A'] = 'Apple'print (dic_a)
>>> {'A': 'Apple'}# Adding the second element
dic_a['B'] = 'Ball'print (dic_a)
>>> {'A': 'Apple', 'B': 'Ball'}5
Menghapus banyak elemen
Tidak ada cara langsung tetapi Anda dapat menggunakan loop "untuk" seperti yang ditunjukkan di bawah ini
# Adding the first elementdic_a['A'] = 'Apple'print (dic_a)
>>> {'A': 'Apple'}# Adding the second element
dic_a['B'] = 'Ball'print (dic_a)
>>> {'A': 'Apple', 'B': 'Ball'}6
4) Menambahkan/menyisipkan elemen baru
Anda dapat menambahkan satu elemen sekaligus ke kamus yang sudah ada seperti yang ditunjukkan di bawah ini
# Adding the first elementdic_a['A'] = 'Apple'print (dic_a)
>>> {'A': 'Apple'}# Adding the second element
dic_a['B'] = 'Ball'print (dic_a)
>>> {'A': 'Apple', 'B': 'Ball'}_7
Jika kunci yang Anda tambahkan sudah ada, nilai yang ada akan ditimpa
# Adding the first elementdic_a['A'] = 'Apple'print (dic_a)
>>> {'A': 'Apple'}# Adding the second element
dic_a['B'] = 'Ball'print (dic_a)
>>> {'A': 'Apple', 'B': 'Ball'}8
Menggunakan pembaruan()
Anda juga dapat menggunakan fungsi # Printing keys
for key in dic_a.keys():
print (key, end=' ')
>>> A B C############################## Printing values
for key in dic_a.values():
print (key, end=' ')
>>> Apple Ball Cat1 untuk menambahkan key-value pair baru dengan meneruskan pasangan tersebut sebagai argumen
dic_a['A'] = 'Apple'print (dic_a)
>>> {'A': 'Apple'}# Adding the second element
dic_a['B'] = 'Ball'print (dic_a)
>>> {'A': 'Apple', 'B': 'Ball'}_9
Fungsi # Printing keys
for key in dic_a.keys():
print (key, end=' ')
>>> A B C############################## Printing values
for key in dic_a.values():
print (key, end=' ')
>>> Apple Ball Cat_1 juga memungkinkan Anda menambahkan beberapa pasangan kunci-nilai secara bersamaan ke kamus yang ada
>>> {'A': 'Apple', 'B': 'Ball', 'a': 'apple'}_0
5) Menggabungkan/menggabungkan kamus
Anda dapat menggabungkan dua kamus atau lebih menggunakan operator unpacking (# Printing keys
for key in dic_a.keys():
print (key, end=' ')
>>> A B C############################## Printing values
for key in dic_a.values():
print (key, end=' ')
>>> Apple Ball Cat3) mulai Python 3. 5 dan seterusnya
>>> {'A': 'Apple', 'B': 'Ball', 'a': 'apple'}_1
Jika Anda tidak ingin membuat kamus baru tetapi hanya ingin menambahkan # Printing keys
for key in dic_a.keys():
print (key, end=' ')
>>> A B C############################## Printing values
for key in dic_a.values():
print (key, end=' ')
>>> Apple Ball Cat4ke # Printing keys
for key in dic_a.keys():
print (key, end=' ')
>>> A B C############################## Printing values
for key in dic_a.values():
print (key, end=' ')
>>> Apple Ball Cat5 yang sudah ada, Anda cukup memperbarui kamus pertama seperti yang ditunjukkan sebelumnya
>>> {'A': 'Apple', 'B': 'Ball', 'a': 'apple'}_2
Bagaimana kunci duplikat ditangani saat digabungkan?
Salah satu karakteristik kamus Python adalah kamus tidak dapat memiliki kunci duplikat i. e. , kunci tidak dapat muncul dua kali. Jadi, apa yang terjadi jika Anda menggabungkan dua kamus atau lebih yang memiliki satu atau beberapa kunci umum
Jawabannya adalah pasangan kunci-nilai dalam kamus yang digabungkan terakhir (dalam urutan penggabungan) akan bertahan. Dalam contoh berikut, kuncidic_b = {1: 'Ace', 'B': 123, np.nan: 99.9, 'D': np.nan, 'E': np.inf}_7 ada di ketiga kamus, dan, oleh karena itu, kamus terakhir mengambil nilai dari kamus gabungan terakhir (# Printing keys
for key in dic_a.keys():
print (key, end=' ')
>>> A B C############################## Printing values
for key in dic_a.values():
print (key, end=' ')
>>> Apple Ball Cat7)
>>> {'A': 'Apple', 'B': 'Ball', 'a': 'apple'}_3
Kata hati-hati
Saya baru saja mengatakan bahwa kamus tidak boleh memiliki kunci duplikat. Sebenarnya, Anda dapat menentukan kamus dengan kunci duplikat, tetapi ketika Anda mencetaknya, hanya kunci duplikat terakhir yang akan dicetak. A yang ditampilkan di bawah, hanya kunci unik yang dikembalikan, dan untuk kunci duplikat ('A' di sini), hanya nilai terakhir yang dikembalikan
dic_a['a'] = 'apple'print (dic_a)>>> {'A': 'Apple', 'B': 'Ball', 'a': 'apple'}_4
Cara yang lebih mudah di Python 3. 9+
Dari Python 3. 9 dan seterusnya, Anda dapat menggunakan operator # Printing keys
for key in dic_a.keys():
print (key, end=' ')
>>> A B C############################## Printing values
for key in dic_a.values():
print (key, end=' ')
>>> Apple Ball Cat8 untuk menggabungkan dua kamus atau lebih
>>> {'A': 'Apple', 'B': 'Ball', 'a': 'apple'}_5
6) Memodifikasi kamus
Jika Anda ingin mengubah nilai dic_b = {1: 'Ace', 'B': 123, np.nan: 99.9, 'D': np.nan, 'E': np.inf}_7 dari dic_b = {1: 'Ace', 'B': 123, np.nan: 99.9, 'D': np.nan, 'E': np.inf}8 menjadi dic_a = {'A': 'Apple', 'B': 'Ball', 'C': 'Cat'}for key, value in dic_a.items():
print (key, value)
>>> A Apple
B Ball
C Cat1, Anda dapat menggunakan tugas sederhana
>>> {'A': 'Apple', 'B': 'Ball', 'a': 'apple'}_6
7) Menyortir kamus
Urutan tidak dipertahankan dalam kamus. Anda dapat mengurutkan kamus menggunakan tombol atau nilai menggunakan fungsi dic_a = {'A': 'Apple', 'B': 'Ball', 'C': 'Cat'}for key, value in dic_a.items():
print (key, value)
>>> A Apple
B Ball
C Cat2
Menyortir menggunakan kunci
Jika kuncinya berupa string (abjad), maka akan diurutkan menurut abjad. Dalam kamus, kami memiliki dua elemen utama. kunci dan nilai. Karenanya, saat menyortir sehubungan dengan kunci, kami menggunakan elemen pertama i. e. kunci, dan, oleh karena itu, indeks yang digunakan dalam fungsi lambda adalah “[0]”. Anda dapat membaca untuk informasi lebih lanjut tentang fungsi lambda
dic_a['a'] = 'apple'print (dic_a)>>> {'A': 'Apple', 'B': 'Ball', 'a': 'apple'}_7
Penyortiran tidak di tempat. Seperti ditunjukkan di bawah ini, jika Anda sekarang mencetak kamus, itu tetap tidak terurut, seperti yang diinisialisasi secara asli. Anda harus menugaskannya kembali setelah menyortir
dic_a['a'] = 'apple'print (dic_a)>>> {'A': 'Apple', 'B': 'Ball', 'a': 'apple'}_8
Jika Anda ingin mengurutkan dalam urutan terbalik, tentukan kata kunci dic_a = {'A': 'Apple', 'B': 'Ball', 'C': 'Cat'}for key, value in dic_a.items():
print (key, value)
>>> A Apple
B Ball
C Cat3
>>> {'A': 'Apple', 'B': 'Ball', 'a': 'apple'}_9
Mengurutkan menggunakan nilai
Untuk mengurutkan kamus berdasarkan nilainya, Anda perlu menggunakan indeks “[1]” di dalam fungsi lambda
dic_a = {'A': 'Apple', 'B': 'Ball', 'C': 'Cat'}08) Pemahaman kamus
Ini adalah metode yang sangat membantu untuk membuat kamus secara dinamis. Misalkan Anda ingin membuat kamus di mana kuncinya adalah bilangan bulat dan nilainya adalah kuadratnya. Pemahaman kamus akan terlihat seperti berikut ini
dic_a = {'A': 'Apple', 'B': 'Ball', 'C': 'Cat'}1Jika Anda ingin kunci Anda berupa string, Anda dapat menggunakan "f-strings"
dic_a = {'A': 'Apple', 'B': 'Ball', 'C': 'Cat'}29) Cara alternatif untuk membuat kamus
Membuat kamus dari daftar
Misalkan Anda memiliki dua daftar dan Anda ingin membuat kamus darinya. Cara paling sederhana adalah dengan menggunakan konstruktor dic_a = {'A': 'Apple', 'B': 'Ball', 'C': 'Cat'}for key, value in dic_a.items():
print (key, value)
>>> A Apple
B Ball
C Cat4
Anda juga dapat menggabungkan kedua daftar dan membuat kamus menggunakan "pemahaman kamus" seperti yang ditunjukkan sebelumnya
dic_a = {'A': 'Apple', 'B': 'Ball', 'C': 'Cat'}4Meneruskan key-value pair
Anda juga dapat meneruskan daftar pasangan kunci-nilai yang dipisahkan dengan koma ke konstruk dic_a = {'A': 'Apple', 'B': 'Ball', 'C': 'Cat'}for key, value in dic_a.items():
print (key, value)
>>> A Apple
B Ball
C Cat4 dan itu akan mengembalikan kamus
Jika kunci Anda berupa string, Anda bahkan dapat menggunakan inisialisasi yang lebih sederhana dengan hanya menggunakan variabel sebagai kunci
dic_a = {'A': 'Apple', 'B': 'Ball', 'C': 'Cat'}610) Menyalin kamus
Saya akan menjelaskan poin ini menggunakan contoh sederhana. Ada lebih banyak seluk-beluk yang terlibat dalam mekanisme penyalinan kamus, dan, saya akan merekomendasikan pembaca untuk merujuk ke posting Stack Overflow ini untuk penjelasan terperinci
Tugas referensi
Saat Anda hanya menetapkan ulang kamus yang ada (kamus induk) ke kamus baru, keduanya menunjuk ke objek yang sama ("penugasan referensi")
Pertimbangkan contoh berikut di mana Anda menugaskan kembali # Printing keys
for key in dic_a.keys():
print (key, end=' ')
>>> A B C############################## Printing values
for key in dic_a.values():
print (key, end=' ')
>>> Apple Ball Cat5 ke # Printing keys
for key in dic_a.keys():
print (key, end=' ')
>>> A B C############################## Printing values
for key in dic_a.values():
print (key, end=' ')
>>> Apple Ball Cat4
Sekarang, jika Anda memodifikasi # Printing keys
for key in dic_a.keys():
print (key, end=' ')
>>> A B C############################## Printing values
for key in dic_a.values():
print (key, end=' ')
>>> Apple Ball Cat_4(untuk e. g. menambahkan elemen baru), Anda akan melihat bahwa perubahan juga akan tercermin dalam # Printing keys
for key in dic_a.keys():
print (key, end=' ')
>>> A B C############################## Printing values
for key in dic_a.values():
print (key, end=' ')
>>> Apple Ball Cat5
Salinan dangkal
Salinan dangkal dibuat menggunakan fungsi dic_a = {'A': 'Apple', 'B': 'Ball', 'C': 'Cat'}dic_a[0]
>>> ----> 1 dic_a[0] KeyError: 00. Dalam salinan dangkal, kedua kamus bertindak sebagai dua objek independen, dengan isinya masih berbagi referensi yang sama. Jika Anda menambahkan pasangan kunci-nilai baru di kamus baru (salinan dangkal), itu tidak akan muncul di kamus induk
Sekarang, jika isi kamus induk ("dic_a") akan berubah tergantung pada jenis nilainya. Misalnya, berikut ini, isinya adalah string sederhana yang tidak dapat diubah. Jadi mengubah nilai di "dic_b" untuk kunci tertentu (dic_b = {1: 'Ace', 'B': 123, np.nan: 99.9, 'D': np.nan, 'E': np.inf}7dalam hal ini) tidak akan mengubah nilai kunci dic_b = {1: 'Ace', 'B': 123, np.nan: 99.9, 'D': np.nan, 'E': np.inf}7 di "dic_a"
dic_b = {1: 'Ace', 'B': 123, np.nan: 99.9, 'D': np.nan, 'E': np.inf}_0Namun, jika nilai kunci dic_b = {1: 'Ace', 'B': 123, np.nan: 99.9, 'D': np.nan, 'E': np.inf}_7 di “dic_a” adalah daftar, maka perubahan nilainya di “dic_b” akan mencerminkan perubahan di “dic_a” (kamus induk), karena daftar bisa berubah
dic_b = {1: 'Ace', 'B': 123, np.nan: 99.9, 'D': np.nan, 'E': np.inf}_111) Mengganti nama kunci yang ada
Misalkan Anda ingin mengganti kunci "Adam" dengan "Alex". Anda dapat menggunakan fungsi dic_a = {'A': 'Apple', 'B': 'Ball', 'C': 'Cat'}dic_a[0]
>>> ----> 1 dic_a[0] KeyError: 04 karena fungsi ini menghapus kunci yang diteruskan ("Adam" di sini) dan mengembalikan nilai yang dihapus (85 di sini). Jadi Anda membunuh dua burung dengan satu tembakan. Gunakan nilai yang dikembalikan (dihapus) untuk menetapkan nilai ke kunci baru ("Alex" di sini). Mungkin ada kasus yang lebih rumit di mana kuncinya adalah tuple. Kasus seperti itu berada di luar cakupan artikel ini
12) Kamus bersarang
Kamus bersarang memiliki satu atau lebih kamus di dalam kamus. Berikut ini adalah contoh paling sederhana dari nested dictionary dengan dua layer nesting. Di sini, kamus luar (lapisan 1) hanya memiliki satu pasangan kunci-nilai. Namun, nilainya sekarang menjadi kamus itu sendiri
dic_b = {1: 'Ace', 'B': 123, np.nan: 99.9, 'D': np.nan, 'E': np.inf}_3Jika Anda ingin mengakses pasangan kunci-nilai lebih lanjut dari kamus dalam (lapisan 2), Anda sekarang perlu menggunakan dic_a = {'A': 'Apple', 'B': 'Ball', 'C': 'Cat'}dic_a[0]
>>> ----> 1 dic_a[0] KeyError: 05 sebagai kamus
Mari kita tambahkan lapisan kamus bersarang tambahan. Sekarang, dic_a = {'A': 'Apple', 'B': 'Ball', 'C': 'Cat'}dic_a[0]
>>> ----> 1 dic_a[0] KeyError: 0_5 adalah kamus bersarang itu sendiri, tidak seperti kamus bersarang paling sederhana di atas
13) Memeriksa apakah ada kunci dalam kamus
Anda dapat menemukan kunci tertentu yang ada dalam kamus menggunakan operator dic_a = {'A': 'Apple', 'B': 'Ball', 'C': 'Cat'}dic_a[0]
>>> ----> 1 dic_a[0] KeyError: 07
Pada kode di atas, Anda tidak perlu menggunakan “in dic_a. keys()” karena “in dic_a” sudah terlihat di tombol
Ini membawa saya ke akhir artikel ini. Anda dapat mengakses bagian pertama dari seri ini tentang “Struktur Data dengan Python” di sini