Amalan Terbaik Python: Menulis Kod Bersih, Cekap dan Boleh Diselenggara

Python ialah salah satu bahasa pengaturcaraan yang paling popular kerana kesederhanaan, kebolehbacaan dan serba boleh.

Sama ada anda pembangun berpengalaman atau pemula, mengikuti amalan terbaik dalam Python adalah penting untuk menulis kod yang bersih, cekap dan boleh diselenggara.

Dalam catatan blog ini, kami akan meneroka beberapa amalan terbaik utama yang perlu diingat semasa menulis kod Python.

1 - Patuhi Garis Panduan PEP 8

PEP 8 ialah panduan gaya untuk kod Python, menyediakan konvensyen untuk memformat dan menstruktur kod anda.

Beberapa perkara penting daripada PEP 8 termasuk:

• Lekukan: Gunakan 4 ruang setiap tahap lekukan.
• Panjang Baris: Hadkan semua baris kepada maksimum 79 aksara.
• Barisan Kosong: Asingkan fungsi peringkat atas dan definisi kelas dengan dua baris kosong dan definisi kaedah di dalam kelas dengan satu baris kosong.
• Import: Letakkan import di bahagian atas fail, dikumpulkan dalam susunan berikut: import perpustakaan standard, import pihak ketiga yang berkaitan dan import khusus aplikasi/pustaka tempatan.

Mematuhi PEP 8 menjadikan kod anda lebih mudah dibaca dan konsisten dengan pangkalan kod Python yang lain.

2 - Tulis Nama Pembolehubah Deskriptif dan Ringkas

Pilih nama pembolehubah yang bersifat deskriptif lagi padat.

Elakkan pembolehubah satu huruf kecuali dalam kes seperti pembilang gelung.
Contohnya:

# Bad
a = 10

# Good
number_of_users = 10

Nama pembolehubah deskriptif menjadikan kod anda jelas, mengurangkan keperluan untuk ulasan yang meluas dan memudahkan orang lain (dan diri masa depan anda) untuk memahami.

3 - Gunakan Pemahaman Senarai dan Ungkapan Penjana

Kefahaman senarai dan ungkapan penjana menyediakan cara ringkas untuk membuat senarai dan penjana.

Ia lebih mudah dibaca dan selalunya lebih pantas daripada menggunakan gelung.

# List comprehension
squares = [x**2 for x in range(10)]

# Generator expression
squares_gen = (x**2 for x in range(10))

Kefahaman senarai adalah yang terbaik apabila senarai yang terhasil cukup kecil untuk dimuatkan dalam ingatan.

Gunakan ungkapan penjana untuk set data yang lebih besar untuk menjimatkan memori.

4 - Manfaatkan Fungsi dan Perpustakaan Terbina Dalam Python

Pustaka standard Python adalah luas, dan selalunya lebih baik menggunakan fungsi terbina dalam daripada menulis kod tersuai.

Sebagai contoh, daripada menulis fungsi anda sendiri untuk mencari maksimum senarai, gunakan fungsi max() terbina dalam Python.

# Bad
def find_max(lst):
    max_val = lst[0]
    for num in lst:
        if num > max_val:
            max_val = num
    return max_val

# Good
max_val = max(lst)

Menggunakan fungsi dan perpustakaan terbina dalam boleh menjimatkan masa dan mengurangkan kemungkinan ralat.

5 - Ikuti Prinsip KERING (Jangan Ulangi Sendiri)

Elakkan pendua kod.

Jika anda mendapati diri anda menulis kod yang sama lebih daripada sekali, pertimbangkan untuk memfaktorkannya semula ke dalam fungsi atau kelas.

Ini bukan sahaja mengurangkan saiz pangkalan kod anda tetapi juga memudahkan penyelenggaraan.

# Bad
def print_user_details(name, age):
    print(f"Name: {name}")
    print(f"Age: {age}")

