Tutorial Memahami Kamus Python

Bahasa pengaturcaraan Python menawarkan set alat unik yang menjadikan pengekodan bukan sahaja menyeronokkan tetapi juga mempercepatkan kemajuan anda sebagai pengaturcara. Disebabkan kemudahan penggunaannya, Python telah menjadi bahasa pilihan untuk pelbagai industri, daripada pembangunan web dan sains data kepada kewangan dan seterusnya.

Pemahaman kamus Python ialah alat penting yang membolehkan anda menjana kamus secara dinamik dengan mengulangi struktur data atau kamus boleh lelar sedia ada untuk mencipta yang baharu. Anda boleh menganggap pemahaman kamus sebagai serupa dengan pemahaman senarai tetapi dengan kes penggunaan yang sedikit berbeza.

Apabila anda membiasakan diri dengan pemahaman, anda akan mendapati ia boleh meningkatkan kod dengan ketara dengan mempromosikan kejelasan dan menghapuskan keperluan untuk gelung yang panjang dan berulang.

Jika anda baru menggunakan Python , anda mungkin tidak menemui pemahaman atau menggunakannya dalam kod anda. Sebelum menyelami sintaks, mari kita jawab soalan utama: Apakah pemahaman kamus Python?

Isi kandungan

• Apakah Pemahaman Kamus Python?
• Memahami Sintaks Kefahaman Kamus
• Contoh Kamus Pemahaman
  • Memetakan Nombor kepada petak mereka
  • Kunci dan Nilai Songsang
• 3 Kelebihan Utama Kefahaman Kamus
  • 1. Mencipta Kod Jelas dan Mudah
  • 2. Prestasi Lebih Baik dengan Gaya
  • 3. Penapisan Mudah dan Transformasi Data
• 3 Contoh Bila Menggunakan Kefahaman Kamus
  • 1. Apabila Mencipta kamus daripada dua senarai
  • 2. Apabila Menapis kamus berdasarkan nilai
  • 3. Apabila Mengubah kunci atau nilai
• Perangkap Kefahaman Kamus
  • Mengimbangi Kerumitan dan Kebolehbacaan
  • Prestasi dengan Set Data Besar
• Perbandingan dengan Kaedah Lain
  • Untuk Gelung
  • Fungsi Lambda
• Amalan Terbaik untuk Pemahaman Kamus
• Kata Akhir Kami

Apakah Pemahaman Kamus Python?

Pemahaman Kamus Python ialah cara ringkas untuk mencipta kamus menggunakan ungkapan mudah. Ia membolehkan anda menjana kamus baharu tanpa perlu menggunakan for-loops.e

Mari kita lihat contoh kefahaman. Katakan anda mempunyai dua senarai, satu mengandungi kunci dan satu lagi mengandungi nilai:

keys = ['a', 'b', 'c']
values = [1, 2, 3]

Menggunakan pemahaman kamus, anda boleh mencipta kamus baharu dengan mengulangi dua senarai dan menggabungkan pasangan nilai kunci yang sepadan:

my_dict = {k: v for k, v in zip(keys, values)}
print(my_dict)

Outputnya ialah:

{'a': 1, 'b': 2, 'c': 3}

Contoh di atas harus memberi gambaran tentang pemahaman dalam Python . Untuk membantu anda mengukuhkan lagi konsep, mari kita fahami sintaks pemahaman kamus dalam Python.

Memahami Sintaks Kefahaman Kamus

Sintaks untuk pemahaman kamus adalah mudah tetapi berkuasa. Mereka menawarkan cara ringkas untuk mencipta kamus baharu dalam Python . Selain itu, mereka mengikuti sintaks yang serupa untuk menyenaraikan kefahaman tetapi menggunakan pendakap kerinting {} dan pasangan nilai kunci yang dipisahkan oleh titik bertindih.

Struktur asas adalah seperti berikut:

{key: value for (key, value) in iterable}

Dalam sintaks ini, kunci dan nilai mewakili ungkapan yang digunakan untuk menjana kunci dan nilai kamus yang dihasilkan. Iterable menyediakan sumber data yang digunakan untuk mencipta pasangan nilai kunci.

