Kamus Python – Semua yang Anda Perlu Tahu

Kamus Python ialah struktur data yang sangat berguna yang anda akan dapati anda capai dengan kerap dalam usaha pengaturcaraan anda. Keupayaan unik mereka untuk memetakan kunci kepada nilai masing-masing membolehkan akses pantas, cekap dan kod dipermudahkan apabila mengurus set data yang kompleks.

Kamus Python pada asasnya adalah pelaksanaan tatasusunan bersekutu. Mereka menyediakan cara yang fleksibel dan cekap untuk menyimpan dan memanipulasi data dalam bentuk pasangan nilai kunci.

Ia sangat serba boleh dan boleh menampung koleksi yang boleh ditukar dan dipesan tanpa membenarkan kunci pendua.

Sambil kami menyelami kamus Python dalam artikel ini, anda akan mendapati ia adalah alat yang berkuasa untuk mengatur dan mengakses data anda.

Jadi, pastikan anda membiasakan diri dengan selok-belok kamus Python untuk membuka kunci potensi penuh mereka dalam projek anda!

Isi kandungan

• Memahami Kamus Python
• Cara Membuat Kamus Python
  • Menggunakan Kurung Kerinting
  • Menggunakan Dict Constructor
• Cara Mengakses Elemen Kamus
  • Menggunakan Kekunci
  • Menggunakan Kaedah Dapatkan
• Cara Mengubahsuai Elemen Kamus
  • Menambah Elemen Baharu
  • Mengemas kini Elemen Sedia Ada
• Memadamkan Elemen Kamus
  • Kata Kunci Del
  • Kaedah Jelas
• Apakah Beberapa Kaedah Kamus Biasa?
  • kunci
  • Nilai
  • barang
  • Kemas kini
  • Pop
  • Popitem
• Menggunakan Kamus Python
  • Mengulangi Kamus
  • Apakah Pemahaman Kamus?
  • Apakah Kamus Bersarang?
• Kes Penggunaan Kamus Biasa

Memahami Kamus Python

Kamus dalam Python ialah struktur data yang berkuasa dan fleksibel yang membolehkan anda menyimpan koleksi pasangan nilai kunci. Fikirkan kamus sebagai cara untuk memetakan kunci kepada nilai yang sepadan, menjadikannya mudah untuk mendapatkan maklumat yang berkaitan dengan pengecam tertentu.

Untuk mencipta kamus, anda boleh menggunakan pendakap kerinting ( { } ) yang menyertakan senarai pasangan nilai kunci yang dipisahkan koma. Sebagai contoh:

your_dict = {"key1": "value1", "key2": "value2", "key3": "value3"}

Perlu diingat bahawa kamus dalam Python boleh berubah, yang bermaksud anda boleh mengubah suai kandungannya selepas ia dibuat. Untuk menambah atau mengemas kini pasangan nilai kunci, hanya gunakan sintaks berikut:

your_dict["new_key"] = "new_value"

#You can also update an old key's value
your_dict["old_key"] = "new_value"

Apabila ia datang untuk mengakses nilai dalam kamus, anda hanya memerlukan kunci:

value = your_dict["key1"]

Sekiranya anda cuba mengakses kunci yang tidak wujud dalam kamus, anda akan menghadapi KeyError. Untuk mengelakkan ini, anda boleh menggunakan kaedah get():

value = your_dict.get("non_existent_key", "default_value")

Satu perkara yang anda perlu ingat ialah kamus Python tidak boleh mengandungi kunci pendua. Setiap kunci mestilah unik dan daripada jenis data yang tidak boleh diubah.

Contohnya, anda boleh menggunakan tuple, String, Integer, atau Boolean untuk kunci anda. Walau bagaimanapun, anda tidak boleh menggunakan senarai, kamus atau set.

Tiada sekatan sedemikian untuk nilai. Anda boleh menggunakan kedua-dua jenis data boleh ubah dan tidak boleh ubah.

Mengalih keluar elemen daripada kamus dilakukan dengan menggunakan kata kunci del :

