Dapatkah kunci kamus python dicantumkan?

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 element
dic_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

dic_a['a'] = 'apple'print (dic_a)
>>> {'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')])

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')])

Alternatifnya, Anda juga dapat menggunakan loop "untuk" untuk mengakses/mencetaknya satu per satu

# 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

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

dic_a = {'A': 'Apple', 'B': 'Ball', 'C': 'Cat'}for key, value in dic_a.items():
    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 element
dic_a['A'] = 'Apple'print (dic_a)
>>> {'A': 'Apple'}# Adding the second element
dic_a['B'] = 'Ball'print (dic_a)
>>> {'A': 'Apple', 'B': 'Ball'}

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

# Adding the first element
dic_a['A'] = 'Apple'print (dic_a)
>>> {'A': 'Apple'}# Adding the second element
dic_a['B'] = 'Ball'print (dic_a)
>>> {'A': 'Apple', 'B': 'Ball'}

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 element
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) 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 Cat

0 dan kunci yang nilainya ingin Anda hapus. Penghapusan ada di tempat, yang berarti Anda tidak perlu menetapkan ulang nilai kamus setelah penghapusan

# Adding the first element
dic_a['A'] = 'Apple'print (dic_a)
>>> {'A': 'Apple'}# Adding the second element
dic_a['B'] = 'Ball'print (dic_a)
>>> {'A': 'Apple', 'B': 'Ball'}

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 element
dic_a['A'] = 'Apple'print (dic_a)
>>> {'A': 'Apple'}# Adding the second element
dic_a['B'] = 'Ball'print (dic_a)
>>> {'A': 'Apple', 'B': 'Ball'}

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 element
dic_a['A'] = 'Apple'print (dic_a)
>>> {'A': 'Apple'}# Adding the second element
dic_a['B'] = 'Ball'print (dic_a)
>>> {'A': 'Apple', 'B': 'Ball'}

Menghapus banyak elemen

Tidak ada cara langsung tetapi Anda dapat menggunakan loop "untuk" seperti yang ditunjukkan di bawah ini

# Adding the first element
dic_a['A'] = 'Apple'print (dic_a)
>>> {'A': 'Apple'}# Adding the second element
dic_a['B'] = 'Ball'print (dic_a)
>>> {'A': 'Apple', 'B': 'Ball'}

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 element
dic_a['A'] = 'Apple'print (dic_a)
>>> {'A': 'Apple'}# Adding the second element
dic_a['B'] = 'Ball'print (dic_a)
>>> {'A': 'Apple', 'B': 'Ball'}

Jika kunci yang Anda tambahkan sudah ada, nilai yang ada akan ditimpa

# Adding the first element
dic_a['A'] = 'Apple'print (dic_a)
>>> {'A': 'Apple'}# Adding the second element
dic_a['B'] = 'Ball'print (dic_a)
>>> {'A': 'Apple', 'B': 'Ball'}

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 Cat

1 untuk menambahkan key-value pair baru dengan meneruskan pasangan tersebut sebagai argumen

# Adding the first element
dic_a['A'] = 'Apple'print (dic_a)
>>> {'A': 'Apple'}# Adding the second element
dic_a['B'] = 'Ball'print (dic_a)
>>> {'A': 'Apple', 'B': 'Ball'}

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

dic_a['a'] = 'apple'print (dic_a)
>>> {'A': 'Apple', 'B': 'Ball', 'a': 'apple'}

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 Cat

3) mulai Python 3. 5 dan seterusnya

dic_a['a'] = 'apple'print (dic_a)
>>> {'A': 'Apple', 'B': 'Ball', 'a': 'apple'}

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 Cat

4ke

# 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

5 yang sudah ada, Anda cukup memperbarui kamus pertama seperti yang ditunjukkan sebelumnya

dic_a['a'] = 'apple'print (dic_a)
>>> {'A': 'Apple', 'B': 'Ball', 'a': 'apple'}

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, kunci

dic_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 Cat

