Bagaimana Membina Sistem Plugin Mudah Untuk Aplikasi Python?

Tentukan antara muka plug-in, gunakan kelas asas abstrak atau fungsi konvensyen; 2. Buat direktori plugin untuk menyimpan modul pemalam; 3. Tulis kelas plug-in atau fungsi yang sepadan dengan antara muka; 4. Gunakan importlib untuk mengimport dan menemui pemalam secara dinamik; 5. Intantiate plug-in dan panggil kaedahnya untuk dilaksanakan; 6. PKGUTIL pilihan untuk mencapai penemuan automatik yang lebih mantap; 7. Ia boleh dipermudahkan ke mod pemalam berasaskan fungsi untuk mengurangkan kerumitan, dan akhirnya melaksanakan sistem pemalam yang fleksibel dan boleh diperluas.

Membina sistem plugin yang mudah di Python boleh menjadikan aplikasi anda boleh dilanjutkan dan modular. Idea ini adalah untuk membolehkan kod luaran (plugin) dimuatkan secara dinamik pada masa runtime, tanpa mengubahsuai aplikasi teras. Berikut adalah cara anda boleh menyediakan sistem plugin asas tetapi berkesan.

1. Tentukan antara muka plugin

Mulakan dengan menentukan bagaimana plugin harus berkelakuan. Cara paling mudah ialah menggunakan kelas asas atau hanya bergantung pada konvensyen penamaan dan fungsi yang diharapkan.

 # plugin_interface.py
Dari ABC Import ABC, AbstrakMethod

Plugin Kelas (ABC):
    @AbstractMethod
    nama def (diri):
        lulus

    @AbstractMethod
    def melaksanakan (diri, data):
        lulus

Sebagai alternatif, untuk pendekatan yang lebih ringan, melangkau kelas asas dan hanya mengharapkan plugin untuk menentukan fungsi run() atau serupa.

2. Buat struktur direktori plugin

Susun projek anda seperti ini:

 myApp/
├── Main.py
├── Plugin_interface.py
└── Plugin/
    ├── __init__.py
    ├── hello_plugin.py
    └── calc_plugin.py

Setiap fail dalam plugins/ direktori akan menjadi modul plugin berasingan.

3. Tulis plugin sampel

Berikut adalah contoh plugin menggunakan kelas asas:

 # plugin/hello_plugin.py
dari plugin import plugin_interface

kelas helleplugin (plugin):
    nama def (diri):
        Kembalikan "Hello plugin"

    def melaksanakan (diri, data):
        Kembali f "Hello, {data}!"

Dan yang lain:

 # plugin/calc_plugin.py
dari plugin import plugin_interface

Kelas Calcplugin (Plugin):
    nama def (diri):
        Kembali "Plugin Kalkulator"

    def melaksanakan (diri, data):
        Pulangan data * 2

4. Plugin beban secara dinamik

Gunakan importlib Python untuk menemui dan memuatkan plugin dari direktori plugins .

 # main.py
Import OS
import importlib
dari plugin import plugin_interface

def load_plugins (plugin_folder = "plugin"):
    plugin = []
    # Dapatkan semua .py fail dalam folder plugin
    Untuk nama fail dalam os.listdir (plugin_folder):
        jika fileName.endswith (". py") dan nama fail! = "__init__.py":
            module_name = f "{plugin_folder}. {filename [:-3]}"
            modul = importlib.import_module (module_name)

            # Cari kelas yang mewarisi dari plugin
            untuk attr_name dalam dir (modul):
                attr = getAttr (modul, attr_name)
                jika (
                    isInstance (ATTR, jenis)
                    dan IssubClass (ATTR, plugin)
                    dan attr! = plugin
                ):
                    plugin.append (attr ())
    Plugin kembali

5. Gunakan plugin

Sekarang anda boleh memuatkan dan menjalankannya:

 # main.py (diteruskan)
def utama ():
    plugin = LOAD_PLUGINS ()
    data = "dunia"

    untuk plugin dalam plugin:
        hasil = plugin.execute (data)
        cetak (f "[{plugin.name ()}] hasil: {result}")

jika __name__ == "__main__":
    utama ()

Output:

 [Hello plugin] Hasil: Hello, dunia!
[Plugin Kalkulator] Hasil: Dunia Dunia

6. (Pilihan) Penemuan automatik tanpa laluan hardcoding

Untuk menjadikannya lebih mantap, anda boleh menggunakan pkgutil atau importlib.util untuk melelehkan modul dalam pakej.

 # Loader alternatif menggunakan pkgutil
import pkgutil
import plugin

def load_plugins_pkgutil ():
    plugins_list = []
    untuk pengimport, nama modname, ISPKG dalam pkgutil.iter_modules (plugin .__ Path__, "plugin."):
        modul = importlib.import_module (ModName)
        untuk attr_name dalam dir (modul):
            attr = getAttr (modul, attr_name)
            Jika isInstance (attr, type) dan issubclass (attr, plugin) dan attr! = plugin:
                plugins_list.append (attr ())
    Kembali plugins_list

7. Jadikan lebih mudah (plugin berasaskan fungsi)

Sekiranya anda tidak memerlukan kelas, tentukan fungsi register() atau mengharapkan fungsi run() dalam setiap plugin:

 # plugin/simple_plugin.py
Def Run (Data):
    kembali f "diproses: {data.upper ()}"

Kemudian muatkan dan hubungi:

 # Dalam main.py
modul = importlib.import_module ("plugins.simple_plugin")
Jika Hasattr (modul, "Run"):
    hasil = modul.run ("hello")

Ini mengelakkan warisan dan lebih mudah bagi pengguna untuk menulis plugin.

Nota akhir

• Pastikan API plugin mudah dan didokumentasikan dengan baik.
• Pertimbangkan pemeriksaan versi atau keserasian untuk aplikasi yang lebih besar.
• Anda boleh melanjutkan ini dengan metadata plugin (misalnya, melalui __plugin_name__ , __version__ pembolehubah).
• Gunakan titik kemasukan dengan setuptools untuk kes-kes yang lebih maju (seperti dalam alat dunia nyata seperti pytest atau flake8 ).

Tetapi untuk aplikasi yang paling kecil dan sederhana, pendekatan di atas adalah bersih, boleh dibaca, dan mudah dijaga.

Pada asasnya, hanya: Tentukan kontrak, letakkan plugin dalam folder, auto-import mereka, dan lari. Bukan sihir -hanya python yang fleksibel.

Atas ialah kandungan terperinci Bagaimana Membina Sistem Plugin Mudah Untuk Aplikasi Python?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!