del your_dict["key1"]

Mereka juga menyediakan beberapa kaedah untuk mengulangi kandungannya. Sebagai contoh, anda boleh melingkari kekunci kamus, nilai, atau kedua-duanya:

for key in your_dict.keys():
    print(key)

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

for key, value in your_dict.items():
    print(key, value)

Anda kini boleh menggunakan kaedah dan teknik kamus ini untuk menyimpan, mendapatkan semula dan memanipulasi data dengan cekap semasa bekerja dengan Python .

Cara Membuat Kamus Python

Terdapat dua cara utama anda boleh mencipta kamus Python: menggunakan kurungan kerinting dan pembina dict() .

Menggunakan Kurung Kerinting

Satu kaedah yang boleh anda gunakan untuk mencipta kamus adalah dengan menggunakan kurungan kerinting( {} ). Untuk memulakan kamus kosong, anda hanya boleh menggunakan empty_dict = {} .

Untuk mencipta kamus dengan pasangan nilai kunci, pisahkan kunci dan nilai dengan titik bertindih. Seterusnya, pisahkan setiap pasangan dengan koma:

python_dict = {
    'key1': 'value1',
    'key2': 'value2',
    'key3': 'value3'
}

Menggunakan format ini, anda telah mencipta kamus Python dengan tiga pasangan nilai kunci. Ingat bahawa kunci mestilah unik manakala nilai kamus boleh diduplikasi.

Menggunakan Dict Constructor

Kaedah lain untuk mencipta kamus Python ialah menggunakan pembina dict() . Untuk mencipta kamus kosong, hanya panggil fungsi ini tanpa sebarang hujah: empty_dict = dict() .

Untuk mencipta kamus menggunakan pembina dict() , anda boleh menggunakan sintaks berikut:

python_dict = dict(
    key1='value1',
    key2='value2',
    key3='value3'
)

Kaedah ini juga mencipta kamus Python dengan tiga elemen nilai kunci. Ambil perhatian bahawa, tidak seperti kaedah kurungan kerinting, pembina dict() tidak memerlukan petikan di sekeliling kunci.

Walau bagaimanapun, nilai kamus masih memerlukan petikan di sekelilingnya

Memandangkan anda sudah biasa dengan dua cara untuk mencipta kamus Python, anda boleh mula melaksanakannya dalam kod anda dan memanfaatkan ciri hebatnya dalam aplikasi anda.

Cara Mengakses Elemen Kamus

Dalam bahagian ini, anda akan belajar tentang cara yang berbeza untuk mengakses elemen dalam kamus. Kamus menyimpan data dalam pasangan nilai kunci, dan anda boleh mengakses setiap nilai kamus menggunakan kunci masing-masing.

Kami akan merangkumi dua kaedah popular: Menggunakan kekunci dan kaedah dapatkan .

Menggunakan Kekunci

Salah satu cara paling mudah untuk mengakses elemen kamus adalah dengan menggunakan kekunci. Untuk mendapatkan nilai kunci kamus tertentu, hanya letakkan kunci di dalam kurungan segi empat sama di sebelah nama kamus:

my_dict = {'name': 'John', 'age': 30, 'city': 'New York'}
name_value = my_dict['name']

phone_value = mydict['phone-number']

Dalam contoh ini, name_value akan menyimpan rentetan 'John' . Ambil perhatian bahawa jika anda cuba mengakses kunci yang tidak wujud, Python akan menimbulkan KeyError .

Menggunakan Kaedah Dapatkan

Alternatif untuk menggunakan kekunci secara langsung ialah kaedah get() , yang membolehkan anda mengakses elemen kamus tanpa risiko menimbulkan KeyError . Sebaliknya, kaedah get mengembalikan nilai lalai jika kunci yang ditentukan tidak dijumpai:

my_dict = {'name': 'John', 'age': 30, 'city': 'New York'}
name_value = my_dict.get('name', 'Key not found')
country_value = my_dict.get('country', 'Key not found')

