ommon Refactors dalam Python untuk Pemula

Pemfaktoran semula membantu menjadikan kod anda lebih bersih dan cekap. Berikut ialah lima refactor biasa untuk pemula dalam Python.

Saya. Memudahkan Ungkapan Boolean

Corak biasa menggunakan blok if-else hanya untuk mengembalikan Benar atau Salah. Contohnya:

if condition:
    return True
else:
    return False

Faktor semula kepada:

return condition

Keadaan itu sendiri sudah pun merupakan ungkapan Boolean, jadi blok if-else tidak diperlukan. Dengan mengembalikan syarat secara terus, kod menjadi lebih pendek dan lebih mudah dibaca. Ini ialah cara yang mudah tetapi berkesan untuk meningkatkan kejelasan tanpa mengubah fungsi.

II. Senaraikan Pemahaman Daripada untuk / jika

Pemula sering menggunakan untuk gelung dengan pernyataan if untuk membina senarai. Contohnya:

result = []
for item in items:
    if condition(item):
        result.append(item)

Faktor semula kepada pemahaman senarai:

result = [item for item in items if condition(item)]

Pemahaman senarai menyediakan cara yang lebih ringkas untuk membina senarai. Ia juga biasanya lebih pantas daripada yang setara untuk gelung kerana ia dioptimumkan secara dalaman oleh Python. Pendekatan ini juga lebih mudah dibaca, terutamanya untuk tugas penciptaan senarai yang mudah.

III. Elakkan Pengiraan Berulang

Jika anda memanggil fungsi yang sama beberapa kali dalam gelung, simpan hasilnya dalam pembolehubah. Contohnya:

for item in items:
    if len(item) > 5:
        result.append(item)
...

Faktor semula kepada:

for item in items:
    len = len(item)
    if len > 5:
        result.append(item)
...

Bayangkan jika keadaan ini disimpan dalam beberapa elif atau pernyataan if bersarang. Di sini, len(item) dipanggil dua kali untuk setiap lelaran, yang boleh menjadi tidak cekap, terutamanya untuk senarai besar. Menyimpan hasil len(item) dalam pembolehubah (len) menghapuskan pengiraan berulang, meningkatkan prestasi dan menjadikan kod lebih bersih. Ini adalah contoh asas.

IV. Gantikan Gelung dengan peta dan penapis

Daripada menulis gelung eksplisit, gunakan fungsi terbina dalam Python seperti map() dan penapis(), yang boleh menjadi lebih cekap dan ringkas. Contohnya, untuk menggandakan setiap item dalam senarai:

result = []
for item in items:
    result.append(item * 2)

Faktor semula kepada:

result = list(map(lambda x: x * 2, items))

Atau untuk menapis item yang lebih besar daripada 5:

result = []
for item in items:
    if item > 5:
        result.append(item)

Faktor semula kepada:

result = list(filter(lambda x: x > 5, items))

Kedua-dua map() dan filter() mengambil fungsi sebagai argumen, jadi kita boleh menggunakan lambda untuk mentakrifkan fungsi kecil tanpa nama. Fungsi lambda ialah cara ringkas untuk mentakrifkan operasi mudah. Sebagai contoh, lambda x: x * 2 mencipta fungsi yang mendarabkan x dengan 2. Faedah map() dan penapis() ialah ia selalunya lebih cekap daripada menggunakan gelung for dan biasanya lebih mudah dibaca. Seseorang juga boleh menggunakan pemahaman senarai (lihat di atas).

V Gabungkan Berbilang jika Pernyataan

Apabila menyemak berbilang syarat, menggabungkannya dengan operator logik (dan, atau) boleh memudahkan kod anda. Contohnya:

if a > 0:
    if b > 0:
        result = a + b

Faktor semula kepada:

if condition:
    return True
else:
    return False

Ini mengurangkan sarang yang tidak perlu dan menjadikan kod lebih mudah dibaca dan diselenggara. Menggabungkan keadaan menjadi satu pernyataan if menjadikan aliran logik lebih jelas dan menghapuskan lebihan.

Kesimpulan

Pemfaktoran semula ialah tentang menjadikan kod anda lebih pendek, jelas dan lebih cekap tanpa mengubah fungsinya. Dengan memudahkan ungkapan Boolean, menggunakan pemahaman senarai, mengelakkan pengiraan berulang, memanfaatkan fungsi terbina dalam seperti map() dan penapis(), dan keadaan penggabungan, anda boleh menjadikan kod anda KERING. Menggunakan lambda membolehkan anda menentukan fungsi kecil dalam satu baris, memastikan kod itu kemas dan pantas. Amalan ini bukan sahaja meningkatkan prestasi tetapi juga meningkatkan kebolehbacaan, yang penting untuk mengekalkan kod dalam jangka masa panjang.

Bacaan lanjut:

https://www.w3schools.com/python/python_lambda.asp

https://www.w3schools.com/python/ref_func_filter.asp

https://www.w3schools.com/python/ref_func_map.asp

Atas ialah kandungan terperinci ommon Refactors dalam Python untuk Pemula. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!