Sintaks ini diperkenalkan dalam Python 3 dan disandarkan sejauh Python 2.7, memastikan keserasian yang luas merentas versi Python.

Contohnya, untuk mencipta kamus yang memetakan nombor daripada 0 hingga 4 kepada petaknya menggunakan pemahaman kamus, anda boleh menggunakan kod Python berikut:

square_dict = {x: x**2 for x in range(5)}

Ini akan menghasilkan kamus berikut:

{0: 0, 1: 1, 2: 4, 3: 9, 4: 16}

Bagaimana jika anda ingin mengulangi dua pembolehubah pada masa yang sama? Anda boleh mencapai ini menggunakan pemahaman kamus dengan fungsi zip() untuk mencipta kamus daripada dua iterable, satu mewakili kekunci dan satu lagi mewakili nilai. Berikut ialah contoh:

keys = ['a', 'b', 'c', 'd', 'e']
values = [1, 2, 3, 4, 5]
my_dict = {k: v for k, v in zip(keys, values)}

Kamus yang terhasil ialah:

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

Pemahaman kamus juga membolehkan anda menambah pernyataan jika pilihan pada akhir pemahaman untuk menggunakan penapis bersyarat pada item yang disertakan.

Sebagai contoh, anda boleh mencipta kamus dengan hanya nombor genap dan petaknya menggunakan pemahaman kamus:

even_square_dict = {x: x**2 for x in range(10) if x % 2 == 0}

Ini mengakibatkan:

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

Memandangkan anda sudah biasa dengan sintaks pemahaman, mari lihat beberapa contoh pemahaman.

Contoh Kamus Pemahaman

Pemahaman kamus menemui pelbagai kes penggunaan kerana sintaksnya yang berkuasa dan elegan. Mereka boleh menjimatkan masa anda dan menjadikan kod anda lebih mudah dibaca.

Memetakan Nombor kepada petak mereka

Pertimbangkan contoh mudah di mana anda ingin mencipta kamus yang memetakan nombor ke petak mereka menggunakan pemahaman kamus Python:

squares = {x: x**2 for x in range(1, 6)}
print(squares)

Ini akan mengeluarkan:

