Teknik Berkuasa untuk Menulis Kod Python yang Cekap dan Boleh Dibaca

Python terkenal dengan kesederhanaan dan serba boleh, tetapi pembangun berpengalaman pun mendapat manfaat daripada mengamalkan amalan terbaik yang memaksimumkan prestasi dan kebolehbacaan. Dengan peningkatan sains data, pembelajaran mesin dan pembangunan web dalam Python, menguasai teknik kod yang cekap telah menjadi satu kemestian untuk kekal berdaya saing dalam landskap teknologi yang bergerak pantas hari ini. Di sini, kami akan menyelami 20 teknik berkesan untuk meningkatkan prestasi dan kebolehbacaan kod Python anda, sama ada anda sedang mengusahakan projek yang kompleks atau skrip automasi pantas.

1. Gunakan Penjana untuk Menjimatkan Memori

Penjana sesuai untuk memproses set data yang besar tanpa menggunakan memori yang berlebihan. Mereka menghasilkan data satu bahagian pada satu masa, bukannya menyimpan segala-galanya dalam ingatan. Sebagai contoh, anda boleh membaca fail log besar baris demi baris dengan penjana.

def read_large_file(file_path):
    with open(file_path, 'r') as file:
        for line in file:
            yield line.strip()

Pendekatan ini amat berguna untuk tugasan seperti pemprosesan data atau latihan kelompok, di mana bekerja dengan ingatan terhad adalah penting.

2. Tetapkan Nilai Lalai dengan .setdefault()

Dalam kes di mana anda perlu memulakan kunci dalam kamus dengan nilai lalai, .setdefault() menyelamatkan anda daripada semakan manual.

inventory = {"jeans": 500, "top": 600}
inventory.setdefault("shoes", 0)
print(inventory)

Ini menjadikan pengurusan nilai lalai lebih ringkas dan menghilangkan keperluan untuk pernyataan-jika tambahan.

3. Gantikan Rantai if-elif dengan Kamus

Menggunakan kamus untuk memetakan fungsi dan bukannya rantai if-elif yang panjang menjadikan kod lebih bersih dan lebih mudah diselenggara.

def start(): print("Start")
def stop(): print("Stop")
actions = {"start": start, "stop": stop}
action = "start"
actions.get(action, lambda: print("Invalid"))()

Struktur ini meningkatkan kebolehbacaan dan prestasi, terutamanya dalam pokok keputusan yang besar.

4. Permudahkan Pengiraan dengan Pembilang

Kelas Kaunter daripada modul koleksi ialah cara terbaik untuk memudahkan pengiraan tugas dalam Python, seperti analisis kekerapan.

from collections import Counter
words = ["apple", "banana", "apple", "orange", "banana"]
counts = Counter(words)
print(counts)

Ia menghapuskan keperluan untuk mencipta fungsi pengiraan tersuai dan kedua-duanya cekap dan mudah digunakan.

5. Optimumkan Rekursi dengan Memoisasi

Memoisasi menyimpan hasil panggilan fungsi yang mahal, yang amat berguna dalam algoritma rekursif seperti pengiraan Fibonacci.

from functools import lru_cache

@lru_cache(maxsize=1000)
def fibonacci(n):
    if n < 2:
        return n
    return fibonacci(n - 1) + fibonacci(n - 2)

Pendekatan ini mengurangkan kerumitan masa dengan kos memori tambahan yang minimum.

6. Tambah Fleksibiliti dengan Penghias

Penghias Python berguna untuk menggunakan fungsi boleh guna semula pada berbilang fungsi, seperti pengelogan atau pemasaan tanpa mengubah suai logik teras.

import time

def timer(func):
    def wrapper(*args, **kwargs):
        start_time = time.time()
        result = func(*args, **kwargs)
        print(f"{func.__name__} took {time.time() - start_time:.6f} seconds")
        return result
    return wrapper

@timer
def slow_function():
    time.sleep(1)

slow_function()

7. Jadikan Model Data Jelas dengan kelas data

Kelas data Python menjadikan penentuan model data ringkas lebih mudah dan lebih mudah dibaca dengan menjana kaedah init, repr dan perbandingan secara automatik.

def read_large_file(file_path):
    with open(file_path, 'r') as file:
        for line in file:
            yield line.strip()

Ini membantu mengurangkan kod boilerplate dan memastikan struktur data anda bersih dan boleh diselenggara.

8. Keadaan Struktur dengan padanan

Dengan Python 3.10, padanan corak struktur membolehkan anda memadankan struktur data yang kompleks tanpa penyataan if-else verbose.

inventory = {"jeans": 500, "top": 600}
inventory.setdefault("shoes", 0)
print(inventory)

9. Gantikan Chained dan dengan semua()

Untuk mengesahkan berbilang syarat serentak, gunakan all() untuk memastikan kod ringkas dan boleh dibaca.