dic_a['a'] = 'apple'print (dic_a)
>>> {'A': 'Apple', 'B': 'Ball', 'a': 'apple'}

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'}

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 Cat

8 untuk menggabungkan dua kamus atau lebih

dic_a['a'] = 'apple'print (dic_a)
>>> {'A': 'Apple', 'B': 'Ball', 'a': 'apple'}

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 Cat

1, Anda dapat menggunakan tugas sederhana

dic_a['a'] = 'apple'print (dic_a)
>>> {'A': 'Apple', 'B': 'Ball', 'a': 'apple'}

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 Cat

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'}

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'}

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 Cat

dic_a['a'] = 'apple'print (dic_a)
>>> {'A': 'Apple', 'B': 'Ball', 'a': 'apple'}

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'}

8) 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'}

Jika Anda ingin kunci Anda berupa string, Anda dapat menggunakan "f-strings"

dic_a = {'A': 'Apple', 'B': 'Ball', 'C': 'Cat'}

9) 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 Cat

dic_a = {'A': 'Apple', 'B': 'Ball', 'C': 'Cat'}

Anda juga dapat menggabungkan kedua daftar dan membuat kamus menggunakan "pemahaman kamus" seperti yang ditunjukkan sebelumnya

dic_a = {'A': 'Apple', 'B': 'Ball', 'C': 'Cat'}

Meneruskan 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 Cat

4 dan itu akan mengembalikan kamus

dic_a = {'A': 'Apple', 'B': 'Ball', 'C': 'Cat'}

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'}

10) 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 Cat

5 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 Cat

dic_a = {'A': 'Apple', 'B': 'Ball', 'C': 'Cat'}

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 Cat

dic_a = {'A': 'Apple', 'B': 'Ball', 'C': 'Cat'}

Salinan dangkal

Salinan dangkal dibuat menggunakan fungsi

dic_a = {'A': 'Apple', 'B': 'Ball', 'C': 'Cat'}dic_a[0]
>>> ----> 1 dic_a[0]    KeyError: 0

0. 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

dic_a = {'A': 'Apple', 'B': 'Ball', 'C': 'Cat'}

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}

Namun, 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}

11) 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: 0

4 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

dic_b = {1: 'Ace', 'B': 123, np.nan: 99.9, 'D': np.nan, 'E': np.inf}

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}

Jika 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: 0

5 sebagai kamus

dic_b = {1: 'Ace', 'B': 123, np.nan: 99.9, 'D': np.nan, 'E': np.inf}

4Kamus tiga lapis

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

dic_b = {1: 'Ace', 'B': 123, np.nan: 99.9, 'D': np.nan, 'E': np.inf}

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: 0

dic_b = {1: 'Ace', 'B': 123, np.nan: 99.9, 'D': np.nan, 'E': np.inf}

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

Bagaimana cara mendapatkan daftar kunci dari kamus dengan Python?

Gunakan fungsi keys() dan terapkan ke kamus masukan untuk mendapatkan daftar semua kunci kamus . Cetak daftar kunci kamus dengan menelusuri setiap kunci dalam daftar kunci di atas menggunakan pemahaman daftar dan for loop.

Bagaimana cara menampilkan kunci kamus dengan python?

Metode dict. keys() dan dict. values() mengembalikan daftar kunci atau nilai secara eksplisit. Ada juga items() yang mengembalikan daftar tupel (kunci, nilai), yang merupakan cara paling efisien untuk memeriksa semua data nilai kunci dalam kamus.

Apa aturan untuk kunci kamus di Python?

Kunci harus tidak dapat diubah . String dan angka adalah dua tipe data yang paling umum digunakan sebagai kunci kamus. Kita juga dapat menggunakan tupel sebagai kunci tetapi harus berisi hanya string, bilangan bulat, atau tupel lainnya. Kami telah membuat kamus dengan kunci bilangan bulat

Bagaimana cara menambahkan daftar ke kunci kamus dengan Python?

Metode 1. Menggunakan tanda += pada kunci dengan nilai kosong .

kode python