Prinsip pepejal adalah lima prinsip reka bentuk yang digunakan dalam pengaturcaraan berorientasikan objek untuk meningkatkan kebolehbacaan, fleksibiliti dan mengekalkan reka bentuk perisian, dan juga terpakai dalam pembangunan Python. 1. Prinsip Tanggungjawab Tunggal (SRP) memerlukan kelas untuk melakukan satu perkara, elakkan meletakkan fungsi yang tidak relevan dalam kelas yang sama, yang boleh dilaksanakan dengan memisahkan logik atau menggunakan modul tambahan; 2. Prinsip Terbuka dan Tertutup (OCP) menekankan pembukaan untuk sambungan, menutup pengubahsuaian, dan memperluaskan fungsi melalui warisan atau gabungan tanpa mengubah kod sedia ada; 3. Prinsip Penggantian Richter (LSP) memastikan subkelas boleh menggantikan kelas induk tanpa memusnahkan tingkah laku program, dan mengekalkan kontrak kaedah yang konsisten, mengelakkan memperkenalkan pengecualian atau jenis pulangan yang berlainan semasa penulisan semula; 4. Prinsip pengasingan antara muka (ISP) menganjurkan antara muka yang halus supaya pelanggan hanya bergantung kepada fungsi yang diperlukan, Python dapat dilaksanakan melalui kelas asas abstrak atau mixin; 5. Prinsip Inversion Ketergantungan (DIP) menganjurkan bahawa kedua-dua modul peringkat tinggi dan rendah bergantung pada abstraksi, dan decoupling biasanya digunakan dalam python untuk mencapai decoupling, yang mudah untuk pengujian dan pelaksanaan penggantian. Prinsip -prinsip ini membantu pemaju membina lebih jelas dan mudah untuk mengekalkan struktur sistem.

Prinsip -prinsip pepejal adalah satu set lima prinsip reka bentuk yang bertujuan untuk membuat reka bentuk perisian lebih mudah difahami, fleksibel, dan dipelihara. Mereka diperkenalkan oleh Robert C. Martin (juga dikenali sebagai Uncle Bob) dan sangat berguna dalam pengaturcaraan berorientasikan objek. Dalam pembangunan Python, menerapkan prinsip-prinsip ini membantu pemaju menulis kod yang lebih bersih, berskala, dan lebih mudah untuk dikekalkan.

Prinsip Tanggungjawab Tunggal (SRP)

Kelas sepatutnya hanya mempunyai satu sebab untuk berubah - bermakna ia harus melakukan satu perkara dan melakukannya dengan baik.

Dalam amalan, ini bermakna memecahkan logik kompleks ke dalam komponen berasingan. Sebagai contoh, jika anda menulis kelas yang mengendalikan kedua -dua pengesahan pengguna dan pembalakan, ia melanggar SRP. Sebaliknya, perpecahan tanggungjawab tersebut ke dalam dua kelas: satu untuk logik pengesahan dan satu lagi untuk tingkah laku pembalakan.

Mengapa ia penting dalam Python:
Python menggalakkan kod modular dan boleh dibaca. Menjaga kelas anda fokus membuat debugging lebih mudah dan mengurangkan kesan sampingan apabila perubahan berlaku.

• Elakkan meletakkan fungsi yang tidak berkaitan di dalam kelas yang sama.
• Jika kelas mula mengendalikan pelbagai tugas, pertimbangkan untuk memisahkannya.
• Gunakan modul penolong atau fungsi utiliti dan bukannya terlalu banyak kelas.

Prinsip Terbuka/Ditutup (OCP)

Entiti perisian (seperti kelas, modul, fungsi) harus dibuka untuk lanjutan tetapi ditutup untuk pengubahsuaian.

Ini bermakna bahawa sekali kelas bekerja dan diuji, anda tidak perlu menukar kod sumbernya setiap kali ciri baru datang. Sebaliknya, lanjutkannya melalui warisan atau komposisi.

Contoh dalam Python:
Katakan anda mempunyai kelas PaymentProcessor . Daripada mengubahnya setiap kali anda menambah kaedah pembayaran baru, buat kelas asas abstrak atau antara muka seperti PaymentMethod , kemudian melaksanakan subkelas seperti CreditCardPayment , PayPalPayment , dll.

 Kelas PaymentProcessor:
    def __init __ (diri, kaedah: pembayaranmethod):
        self.method = kaedah

    proses def (diri):
        self.method.process ()

• Gunakan polimorfisme untuk membolehkan tingkah laku yang berbeza tanpa mengubah kod sedia ada.
• Kelas asas abstrak (modul abc ) dapat membantu menguatkuasakan corak ini.
• Ini menjadikan sistem anda lebih mudah disesuaikan dengan ciri -ciri masa depan.

