Corak Penghias Python yang penting untuk Kod Lebih Bersih, Lebih Cekap

Sebagai pengarang terlaris, saya menjemput anda untuk menerokai buku saya di Amazon. Jangan lupa ikuti saya di Medium dan tunjukkan sokongan anda. terima kasih! Sokongan anda bermakna dunia!

Penghias Python ialah ciri berkuasa yang membolehkan kami mengubah suai atau meningkatkan fungsi dan kelas tanpa mengubah logik terasnya. Sebagai pembangun, saya mendapati bahawa menguasai corak penghias boleh meningkatkan kualiti kod, kebolehgunaan semula dan kebolehselenggaraan dengan ketara. Mari terokai tujuh corak penghias penting yang saya dapati amat berguna dalam projek saya.

Penghias Kelas

Penghias kelas menyediakan cara untuk mengubah suai atau meningkatkan gelagat dan atribut kelas. Ia digunakan menggunakan sintaks @decorator tepat di atas definisi kelas. Saya sering menggunakan penghias kelas untuk menambah kaedah, mengubah suai kaedah sedia ada atau menukar atribut kelas.

Berikut ialah contoh penghias kelas yang menambahkan kaedah baharu pada kelas:

def add_greeting(cls):
    def say_hello(self):
        return f"Hello, I'm {self.name}"
    cls.say_hello = say_hello
    return cls

@add_greeting
class Person:
    def __init__(self, name):
        self.name = name

person = Person("Alice")
print(person.say_hello())  # Output: Hello, I'm Alice

Dalam contoh ini, penghias add_greeting menambahkan kaedah say_hello pada kelas Person. Corak ini amat berguna apabila anda ingin meluaskan fungsi merentas berbilang kelas tanpa mengubah suai kod sumbernya.

Penghias Fungsi dengan Hujah

Penghias fungsi yang menerima hujah menawarkan lebih fleksibiliti. Mereka membenarkan kami menyesuaikan tingkah laku penghias itu sendiri. Saya mendapati corak ini tidak ternilai apabila mencipta penghias boleh guna semula yang boleh diperhalusi untuk kes penggunaan yang berbeza.

Berikut ialah contoh penghias yang boleh mengulangi panggilan fungsi beberapa kali tertentu:

def repeat(times):
    def decorator(func):
        def wrapper(*args, **kwargs):
            for _ in range(times):
                result = func(*args, **kwargs)
            return result
        return wrapper
    return decorator

@repeat(times=3)
def greet(name):
    print(f"Hello, {name}!")

greet("Bob")
# Output:
# Hello, Bob!
# Hello, Bob!
# Hello, Bob!

Dalam contoh ini, penghias ulangan mengambil masa hujah yang menentukan berapa kali fungsi yang dihias harus dipanggil. Corak ini membolehkan fleksibiliti yang hebat dalam cara kami menggunakan penghias pada fungsi kami.

Memelihara Metadata Fungsi

Apabila menggunakan penghias, penting untuk mengekalkan metadata fungsi asal. Ini termasuk nama fungsi, docstring dan atribut lain. Penghias functools.wraps daripada pustaka standard Python membantu kami mencapai matlamat ini.

Ini contohnya:

from functools import wraps