{1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

Kod di atas melakukan kerja yang sama seperti menjalankan gelung enam kali dan menduakan setiap nombor. Kod di bawah menunjukkan menjalankan gelung untuk mengambil kuasa dua nombor:

squares = {}
for x in range(1, 6):
    squares[x] = x ** 2

print(squares)

Pada ketika ini, anda mungkin tertanya-tanya mengapa menggunakan pemahaman apabila anda boleh menggunakan gelung. Dalam pengaturcaraan, peraturan biasa ialah menulis kod yang padat dan cekap.

Anda juga boleh menggunakan syarat untuk pemahaman anda. Sebagai contoh, anda mungkin ingin mencipta kamus yang mengandungi hanya nombor genap dan petaknya:

even_squares = {x: x**2 for x in range(1, 6) if x % 2 == 0}
print(even_squares)

Menjalankan kod ini akan menghasilkan kamus baharu seperti berikut:

{2: 4, 4: 16}

Kunci dan Nilai Songsang

Anda juga boleh membalikkan elemen kamus dengan mudah dengan pemahaman kamus dalam Python.

Kod berikut menunjukkan cara untuk membalikkan kunci dan nilai kamus sedia ada menggunakan pemahaman kamus:

original_dict = {"one": 1, "two": 2, "three": 3, "four": 4}
reversed_dict = {v: k for k, v in original_dict.items()}
print(reversed_dict)

Pemahaman kamus di atas (atau pemahaman dict) akan mencetak perkara berikut:

{1: 'one', 2: 'two', 3: 'three', 4: 'four'}

Untuk mendapatkan pemahaman yang baik tentang apa itu kamus dan bagaimana anda boleh menggunakannya untuk kes yang berbeza, sila rujuk video yang diberikan di bawah:

Contoh yang disediakan berfungsi sebagai asas yang kukuh untuk menggunakan pemahaman kamus dalam projek Python anda.

Selain itu, pemahaman kamus boleh dioptimumkan lagi, membenarkan satu baris kod untuk menyelesaikan tugasan kompleks yang mungkin memakan lebih banyak masa dan memori dengan gelung.

3 Kelebihan Utama Kefahaman Kamus

Anda telah mengalami keanggunan pemahaman kamus melalui contoh yang disediakan. Selain daripada kebolehbacaan, pemahaman menawarkan beberapa kelebihan, termasuk kecekapan, apabila bekerja dengan struktur jadual hash kunci/nilai yang cekap Python, yang dipanggil pemahaman dict .

1. Mencipta Kod Jelas dan Mudah

Pemahaman membolehkan anda mencipta kamus baharu dengan mudah dan dengan cara yang mudah dibaca. Mereka menjadikan kod anda kelihatan dan berasa lebih Pythonic berbanding gelung tradisional.

2. Prestasi Lebih Baik dengan Gaya

Pemahaman bukan sahaja elegan tetapi juga cekap. Mereka selalunya berfungsi lebih cepat daripada untuk gelung kerana mereka menggunakan satu ungkapan. Python mengoptimumkan jenis kod ini, menghapuskan keperluan untuk memanggil berulang kali pembina kamus atau menggunakan kaedah kemas kini().

3. Penapisan Mudah dan Transformasi Data

Satu lagi kelebihan pemahaman kamus ialah kesederhanaannya dalam menapis dan mengubah data. Sebagai contoh, anda boleh mencipta kamus baharu daripada yang sedia ada dengan menggunakan syarat atau mengubah suai kunci atau nilai.

Adalah penting untuk memahami masa untuk menggunakan pemahaman kamus dalam Python, kerana ia boleh menjadi rumit dan sukar untuk dibaca dan ditulis dengan cepat. Sekarang, mari kita terokai beberapa kes penggunaan untuk pemahaman kamus dalam Python.

3 Contoh Bila Menggunakan Kefahaman Kamus

Pemahaman berguna dalam 3 senario berikut:

1. Apabila Mencipta kamus daripada dua senarai

{key:value for key, value in zip(list1, list2)}

2. Apabila Menapis kamus berdasarkan nilai

{k: v for k, v in original_dict.items() if v > threshold}

3. Apabila Mengubah kunci atau nilai

{k.upper(): v * 2 for k, v in original_dict.items()}

Adalah penting untuk diingat bahawa walaupun pemahaman boleh menjadikan kod anda lebih elegan dan cekap, ia juga boleh menjadi sukar untuk dibaca jika ia terlalu rumit.

Mari kita lihat beberapa perangkap yang paling biasa apabila menggunakan pemahaman kamus.

Perangkap Kefahaman Kamus

Pemahaman kamus membawa keanggunan dan kecekapan tetapi juga datang dengan cabaran. Kami akan membincangkan masalah biasa yang berkaitan dengan kebolehbacaan, kerumitan dan prestasi dengan set data yang besar.

Mengimbangi Kerumitan dan Kebolehbacaan

Pemahaman kamus yang kompleks mungkin sukar dibaca. Utamakan kebolehbacaan kod, terutamanya apabila bekerja dengan orang lain. Dalam sesetengah kes, tradisional untuk gelung mungkin lebih mudah dan lebih boleh diselenggara.

Prestasi dengan Set Data Besar

Untuk set data yang besar, pemahaman kamus mungkin tidak sentiasa optimum. Menurut Stack Overflow , pembina dict() terbina dalam boleh mengatasi pemahaman kamus dengan banyak pasangan nilai kunci kerana gelung dalam C.

Perbandingan dengan Kaedah Lain

Dalam bahagian ini, kami akan membandingkan pemahaman kamus dengan dua kaedah alternatif untuk mencipta kamus dalam Python: untuk fungsi gelung dan lambda.

Untuk Gelung

Menggunakan gelung for untuk mencipta kamus melibatkan memulakan kamus kosong dan kemudian melelang melalui pasangan nilai kunci yang sah yang dikehendaki, menambah setiap pasangan pada kamus. Ini adalah kaedah yang lebih verbose berbanding dengan pemahaman kamus.

Berikut ialah contoh mencipta kamus menggunakan gelung:

dictionary = {}
for key, value in zip(keys, values):
    dictionary[key] = value

Sebaliknya, pemahaman kamus membolehkan anda mencapai hasil yang sama dalam satu baris:

dictionary = {key: value for key, value in zip(keys, values)}

Seperti yang anda lihat, pemahaman memberikan cara yang ringkas dan lebih mudah dibaca untuk mencipta kamus dalam Python.

Fungsi Lambda

Kita juga boleh menggunakan fungsi Lambda untuk mencipta kamus. Fungsi Lambda ialah cara untuk mencipta fungsi kecil tanpa nama dalam Python. Ia boleh digunakan bersama dengan fungsi map() untuk mencipta kamus.

Mari lihat contoh fungsi Lambda untuk mencipta kamus:

keys = ['a', 'b', 'c']
values = [1, 2, 3]

key_value_pairs = map(lambda key, value: (key, value), keys, values)
dictionary = dict(key_value_pairs)

Sebagai perbandingan, berikut ialah cara kamus yang sama boleh dibuat menggunakan pemahaman:

dictionary = {key: value for key, value in zip(keys, values)}

Sekali lagi, pemahaman kamus menyediakan alternatif yang ringkas dan lebih mudah dibaca untuk mencipta kamus menggunakan fungsi lambda dan fungsi map().

Amalan Terbaik untuk Pemahaman Kamus

Apabila menggunakan pemahaman dalam Python, adalah penting untuk mengikuti amalan terbaik untuk meningkatkan kebolehbacaan, kebolehselenggaraan dan kecekapan. Berikut ialah beberapa amalan terbaik untuk dipertimbangkan:

1. Pastikan pemahaman kamus mudah

Pemahaman kamus adalah kuat, tetapi ia harus jelas dan ringkas. Jika pemahaman anda menjadi terlalu kompleks atau menjangkau berbilang baris, pertimbangkan untuk menggunakan gelung tradisional sebagai ganti. Ini membantu pemahaman kod, terutamanya untuk orang lain atau apabila melawat semula kerja anda nanti.

2. Manfaatkan fungsi terbina dalam

Python menawarkan fungsi terbina dalam seperti zip() dan enumerate() yang membantu mencipta pemahaman. Gunakan fungsi ini untuk menyelaraskan kod anda dan menjadikannya lebih mudah dibaca.

Contohnya, menggunakan zip() untuk menggabungkan dua senarai dan mencipta kamus menghasilkan kod ringkas dan bersih seperti ini:

{key: value for key, value in zip(keys, values)}

3. Gunakan pernyataan bersyarat dengan bijak

Masukkan pernyataan bersyarat dalam pemahaman anda apabila perlu, tetapi jangan gunakannya secara berlebihan. Mereka boleh membantu menapis atau mengubah suai kamus yang terhasil, tetapi terlalu banyak keadaan bersarang boleh menyebabkan kod sukar dibaca. Contoh mudah yang melibatkan pernyataan bersyarat ialah:

{x: x**2 for x in range(10) if x % 2 == 0}

4. Berhati-hati dengan pemahaman kamus bersarang

Pemahaman kamus bersarang boleh menjana kamus dengan struktur bersarang. Walau bagaimanapun, seperti pernyataan bersyarat, lebihan kamus bersarang boleh menjadikan kod lebih sukar untuk dihuraikan. Elakkan melampaui dua tahap sarang dalam pemahaman kamus bersarang anda.

Kadangkala anda mungkin perlu menggunakan pemahaman kamus bersarang di dalam gelung untuk mencapai kecekapan yang diingini.

Kata Akhir Kami

Sekarang, anda telah menguasai pemahaman kamus dalam Python. Teknik yang elegan dan cekap ini membantu mencipta kamus dengan mengulangi yang boleh diulang atau menggunakan syarat. Pemahaman menyelaraskan kod anda, meningkatkan kebolehbacaan dan kebolehselenggaraan.

Mencipta kamus baharu adalah mudah dengan pemahaman, menjimatkan masa dan usaha berbanding gelung untuk tradisional. Ia berguna dalam aplikasi dunia nyata seperti pemprosesan data, pemetaan dan transformasi.

Jika anda ingin melanjutkan pengetahuan Python anda dan menjadi profesional sebenar, untuk kursus Python kami dan lihat cara kami mencipta pengguna Python terbaik di dunia.