Bagaimana untuk memilih corak reka bentuk yang betul dalam Python, dengan contoh

Corak reka bentuk terbukti penyelesaian kepada masalah biasa dalam pembangunan perisian. Mereka menyediakan templat yang boleh diguna semula untuk menyelesaikan masalah reka bentuk, dengan itu meningkatkan kebolehselenggaraan dan fleksibiliti kod.

Tetapi dengan begitu banyak corak reka bentuk yang tersedia, bagaimana anda tahu yang mana satu untuk dilaksanakan dalam Python untuk masalah tertentu? Dalam artikel ini, kami akan meneroka langkah untuk memilih corak reka bentuk yang betul dan memberikan contoh bagi setiap satu untuk membantu anda memahami dan menerapkannya dengan berkesan.

1. Fahami masalah

Langkah pertama dalam memilih corak reka bentuk ialah memahami dengan jelas masalah yang anda cuba selesaikan. Tanya diri anda soalan berikut:

Apakah tingkah laku yang diharapkan?
Apakah kekangan sistem?
Apakah titik lanjutan atau variasi yang mungkin?

2. Mengkategorikan corak reka bentuk

Corak reka bentuk secara amnya dikelaskan kepada tiga kategori:

Penciptaan: Mementingkan penciptaan objek.
Struktur: Mementingkan komposisi objek.
Tingkah laku: Membimbangkan interaksi antara objek.
Mengenal pasti kategori yang sepadan dengan isu anda boleh membantu mengecilkan bilangan corak yang berkaitan.

3. Pilih corak reka bentuk yang sesuai

Setelah memahami masalah dan kategorinya, semak semula corak reka bentuk dalam kategori itu untuk mencari yang paling sesuai dengan situasi anda. Pertimbangkan perkara berikut:

Fleksibiliti: Adakah corak menawarkan fleksibiliti yang diperlukan?
Kerumitan: Bukankah ia memperkenalkan kerumitan yang tidak perlu?
Kebolehlanjutan: Adakah ia menjadikan sambungan masa hadapan lebih mudah?

1. Contoh corak reka bentuk dalam Python Singleton Bila nak guna? Apabila anda perlu memastikan bahawa kelas hanya mempunyai satu tika dan menyediakan pusat akses global kepada tika itu.

Contoh dalam Python:
`kelas SingletonMeta(jenis):
_contoh = {}

def __call__(cls, *args, **kwargs):
    if cls not in cls._instance:
        cls._instance[cls] = super().__call__(*args, **kwargs)
    return cls._instance[cls]

class Logger(metaclass=SingletonMeta):
log def(diri, mesej):
print(f"[LOG]: {message}")

guna

logger1 = Logger()
logger2 = Logger()

cetak(logger1 ialah logger2) # Output: Benar

logger1.log("Corak singleton dalam tindakan.")
`
Mengapa ia berkesan?
SingletonMeta ialah metaclass yang mengawal penciptaan tika Logger. Jika contoh sudah wujud, ia dikembalikan, memastikan hanya terdapat satu tika.

Kilang
Bila nak guna?
Apabila anda mempunyai kelas induk dengan berbilang kelas anak dan berdasarkan data input, anda perlu mengembalikan salah satu kelas anak.

Contoh dalam Python:
`Bentuk kelas:
def draw(self):
lulus

Bulatan kelas(Bentuk):
def draw(self):
print("Melukis bulatan.")

Segi empat kelas(Bentuk):
def draw(self):
print("Melukis segi empat sama.")

def shape_factory(shape_type):
if shape_type == "bulatan":
kembalikan Bulatan()
elif shape_type == "segi empat":
kembalikan Square()
lain:
naikkan ValueError("Jenis bentuk tidak diketahui.")

guna

bentuk = shape_factory("bulatan")
shape.draw() # Output: Melukis bulatan.
`
Mengapa ia berkesan?
Kilang merangkum logik penciptaan objek, membenarkan kejadian dibuat tanpa mendedahkan logik asas.

Perhatikan
Bila nak guna?
Apabila anda mempunyai satu objek (subjek) yang perlu memberitahu berbilang objek lain (pemerhati) apabila perubahan keadaan berlaku.

Contoh dalam Python:
`Subjek kelas:
def init(diri sendiri):
diri._pemerhati = []

def __call__(cls, *args, **kwargs):
    if cls not in cls._instance:
        cls._instance[cls] = super().__call__(*args, **kwargs)
    return cls._instance[cls]

Pemerhati kelas:
kemas kini def(diri, mesej):
lulus

Pemerhati Email(Pemerhati):
kemas kini def(diri, mesej):
print(f"Pemberitahuan e-mel: {message}")

Pemerhati SMS kelas(Pemerhati):
kemas kini def(diri, mesej):
print(f"Pemberitahuan SMS: {message}")

guna

subjek = Subjek()
subject.attach(EmailObserver())
subject.attach(SMSObserver())

subject.notify("Corak pemerhati dilaksanakan.")
`
Mengapa ia berkesan?
Subjek mengekalkan senarai pemerhati dan memberitahu mereka tentang perubahan, membenarkan komunikasi yang dipisahkan.
Strategi
Bila nak guna?
Apabila anda mempunyai berbilang algoritma untuk melaksanakan tugas dan anda ingin menukarnya secara dinamik.