def my_decorator(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        """This is the wrapper function"""
        print("Something is happening before the function is called.")
        result = func(*args, **kwargs)
        print("Something is happening after the function is called.")
        return result
    return wrapper

@my_decorator
def say_hello(name):
    """This function greets someone"""
    print(f"Hello, {name}!")

say_hello("Charlie")
print(say_hello.__name__)  # Output: say_hello
print(say_hello.__doc__)   # Output: This function greets someone

Dengan menggunakan @wraps(func), kami memastikan fungsi pembalut mengambil metadata fungsi asal. Ini penting untuk nyahpepijat dan introspeksi.

Menyusun Berbilang Penghias

Penghias boleh disusun, membolehkan berbilang penghias digunakan pada satu fungsi. Susunan hiasan adalah penting, dengan penghias digunakan dari bawah ke atas.

Ini contohnya:

def decorator1(func):
    def wrapper(*args, **kwargs):
        print("Decorator 1")
        return func(*args, **kwargs)
    return wrapper

def decorator2(func):
    def wrapper(*args, **kwargs):
        print("Decorator 2")
        return func(*args, **kwargs)
    return wrapper

@decorator1
@decorator2
def greet(name):
    print(f"Hello, {name}!")

greet("David")
# Output:
# Decorator 1
# Decorator 2
# Hello, David!

Dalam contoh ini, penghias2 digunakan dahulu, diikuti oleh penghias1. Memahami susunan pelaksanaan adalah penting apabila bekerja dengan berbilang penghias.

Penghias Hafalan

Memoisasi ialah teknik pengoptimuman yang menyimpan hasil panggilan fungsi yang mahal dan mengembalikan hasil cache apabila input yang sama berlaku lagi. Saya mendapati penghias hafalan amat berguna untuk meningkatkan prestasi fungsi atau fungsi rekursif dengan pengiraan yang mahal.

Berikut ialah contoh penghias hafalan:

def add_greeting(cls):
    def say_hello(self):
        return f"Hello, I'm {self.name}"
    cls.say_hello = say_hello
    return cls

@add_greeting
class Person:
    def __init__(self, name):
        self.name = name

person = Person("Alice")
print(person.say_hello())  # Output: Hello, I'm Alice

Penghias hafalan ini menyimpan cache hasil fungsi fibonacci, meningkatkan prestasinya secara mendadak untuk input yang besar.

Penghias Masa dan Pembalakan

Penghias untuk pelaksanaan fungsi pemasaan dan panggilan fungsi pengelogan amat berguna untuk analisis prestasi dan penyahpepijatan. Saya kerap menggunakan ini dalam proses pembangunan saya.

Berikut ialah contoh penghias pemasaan dan pembalakan gabungan:

def repeat(times):
    def decorator(func):
        def wrapper(*args, **kwargs):
            for _ in range(times):
                result = func(*args, **kwargs)
            return result
        return wrapper
    return decorator

@repeat(times=3)
def greet(name):
    print(f"Hello, {name}!")

greet("Bob")
# Output:
# Hello, Bob!
# Hello, Bob!
# Hello, Bob!

Penghias ini log apabila fungsi dipanggil dan tempoh masa yang diperlukan untuk dilaksanakan. Ia adalah corak yang saya dapati tidak ternilai untuk mengenal pasti kesesakan prestasi dalam kod saya.

Penghias Pengurus Konteks

Pengurus konteks biasanya digunakan dengan pernyataan dengan untuk pengurusan sumber dan pengendalian ralat. Kami boleh mencipta penghias yang menukar fungsi menjadi pengurus konteks, membolehkan persediaan yang elegan dan operasi teardown.

Ini contohnya:

from functools import wraps

def my_decorator(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        """This is the wrapper function"""
        print("Something is happening before the function is called.")
        result = func(*args, **kwargs)
        print("Something is happening after the function is called.")
        return result
    return wrapper

@my_decorator
def say_hello(name):
    """This function greets someone"""
    print(f"Hello, {name}!")

say_hello("Charlie")
print(say_hello.__name__)  # Output: say_hello
print(say_hello.__doc__)   # Output: This function greets someone

Dalam contoh ini, penghias file_manager memastikan fail ditutup dengan betul selepas operasi, walaupun pengecualian berlaku.

Amalan Terbaik untuk Mencipta dan Menggunakan Penghias

Apabila bekerja dengan penghias, saya telah mempelajari beberapa amalan terbaik yang telah memberi manfaat kepada saya:

1. Gunakan functools.wraps untuk mengekalkan metadata fungsi.
2. Pastikan penghias ringkas dan fokus pada satu tanggungjawab.
3. Gunakan kilang penghias apabila anda perlu menyampaikan hujah kepada penghias anda.
4. Berhati-hati dengan kesan prestasi penghias anda, terutamanya untuk majlis yang sering dipanggil.
5. Dokumenkan penghias anda dengan jelas, terangkan perkara yang mereka lakukan dan sebarang kesan sampingan yang mungkin ada.
6. Apabila menyahpepijat, ingat bahawa penghias menambah lapisan tidak arah. Alat seperti sintaks @ dalam penyahpepijat Python boleh membantu anda melangkah ke dalam fungsi yang dihias.

Menguji kod berhias kadangkala boleh menjadi rumit. Satu pendekatan yang sering saya gunakan ialah menguji penghias secara berasingan daripada fungsi yang dihias. Ini membolehkan ujian yang lebih terperinci dan penyahpepijatan yang lebih mudah.

Berikut ialah contoh cara anda boleh menguji penghias:

def decorator1(func):
    def wrapper(*args, **kwargs):
        print("Decorator 1")
        return func(*args, **kwargs)
    return wrapper

def decorator2(func):
    def wrapper(*args, **kwargs):
        print("Decorator 2")
        return func(*args, **kwargs)
    return wrapper

@decorator1
@decorator2
def greet(name):
    print(f"Hello, {name}!")

greet("David")
# Output:
# Decorator 1
# Decorator 2
# Hello, David!

Dalam ujian ini, kami menggunakan fungsi olok-olok untuk mengesahkan bahawa penghias kami memanggil fungsi asal dengan betul dan mengembalikan hasilnya.

Penghias ialah alat yang berkuasa dalam Python dan menguasai corak ini boleh meningkatkan senjata pengekodan anda dengan ketara. Ia membenarkan pengasingan yang bersih dari kebimbangan, menggalakkan penggunaan semula kod dan boleh menjadikan kod anda lebih mudah dibaca dan diselenggara.

Saya telah mendapati bahawa kunci untuk menggunakan penghias dengan berkesan ialah bermula dengan mudah dan secara beransur-ansur membina kerumitan mengikut keperluan. Mulakan dengan penghias fungsi asas, kemudian beralih kepada penghias kelas dan corak yang lebih maju seperti kilang penghias.

Ingat, walaupun penghias boleh menambah baik kod anda, mereka harus digunakan dengan bijak. Penggunaan penghias yang berlebihan boleh menyebabkan kod yang sukar difahami dan nyahpepijat. Sentiasa pertimbangkan sama ada penghias ialah penyelesaian terbaik untuk kes penggunaan khusus anda.

Sambil anda terus bekerja dengan penghias, anda mungkin akan menemui corak dan kes penggunaan baharu. Komuniti Python sentiasa berinovasi, dan teknik penghias baharu muncul dengan kerap. Kekal ingin tahu, bereksperimen dengan pendekatan yang berbeza dan jangan teragak-agak untuk mencipta corak penghias anda sendiri untuk menyelesaikan masalah unik dalam projek anda.

Penghias hanyalah satu daripada banyak ciri berkuasa dalam Python yang boleh membantu anda menulis kod yang lebih bersih dan cekap. Apabila anda menjadi lebih selesa dengan penghias, anda akan mendapati bahawa mereka berintegrasi dengan baik dengan ciri Python lain seperti penjana, pengurus konteks dan kelas meta, membuka lebih banyak kemungkinan untuk reka bentuk kod yang elegan dan berkuasa.

---

101 Buku

101 Buku ialah syarikat penerbitan dipacu AI yang diasaskan bersama oleh pengarang Aarav Joshi. Dengan memanfaatkan teknologi AI termaju, kami memastikan kos penerbitan kami sangat rendah—sesetengah buku berharga serendah $4—menjadikan pengetahuan berkualiti boleh diakses oleh semua orang.

Lihat buku kami Kod Bersih Golang tersedia di Amazon.

Nantikan kemas kini dan berita menarik. Apabila membeli-belah untuk buku, cari Aarav Joshi untuk mencari lebih banyak tajuk kami. Gunakan pautan yang disediakan untuk menikmati diskaun istimewa!

Ciptaan Kami

Pastikan anda melihat ciptaan kami:

Pusat Pelabur | Pelabur Central Spanish | Pelabur Jerman Tengah | Hidup Pintar | Epos & Gema | Misteri Membingungkan | Hindutva | Pembangunan Elit | Sekolah JS

---

Kami berada di Medium

Tech Koala Insights | Dunia Epok & Gema | Medium Pusat Pelabur | Medium Misteri Membingungkan | Sains & Zaman Sederhana | Hindutva Moden

Atas ialah kandungan terperinci Corak Penghias Python yang penting untuk Kod Lebih Bersih, Lebih Cekap. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!