Prinsip Penggantian Liskov (LSP)

Objek superclass harus digantikan dengan objek subclass tanpa melanggar permohonan.

Prinsip ini memastikan bahawa kelas kanak -kanak tidak memecahkan tingkah laku yang diharapkan dari kelas induk. Di Python, kerana ia ditaip secara dinamik, prinsip ini membantu mengelakkan bug yang mengelirukan yang disebabkan oleh mengatasi yang tidak dijangka.

Apa yang perlu diperhatikan: Jika subclass membuang pengecualian atau mengembalikan jenis yang sama sekali berbeza daripada kaedah induk, ia mungkin melanggar LSP.

Sebagai contoh, jika anda mempunyai kelas Rectangle dengan kaedah set_width() dan set_height() , dan kelas Square mewarisi daripadanya tetapi mengatasi kaedah tersebut untuk menjaga lebar dan ketinggian sama, menggunakan Square di mana Rectangle dijangka dapat menyebabkan tingkah laku yang tidak dijangka.

• Memastikan kaedah yang ditindas mengekalkan kontrak yang sama.
• Jangan memaksa subkelas untuk membuang pengecualian untuk kaedah yang mereka tidak menyokong.
• Berfikir dengan teliti tentang bagaimana warisan mempengaruhi jangkaan.

Prinsip Pengasingan Antara Muka (ISP)

Pelanggan tidak boleh dipaksa bergantung pada antara muka yang mereka tidak gunakan.

Daripada mempunyai satu antara muka yang besar dengan banyak kaedah, tentukan yang lebih kecil, lebih spesifik supaya kelas hanya perlu melaksanakan apa yang sebenarnya mereka gunakan.

Bagaimana ia berlaku di Python:
Oleh kerana Python tidak mempunyai antara muka per se (tetapi mempunyai kelas asas abstrak), anda masih boleh mengikuti ISP dengan membuat kelas asas kecil atau fokus.

Sebagai contoh, bukannya mempunyai antara muka Worker dengan work() , eat() , dan rest() , memisahkannya menjadi Workable , Eatable , dan Restable . Kemudian, robot boleh melaksanakan hanya Workable , sementara manusia melaksanakan ketiga -tiga.

• Berpecah kelas abstrak yang besar ke dalam yang lebih kecil.
• Mixins boleh digunakan dengan berkesan untuk menggabungkan fungsi.
• Membantu mencegah pelaksanaan yang tidak perlu dan mengekalkan kebergantungan bersih.

Prinsip Penyongsangan Ketergantungan (DIP)

Modul peringkat tinggi tidak boleh bergantung kepada modul peringkat rendah. Kedua -duanya bergantung kepada abstraksi. Juga, abstraksi tidak boleh bergantung kepada butiran; Butiran harus bergantung kepada abstraksi.

Ini membolehkan sistem longgar digabungkan. Di Python, ini sering bermakna pengekodan terhadap antara muka atau kelas abstrak dan bukannya pelaksanaan konkrit.

Pendekatan Praktikal: Gunakan suntikan ketergantungan untuk lulus komponen yang diperlukan dan bukannya mengodkannya di dalam kelas.

Sebagai contoh, bukannya secara langsung meneliti sambungan pangkalan data di dalam kelas perkhidmatan, menyuntik penyesuai pangkalan data yang mengikuti antara muka yang sama.

 Kelas Pengguna Kelas:
    def __init __ (diri, db: pangkalan data):
        self.db = db

• Gunakan suntikan ketergantungan untuk mengurangkan gandingan.
• Tentukan tingkah laku melalui kelas abstrak atau protokol.
• Membuat ujian lebih mudah - hanya bertukar dalam versi mengejek semasa ujian.

Memohon prinsip-prinsip pepejal di Python bukanlah mengenai peraturan yang ketat tetapi membuat pilihan reka bentuk yang bijak. Idea ini membantu menyusun kod anda dengan cara yang menjangkakan perubahan dan mengurangkan kerumitan.

Ia mungkin berasa seperti kerja tambahan pada mulanya, terutamanya dalam projek yang lebih kecil, tetapi hasilnya menjadi jelas apabila asas kod anda berkembang. Dan dengan jujur, beberapa prinsip ini menggabungkan secara semulajadi ke dalam sintaks bersih Python dan sifat dinamik - anda mungkin sudah melakukan bahagian -bahagian mereka tanpa menyedarinya.

Pada dasarnya itu sahaja.

Atas ialah kandungan terperinci Apakah prinsip reka bentuk yang kukuh, dan bagaimana ia memohon kepada pembangunan python?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!