Dalam contoh ini, name_value akan menyimpan rentetan ' John ' seperti sebelum ini kerana kekunci ' name ' terdapat dalam kamus. Walau bagaimanapun, country_value akan menyimpan nilai lalai ' Key not found ' kerana kunci ' country ' tidak wujud dalam kamus.

Kaedah get() menyediakan cara yang lebih fleksibel untuk mengakses elemen kamus, kerana ia membolehkan anda mengendalikan kunci yang hilang dengan anggun. Anda boleh memilih untuk menggunakan salah satu kaedah bergantung pada keperluan anda dan kemungkinan menemui kunci yang tidak wujud.

Cara Mengubahsuai Elemen Kamus

Dalam bahagian ini, anda akan belajar cara mengubah suai elemen dalam kamus Python. Terdapat dua operasi utama untuk mencapai ini: menambah elemen baharu dan mengemas kini elemen sedia ada.

Kedua-dua kaedah ini akan membantu anda mengekalkan ketepatan dan kegunaan kamus anda. Mari lihat mereka:

1. Menambah Elemen Baharu

Menambah elemen baharu pada kamus adalah mudah. Untuk berbuat demikian, tentukan pasangan nilai kunci baharu menggunakan pengendali tugasan, seperti ini:

your_dict = {"key1": "value1", "key2": "value2"}
your_dict["new_key"] = "new_value"

Selepas melaksanakan coretan kod di atas, kamus anda kini akan menyertakan pasangan baharu:

{"key1": "value1", "key2": "value2", "new_key": "new_value"}

Anda juga boleh menambah berbilang pasangan nilai kunci serentak dengan menggunakan kaedah kemas kini() kamus

new_elements = {"key3": "value3", "key4": "value4"}
your_dict.update(new_elements)

Sekarang, kamus anda akan mengandungi entri berikut:

{"key1": "value1", "key2": "value2", "key3": "value3", "key4": "value4"}

1. Mengemas kini Elemen Sedia Ada

Untuk mengemas kini nilai elemen sedia ada, anda hanya perlu merujuk kunci dan menetapkan nilai baharu kepadanya:

your_dict["key1"] = "updated_value1"

Perubahan ini akan menghasilkan kamus berikut:

{"key1": "updated_value1", "key2": "value2", "key3": "value3", "key4": "value4"}

Jika anda perlu mengemas kini berbilang elemen sekali gus, gunakan kaedah kemas kini() sekali lagi. Untuk menggunakannya, masukkan kamus baharu yang mengandungi pengubahsuaian yang diingini.

Sebagai contoh, mari kemas kini kamus your_dict dengan nilai daripada kamus kemas kini:

updates = {"key2": "updated_value2", "key4": "updated_value4"}
your_dict.update(updates)

Dengan kemas kini ini digunakan, kamus your_dict akan kelihatan seperti ini:

{"key1": "updated_value1", "key2": "updated_value2", "key3": "value3", "key4": "updated_value4"}

Operasi ini adalah alat penting apabila berfungsi kerana ia membolehkan anda memastikan struktur data anda dikemas kini dan tepat.

Memadamkan Elemen Kamus

Dalam bahagian ini, kami akan meneroka dua cara biasa untuk memadamkan elemen kamus dalam Python: kata kunci del dan kaedah clear() .

1. Kata Kunci Del

Kata kunci del digunakan untuk mengalih keluar pasangan nilai kunci tertentu daripada kamus. Ia beroperasi di tempat dan menimbulkan KeyError jika kunci tidak wujud dalam kamus. Untuk memadamkan elemen, hanya gunakan sintaks berikut:

del my_dict[key]

Sebagai contoh, jika anda ingin memadamkan kunci yang dipanggil " jenama " daripada kamus bernama my_dict, anda akan menulis:

del my_dict["brand"]

Perlu diingat bahawa adalah amalan yang baik untuk memastikan kunci wujud dalam kamus sebelum menggunakan kata kunci del. Anda boleh melakukan ini dengan menyemak sama ada kunci ada dalam kamus:

if "brand" in my_dict:
    del my_dict["brand"]