def start(): print("Start")
def stop(): print("Stop")
actions = {"start": start, "stop": stop}
action = "start"
actions.get(action, lambda: print("Invalid"))()

10. Gunakan Pemahaman Senarai

Senaraikan pemahaman menjadikan gelung ringkas dan ekspresif, terutamanya untuk transformasi mudah.

from collections import Counter
words = ["apple", "banana", "apple", "orange", "banana"]
counts = Counter(words)
print(counts)

Ia lebih cekap dan lebih mudah dibaca berbanding gelung tradisional.

11. Fahami dan Gunakan Ungkapan Penjana

Untuk kes di mana anda tidak memerlukan senarai, gunakan ungkapan penjana untuk kecekapan ingatan yang lebih baik.

from functools import lru_cache

@lru_cache(maxsize=1000)
def fibonacci(n):
    if n < 2:
        return n
    return fibonacci(n - 1) + fibonacci(n - 2)

Ekspresi penjana mengurangkan penggunaan memori dengan menghasilkan nilai atas permintaan.

12. Cuba zip() untuk Lelaran Selari

Fungsi zip() memudahkan untuk mengulangi berbilang senarai secara selari.

import time

def timer(func):
    def wrapper(*args, **kwargs):
        start_time = time.time()
        result = func(*args, **kwargs)
        print(f"{func.__name__} took {time.time() - start_time:.6f} seconds")
        return result
    return wrapper

@timer
def slow_function():
    time.sleep(1)

slow_function()

13. Kendalikan Fail dengan Selamat dengan Penyata

Pernyataan dengan memastikan fail ditutup dengan betul selepas suitenya selesai, menjadikannya sesuai untuk pengendalian fail.

from dataclasses import dataclass

@dataclass
class Employee:
    name: str
    id: int
    salary: float

e = Employee("Alice", 1, 50000)
print(e)

Ini memudahkan pengurusan sumber dan meminimumkan potensi ralat.

14. Tambah Keselamatan dengan Petua Jenis

Petua taip menjadikan kod anda lebih mudah dibaca dan membantu IDE mengesan kemungkinan ralat sebelum masa jalan.

def describe_point(point):
    match point:
        case (0, 0):
            return "Origin"
        case (0, y):
            return f"On Y-axis at {y}"
        case (x, 0):
            return f"On X-axis at {x}"
        case (x, y):
            return f"Point at ({x}, {y})"

Petua jenis meningkatkan kebolehselenggaraan, terutamanya dalam pangkalan kod yang besar.

15. Permudahkan dengan mana-mana() untuk atau Syarat

Untuk menyemak sama ada mana-mana syarat dalam senarai adalah benar, any() adalah lebih ringkas daripada berantai atau syarat.

fields = ["name", "email", "age"]
data = {"name": "Alice", "email": "alice@example.com", "age": 25}
if all(field in data for field in fields):
    print("All fields are present")

16. Manfaatkan percubaan-kecuali-lain-akhirnya

Struktur ini membolehkan pengendalian ralat yang lebih bersih, dengan yang lain dan akhirnya menambah fleksibiliti untuk mengurus senario yang berbeza.

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

17. Susun Data dengan Tuple Bernama

Tuple bernama menambah struktur pada tupel, menjadikannya lebih mudah dibaca dan mendokumentasikan diri.

sum_of_squares = sum(x ** 2 for x in range(1000))

18. Tingkatkan Penggabungan str dengan f-Strings

f-Strings lebih pantas dan lebih mudah dibaca daripada kaedah penggabungan tradisional, terutamanya dengan ungkapan yang kompleks.

names = ["Alice", "Bob"]
ages = [25, 30]
for name, age in zip(names, ages):
    print(f"{name} is {age} years old")

19. Gunakan itertools untuk Lelaran Cekap

Modul itertools menawarkan pilihan gelung yang cekap, seperti menjana pilih atur, gabungan atau elemen berulang.

def read_large_file(file_path):
    with open(file_path, 'r') as file:
        for line in file:
            yield line.strip()

20. Pastikan Kod Bersih dengan Pengurus Konteks

Pengurus konteks tersuai membantu mengurus sumber atau tugas pembersihan, meningkatkan kebolehbacaan dan keselamatan.

inventory = {"jeans": 500, "top": 600}
inventory.setdefault("shoes", 0)
print(inventory)

---

Dengan menyepadukan teknik ini, anda boleh menulis kod Python yang bukan sahaja lebih cekap tetapi juga lebih mudah dibaca dan diselenggara. Eksperimen dengan petua ini dan masukkannya secara beransur-ansur ke dalam amalan pengekodan harian anda.

Atas ialah kandungan terperinci Teknik Berkuasa untuk Menulis Kod Python yang Cekap dan Boleh Dibaca. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!