def print_product_details(product, price):
    print(f"Product: {product}")
    print(f"Price: {price}")

# Good
def print_details(label, value):
    print(f"{label}: {value}")

Prinsip DRY membawa kepada kod yang lebih modular dan boleh digunakan semula.

6 - Gunakan Persekitaran Maya

Apabila bekerja pada projek Python, terutamanya dengan kebergantungan, sebaiknya gunakan persekitaran maya.

Persekitaran maya membolehkan anda mengurus kebergantungan berdasarkan setiap projek, mengelakkan konflik antara pakej yang digunakan dalam projek yang berbeza.

# 
Create a virtual environment
python -m venv myenv

# Activate the virtual environment
source myenv/bin/activate  # On Windows: myenv\Scripts\activate

# Install dependencies
pip install -r requirements.txt

Menggunakan persekitaran maya memastikan kebergantungan projek anda diasingkan dan mudah dihasilkan semula.

7 - Tulis Ujian Unit

Ujian penulisan adalah penting untuk memastikan kod anda berfungsi seperti yang diharapkan dan untuk mencegah regresi apabila anda membuat perubahan.

Modul ujian unit Python ialah titik permulaan yang bagus untuk ujian menulis.

import unittest

def add(a, b):
    return a + b

class TestMathFunctions(unittest.TestCase):
    def test_add(self):
        self.assertEqual(add(2, 3), 5)
        self.assertEqual(add(-1, 1), 0)

if __name__ == '__main__':
    unittest.main()

Menjalankan ujian secara kerap semasa anda membangunkan memastikan kod anda kekal teguh dan bebas pepijat.

8 - Gunakan Komen dan Dokumen Bermakna

Walaupun kod bersih seharusnya menjelaskan sendiri, ulasan dan dokstring masih penting untuk menerangkan logik, andaian dan keputusan yang kompleks.

Gunakan ulasan dengan berhati-hati dan fokus pada sebab anda melakukan sesuatu dan bukannya apa yang anda lakukan.

def calculate_discount(price, discount):
    """
    Calculate the price after applying the discount.

    Args:
    price (float): Original price
    discount (float): Discount percentage (0-100)

    Returns:
    float: Final price after discount
    """
    return price * (1 - discount / 100)

Komen dan docstring yang baik meningkatkan kebolehselenggaraan dan kebolehgunaan kod anda.

9 - Tangani Pengecualian dengan Anggun

Python menyediakan ciri pengendalian pengecualian yang berkuasa yang harus digunakan untuk mengurus ralat dengan anggun.

Daripada membiarkan program anda ranap, gunakan blok try and except untuk menangani kemungkinan ralat.

try:
    with open('data.txt', 'r') as file:
        data = file.read()
except FileNotFoundError:
    print("File not found. Please check the file path.")
except Exception as e:
    print(f"An unexpected error occurred: {e}")

Mengendalikan pengecualian dengan betul memastikan program anda boleh mengendalikan situasi yang tidak dijangka tanpa ranap.

10 - Pastikan Kod Anda Bermodul

Kod modular lebih mudah difahami, diuji dan diselenggara.

Pecahkan kod anda kepada fungsi dan kelas yang lebih kecil dan boleh digunakan semula.

Each function or class should have a single responsibility.

# Bad
def process_data(data):
    # Load data
    # Clean data
    # Analyze data
    # Save results

# Good
def load_data(path):
    pass

def clean_data(data):
    pass

def analyze_data(data):
    pass

def save_results(results):
    pass

Modularity enhances code clarity and reusability, making it easier to debug and extend.

Conclusion

By following these Python best practices, you can write code that is clean, efficient, and maintainable.

Whether you’re writing a small script or developing a large application, these principles will help you create better, more professional Python code.

Remember, coding is not just about making things work; it’s about making them work well, now and in the future.

Atas ialah kandungan terperinci Amalan Terbaik Python: Menulis Kod Bersih, Cekap dan Boleh Diselenggara. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!