1. Kaedah Jelas

The clear() method is another way to delete dictionary elements. This method removes all dictionary keys and values in one operation, resulting in an empty dictionary.

To use the clear() method on your dictionary, simply call it. For example, if you have an existing dictionary named my_dict and you want to remove all its contents, you would write:

my_dict.clear()

In conclusion, you have learned two methods to delete elements from a Python dictionary: the del keyword for removing individual key-value pairs and the clear() method for emptying an entire dictionary.

What Are Some Common Dictionary Methods?

In this section, we will explore some common Python dictionary methods. These built-in methods will help you manipulate and modify dictionaries to suit your needs.

Keys

To retrieve all the keys from your dictionary, you can use the keys() method. This will return a view object containing all the dictionary’s keys.

For example:

your_dict = {'a': 1, 'b': 2, 'c': 3}
key_view = your_dict.keys()
print(key_view)
# Output: dict_keys(['a', 'b', 'c'])

Values

Similarly, the values() method allows you to obtain all the values stored in the dictionary. This is also presented as a view object.

For instance:

value_view = your_dict.values()
print(value_view)
# Output: dict_values([1, 2, 3])

Items

If you need to access both keys and values simultaneously, use the items() method. This returns a view object containing key-value pairs in the form of tuples.

Let’s look at an example:

item_view = your_dict.items()
print(item_view)
# Output: dict_items([('a', 1), ('b', 2), ('c', 3)])

Update

The update() method allows you to modify your dictionary by adding or updating key-value elements. To use the method, you have to provide a dictionary as an argument.

To merge two dictionaries or update specific keys, use this method:

your_dict.update({'d': 4, 'e': 5})
print(your_dict)
# Output: {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5}

Pop

Menggunakan kaedah pop(), anda boleh mengalih keluar item tertentu daripada kamus. Untuk menggunakannya, berikan kunci untuk dialih keluar sebagai hujah dalam kaedah.

Kaedah ini akan mengembalikan nilai yang dikaitkan dengan kunci yang ditentukan dan mengeluarkannya daripada kamus:

removed_value = your_dict.pop('a')
print(removed_value)
# Output: 1
print(your_dict)
# Output: {'b': 2, 'c': 3, 'd': 4, 'e': 5}

Popitem

Kaedah popitem () mengalih keluar pasangan nilai kunci terakhir dalam kamus. Ia mengembalikan tuple yang mengandungi kunci dan nilai yang dialih keluar. Sebagai contoh:

removed_item = your_dict.popitem()
print(removed_item)
# Output: ('e', 5)
print(your_dict)
# Output: {'b': 2, 'c': 3, 'd': 4}

Dengan menggunakan kaedah ini, anda boleh mengurus dan memanipulasi kamus anda dengan berkesan untuk mencapai pelbagai tugas.

Menggunakan Kamus Python

Dalam bahagian ini, anda akan mempelajari teknik yang berbeza untuk bekerja dengan kamus, seperti menggelungkannya, menggunakan pemahaman kamus dan bekerja dengan kamus bersarang.

Mengulangi Kamus

Untuk menggelungkan kamus, anda boleh menggunakan item kaedah terbina dalam () untuk mengulangi pasangan nilai kunci. Ini membolehkan anda melakukan operasi pada kedua-dua kunci dan nilai dengan cara yang boleh dibaca dan cekap.

Berikut adalah contoh:

my_dict = {"apple": 1, "banana": 2, "cherry": 3}

for key, value in my_dict.items():
    print(key, value)

Sebagai alternatif, anda boleh menggunakan kaedah keys() dan values() untuk mengulang sama ada kekunci atau nilai kamus secara eksklusif.

Apakah Pemahaman Kamus?

Pemahaman kamus ialah cara ringkas untuk mencipta kamus menggunakan satu baris kod. Mereka serupa dengan pemahaman senarai tetapi sebaliknya berfungsi dengan kamus.

Berikut ialah contoh kefahaman kamus yang menduakan nombor dari 1 hingga 5:

squared_numbers = {num: num**2 for num in range(1, 6)}

Pemahaman kamus boleh menjadi sangat berharga untuk tugas seperti menapis kamus atau mengubah nilainya.

Apakah Kamus Bersarang?

Kamus bersarang ialah kamus yang mengandungi kamus lain sebagai nilai. Ia boleh digunakan untuk mewakili struktur data hierarki yang kompleks.

Berikut ialah contoh kamus bersarang:

nested_dict = {
    "person1": {"name": "Alice", "age": 30},
    "person2": {"name": "Bob", "age": 24}
}

Untuk mengakses elemen dalam kamus bersarang, gunakan berbilang pengindeksan:

name_p1 = nested_dict["person1"]["name"]

Anda boleh terus mengedit atau memanipulasi elemen dalam kamus bersarang mengikut keperluan. Ingat untuk menjejak kekunci dan tahap bersarang apabila bekerja dengan kamus bersarang yang kompleks untuk mengelakkan kekeliruan atau ralat.

Kes Penggunaan Kamus Biasa

Kamus Python adalah serba boleh, membolehkan anda mengatur dan mengurus pelbagai jenis data. Dalam bahagian ini, anda akan meneroka beberapa kes penggunaan biasa untuk kamus, yang akan meningkatkan pemahaman anda dan membantu anda melaksanakannya dengan berkesan dalam projek anda.

1. Menyimpan data nilai kunci : Kamus sesuai untuk menyimpan data dengan kunci unik dan nilai yang berkaitan, seperti nama pengguna dan maklumat pengguna atau ID produk dan butiran produk:

{
  "username1": {"name": "Alice", "email": "[email protected]"},
  "username2": {"name": "Bob", "email": "[email protected]"}
}

Contoh ini boleh dilihat dalam video ini tentang Cara Membina Agregator Berita Google Dalam LuckyTemplates Menggunakan Python.

https://youtu.be/InsDb_DR15E

Dalam video ini, kami menggunakan kamus untuk menyimpan nilai data yang diperoleh daripada panggilan API GoogleNews.

2. Mengira kejadian : Anda boleh menggunakan kamus untuk mengira kejadian item, seperti kekerapan perkataan dalam dokumen. Menggunakan kekunci untuk mewakili item unik dan nilai untuk menunjukkan kiraan, anda boleh mengurus data sedemikian dengan berkesan.

Fakta yang menyeronokkan, anda boleh melakukan ini dengan kelas Kaunter dalam modul Koleksi Python. Ia mengambil senarai tidak tertib dan mengembalikan kamus dengan setiap elemen unik sebagai kunci dan kekerapannya sebagai nilai masing-masing.

3. Memetakan kunci kepada berbilang nilai : Jika anda perlu menyimpan berbilang nilai untuk setiap kunci kamus, anda boleh menggunakan senarai atau set sebagai nilai dalam kamus anda:

{
  "fruits": ["apple", "banana", "mango"],
  "vegetables": ["carrot", "broccoli", "spinach"]
}

4. Caching hasil pengiraan : Kamus boleh digunakan untuk caching hasil operasi yang mahal. Ini amat berguna dalam teknik memoisasi dan pengaturcaraan dinamik, di mana anda menyimpan hasil pengiraan untuk mengelakkan pengiraan berlebihan.

5. Mencipta indeks terbalik : Dalam kes seperti enjin carian, anda mungkin memerlukan indeks terbalik yang memetakan setiap istilah carian ke senarai sumber yang mengandungi istilah tersebut. Menggunakan kamus membolehkan anda menyimpan data ini dengan cekap:

{
  "python": ["resource1", "resource3"],
  "dictionary": ["resource2", "resource3", "resource4"]
}

Ini hanyalah beberapa contoh untuk menggambarkan kuasa dan kepelbagaian kamus Python. Dengan memahami kes penggunaan ini dan aplikasinya, anda boleh memanfaatkan potensi penuh kamus untuk membina penyelesaian yang cekap untuk tugas pengaturcaraan anda!