Contoh dalam Python:
`jenis import

Pemproses Teks kelas:
def init(diri sendiri, pemformat):
self.formatter = jenis.MethodType(formatter, self)

def attach(self, observer):
    self._observers.append(observer)

def notify(self, message):
    for observer in self._observers:
        observer.update(message)

definisi pemformat_huruf besar(diri, teks):
return text.upper()

definisi huruf kecil_formatter(diri, teks):
kembalikan teks.lower()

guna

pemproses = TextProcessor(huruf besar_formatter)
print(processor.process("Hello World")) # Output: HELLO WORLD

pemproses.formatter = jenis.MethodType(huruf kecil_formatter, pemproses)
print(processor.process("Hello World")) # Output: hello world
`
Mengapa ia berkesan?
Corak Strategi membolehkan anda menukar algoritma yang digunakan oleh objek dengan cepat, dengan menetapkan fungsi baharu untuk diformatkan.

Penghias
Bila nak guna?
Apabila anda ingin menambah kefungsian baharu secara dinamik pada objek tanpa mengubah strukturnya.

Contoh dalam Python:
`def bold_decorator(func):
def wrapper():
kembalikan "" func() ""
kembalikan pembalut

definisi italic_decorator(func):
def wrapper():
kembalikan "" func() ""
kembalikan pembalut

@bold_decorator
@italic_decorator
def say_hello():
balas "Hello"

guna

print(say_hello()) # Output: Hello
`

Mengapa ia berkesan?
Penghias membenarkan anda membungkus fungsi untuk menambah fungsi, seperti memformat di sini, tanpa mengubah suai fungsi asal.

Suaikan
Bila nak guna?
Apabila anda perlu menggunakan kelas sedia ada tetapi antara mukanya tidak sepadan dengan keperluan anda.

Contoh dalam Python:
`kelas EuropeanSocketInterface:
voltan def(diri): lulus
def live(self): lulus
def neutral(self): lulus

kelas EuropeanSocket(EuropeanSocketInterface):
voltan def(diri):
pulangkan 230

def __call__(cls, *args, **kwargs):
    if cls not in cls._instance:
        cls._instance[cls] = super().__call__(*args, **kwargs)
    return cls._instance[cls]

kelas USASocketInterface:
voltan def(diri): lulus
def live(self): lulus
def neutral(self): lulus

Penyesuai kelas(USASocketInterface):
def init(self, european_socket):
self.european_socket = european_socket

def attach(self, observer):
    self._observers.append(observer)

def notify(self, message):
    for observer in self._observers:
        observer.update(message)

guna

euro_socket = EuropeanSocket()
penyesuai = Penyesuai(soket_euro)
print(f"Voltan: {adapter.voltage()}V") # Output: Voltan: 110V
`
penyesuai menterjemah antara muka kelas ke antara muka lain yang pelanggan jangkakan, membenarkan keserasian antara antara muka yang tidak serasi.

Perintah
Bila nak guna?
Apabila anda ingin merangkum permintaan sebagai objek, membolehkan anda mengkonfigurasi pelanggan dengan permintaan, baris gilir atau pengelogan yang berbeza.

Contoh dalam Python:
`Arahan kelas:
def laksanakan(diri):
lulus

kelas LightOnCommand(Command):
def init(diri, cahaya):
diri.cahaya = cahaya

def process(self, text):
    return self.formatter(text)

kelas LightOffCommand(Perintah):
def init(diri, cahaya):
diri.cahaya = cahaya

def live(self):
    return 1

def neutral(self):
    return -1

Cahaya kelas:
def turn_on(self):
print("Lampu dihidupkan")

def voltage(self):
    return 110

def live(self):
    return self.european_socket.live()

def neutral(self):
    return self.european_socket.neutral()

Kawalan Jauh kelas:
def serahkan(diri, perintah):
command.execute()

guna

cahaya = Cahaya()
on_command = LightOnCommand(cahaya)
off_command = LightOffCommand(cahaya)

jarak = RemoteControl()
remote.submit(on_command) # Output: Lampu dihidupkan
remote.submit(off_command) # Output: Lampu dimatikan
`
Mengapa ia berkesan?
Corak Perintah mengubah operasi menjadi objek, membenarkan tindakan dikonfigurasikan, beratur atau dibatalkan.

5. Kesimpulan

Memilih corak reka bentuk yang betul dalam Python memerlukan pemahaman yang jelas tentang masalah yang perlu diselesaikan dan corak yang tersedia. Dengan mengkategorikan masalah dan menganalisis faedah setiap corak, anda boleh memilih salah satu yang menawarkan penyelesaian paling berkesan.

Ingat bahawa corak reka bentuk ialah alat untuk menambah baik kod anda, bukan peraturan ketat untuk dipatuhi. Gunakannya dengan bijak untuk menulis kod Python yang bersih, boleh diselenggara dan berskala.

6. Sumber Tambahan

Buku:
Corak Reka Bentuk: Elemen Perisian Berorientasikan Objek Boleh Digunakan Semula oleh Erich Gamma et al.
Head First Design Patterns oleh Eric Freeman dan Elisabeth Robson.
Tapak web:
Pemfaktoran semula.Guru
Selami Corak Rekaan
Terima kasih kerana membaca! Jangan ragu untuk berkongsi pengalaman anda dengan corak reka bentuk Python dalam ulasan.

Atas ialah kandungan terperinci Bagaimana untuk memilih corak reka bentuk yang betul dalam Python, dengan contoh. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!