Python xulq-atvor shablonlari: Observer, Strategy va Command

Xulq-atvor dizayn shablonlari dasturiy ta'minot ishlab chiquvchisi qurol-aslahasidagi muhim vositalardir. Ular obyektlar o'rtasidagi umumiy aloqa va o'zaro ta'sir muammolarini hal qiladi, bu esa yanada moslashuvchan, texnik xizmat ko'rsatishga yaroqli va miqyoslanuvchi kodga olib keladi. Ushbu keng qamrovli qo'llanma Python'dagi uchta muhim xulq-atvor shablonini ko'rib chiqadi: Observer, Strategy va Command. Biz ularning maqsadini, amalga oshirilishini va real hayotdagi qo'llanilishini o'rganamiz, bu esa sizni loyihalaringizda ushbu shablonlardan samarali foydalanish uchun bilimlar bilan qurollantiradi.

Xulq-atvor shablonlarini tushunish

Xulq-atvor shablonlari obyektlar o'rtasidagi aloqa va o'zaro ta'sirga e'tibor qaratadi. Ular algoritmlarni belgilaydi va obyektlar o'rtasida mas'uliyatlarni taqsimlaydi, bu esa bo'sh bog'lanish va moslashuvchanlikni ta'minlaydi. Ushbu shablonlardan foydalanish orqali siz tushunish, o'zgartirish va kengaytirish oson bo'lgan tizimlarni yaratishingiz mumkin.

Xulq-atvor shablonlaridan foydalanishning asosiy afzalliklari:

• Kod tashkil etilishini yaxshilash: Maxsus xulq-atvorlarni inkapsulatsiyalash orqali bu shablonlar modullik va aniqlikni oshiradi.
• Moslashuvchanlikni oshirish: Ular tizimning asosiy komponentlarini o'zgartirmasdan, uning xulq-atvorini o'zgartirish yoki kengaytirish imkonini beradi.
• Bog'lanishni kamaytirish: Xulq-atvor shablonlari obyektlar orasidagi bo'sh bog'lanishni rag'batlantiradi, bu esa kod bazasiga texnik xizmat ko'rsatish va uni sinovdan o'tkazishni osonlashtiradi.
• Qayta ishlatish imkoniyatini oshirish: Shablonlarning o'zlari va ularni amalga oshiruvchi kod dasturning turli qismlarida yoki hatto turli loyihalarda qayta ishlatilishi mumkin.

Observer shabloni

Observer shabloni nima?

Observer shabloni obyektlar o'rtasida birga-ko'p bog'liqlikni aniqlaydi, shunda bir obyekt (mavzu) holati o'zgarganda, uning barcha bog'liq obyektlari (observerlar) avtomatik ravishda xabardor qilinadi va yangilanadi. Bu shablon bir obyektning holatiga asoslanib, bir nechta obyektlarda mustahkamlikni saqlash kerak bo'lganda ayniqsa foydalidir. Ba'zan u Publish-Subscribe (nashr qilish-obuna bo'lish) shabloni deb ham ataladi.

Buni jurnalga obuna bo'lish kabi tasavvur qiling. Siz (observer) jurnal (mavzu) yangi sonni nashr etganda yangiliklarni (xabarnomalarni) olish uchun ro'yxatdan o'tasiz. Siz doimiy ravishda yangi sonlarni tekshirishingiz shart emas; siz avtomatik ravishda xabardor qilinishingiz mumkin.

Observer shablonining komponentlari

• Mavzu (Subject): Holati qiziqish uyg'otadigan obyekt. U observerlar ro'yxatini saqlaydi va observerlarni biriktirish (obuna bo'lish) hamda ajratish (obunani bekor qilish) usullarini taqdim etadi.
• Observer: Mavzu tomonidan holat o'zgarishlari haqida observerlarga xabar berish uchun chaqiriladigan `update` usulini aniqlovchi interfeys yoki abstrakt sinf.
• KonkretMavzu (ConcreteSubject): Mavzuning konkret amalga oshirilishi bo'lib, u holatni saqlaydi va holat o'zgarganda observerlarga xabar beradi.
• KonkretObserver (ConcreteObserver): Observerning konkret amalga oshirilishi bo'lib, u mavzudagi holat o'zgarishlariga munosabat bildirish uchun `update` usulini amalga oshiradi.

Python'da amalga oshirish

Mana Observer shablonini ko'rsatuvchi Python misoli:

class Subject:
    def __init__(self):
        self._observers = []
        self._state = None

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

    def detach(self, observer):
        self._observers.remove(observer)

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

    @property
    def state(self):
        return self._state

    @state.setter
    def state(self, new_state):
        self._state = new_state
        self.notify()


class Observer:
    def update(self, state):
        raise NotImplementedError


class ConcreteObserverA(Observer):
    def update(self, state):
        print(f"ConcreteObserverA: State changed to {state}")


class ConcreteObserverB(Observer):
    def update(self, state):
        print(f"ConcreteObserverB: State changed to {state}")


# Example Usage
subject = Subject()

observer_a = ConcreteObserverA()
observer_b = ConcreteObserverB()

subject.attach(observer_a)
subject.attach(observer_b)

subject.state = "New State"
subject.detach(observer_a)
subject.state = "Another State"

Ushbu misolda, `Subject` `Observer` obyektlari ro'yxatini saqlaydi. `Subject`ning `state` holati o'zgarganda, u `notify()` usulini chaqiradi, bu esa observerlar ro'yxati bo'ylab takrorlanadi va ularning `update()` usulini chaqiradi. Har bir `ConcreteObserver` keyin holat o'zgarishiga mos ravishda munosabat bildiradi.

Real hayotdagi qo'llanilishi

• Hodisalarni qayta ishlash: GUI freymvorklarida Observer shabloni hodisalarni qayta ishlash uchun keng qo'llaniladi. Foydalanuvchi foydalanuvchi interfeysi elementi bilan o'zaro aloqada bo'lganda (masalan, tugmani bosganda), element (mavzu) ro'yxatdan o'tgan tinglovchilarni (observerlarni) hodisa haqida xabardor qiladi.
• Ma'lumotlarni tarqatish: Moliyaviy ilovalarda birja tikkerlari (mavzular) ro'yxatdan o'tgan mijozlarga (observerlarga) narx yangilanishlarini tarqatadi.
• Elektron jadval ilovalari: Elektron jadvaldagi katakcha o'zgarganda, bog'liq katakchalar (observerlar) avtomatik ravishda qayta hisoblanadi va yangilanadi.
• Ijtimoiy tarmoq bildirishnomalari: Kimdir ijtimoiy tarmoq platformasida post joylashtirganda, ularning obunachilari (observerlar) xabardor qilinadi.

Observer shablonining afzalliklari

• Bo'sh bog'lanish: Mavzu va observerlar bir-birining konkret sinflarini bilishlari shart emas, bu modullik va qayta ishlatishni rag'batlantiradi.
• Miqyoslanish: Yangi observerlarni mavzuni o'zgartirmasdan osongina qo'shish mumkin.
• Moslashuvchanlik: Mavzu observerlarga turli yo'llar bilan xabar berishi mumkin (masalan, sinxron yoki asinxron).

Observer shablonining kamchiliklari

• Kutilmagan yangilanishlar: Observerlar o'zlari qiziqmaydigan o'zgarishlar haqida xabardor qilinishi mumkin, bu esa resurslarning isrof bo'lishiga olib keladi.
• Yangilanish zanjirlari: Kaskadli yangilanishlar murakkablashishi va nosozliklarni tuzatish qiyinlashishi mumkin.
• Xotira sizishi: Agar observerlar to'g'ri ajratilmasa, ular axlat yig'uvchi tomonidan olib tashlanishi mumkin, bu esa xotira sizishiga olib keladi.

Strategy shabloni

Strategy shabloni nima?

Strategy shabloni algoritmlar oilasini aniqlaydi, har birini inkapsulatsiyalaydi va ularni o'zaro almashinuvchan qiladi. Strategy algoritmning undan foydalanadigan mijozlardan mustaqil ravishda farq qilishiga imkon beradi. Bu shablon vazifani bajarishning bir nechta usullari mavjud bo'lganda va mijoz kodini o'zgartirmasdan, ish vaqtida ular o'rtasida almashish imkoniyatini xohlaganingizda foydalidir.

Bir shahardan boshqa shaharga sayohat qilayotganingizni tasavvur qiling. Siz turli xil transport strategiyalarini tanlashingiz mumkin: samolyot, poyezd yoki mashina. Strategy shabloni manzilni o'zgartirmasdan, xarajat, vaqt va qulaylik kabi omillarga asoslanib eng yaxshi transport strategiyasini tanlash imkonini beradi.

Strategy shablonining komponentlari

• Strategy: Algoritmni aniqlovchi interfeys yoki abstrakt sinf.
• KonkretStrategy (ConcreteStrategy): Strategy interfeysining konkret amalga oshirilishlari bo'lib, har biri har xil algoritmni ifodalaydi.
• Kontekst (Context): Strategy obyektiga havolani saqlovchi va algoritmning bajarilishini unga topshiruvchi sinf. Kontekst Strategiyaning aniq amalga oshirilishini bilishi shart emas; u faqat Strategy interfeysi bilan o'zaro aloqada bo'ladi.

Python'da amalga oshirish

Mana Strategy shablonini ko'rsatuvchi Python misoli:

class Strategy:
    def execute(self, data):
        raise NotImplementedError


class ConcreteStrategyA(Strategy):
    def execute(self, data):
        print("Executing Strategy A...")
        return sorted(data)


class ConcreteStrategyB(Strategy):
    def execute(self, data):
        print("Executing Strategy B...")
        return sorted(data, reverse=True)


class Context:
    def __init__(self, strategy):
        self._strategy = strategy

    def set_strategy(self, strategy):
        self._strategy = strategy

    def execute_strategy(self, data):
        return self._strategy.execute(data)


# Example Usage
data = [1, 5, 3, 2, 4]

strategy_a = ConcreteStrategyA()
context = Context(strategy_a)
result = context.execute_strategy(data)
print(f"Result with Strategy A: {result}")

strategy_b = ConcreteStrategyB()
context.set_strategy(strategy_b)
result = context.execute_strategy(data)
print(f"Result with Strategy B: {result}")

Ushbu misolda, `Strategy` interfeysi `execute()` usulini aniqlaydi. `ConcreteStrategyA` va `ConcreteStrategyB` bu usulning turli xil amalga oshirilishlarini ta'minlaydi, ma'lumotlarni mos ravishda o'sish va kamayish tartibida saralaydi. `Context` sinfi `Strategy` obyektiga havolani saqlaydi va algoritmning bajarilishini unga topshiradi. Mijoz `set_strategy()` usulini chaqirish orqali ish vaqtida strategiyalar o'rtasida almashishi mumkin.

Real hayotdagi qo'llanilishi

• To'lovlarni qayta ishlash: Elektron tijorat platformalari turli xil to'lov usullarini (masalan, kredit karta, PayPal, bank o'tkazmasi) qo'llab-quvvatlash uchun Strategy shablonidan foydalanadi. Har bir to'lov usuli konkret strategiya sifatida amalga oshiriladi.
• Yuk tashish narxini hisoblash: Onlayn chakana sotuvchilar vazn, manzil va yuk tashish usuli kabi omillarga asoslanib yuk tashish narxini hisoblash uchun Strategy shablonidan foydalanadilar.
• Tasvirni siqish: Tasvirlarni tahrirlash dasturlari turli xil tasvirni siqish algoritmlarini (masalan, JPEG, PNG, GIF) qo'llab-quvvatlash uchun Strategy shablonidan foydalanadi.
• Ma'lumotlarni tasdiqlash: Ma'lumot kiritish shakllari kiritilayotgan ma'lumot turiga qarab turli xil tasdiqlash strategiyalaridan foydalanishi mumkin (masalan, elektron pochta manzili, telefon raqami, sana).
• Marshrutlash algoritmlari: GPS navigatsiya tizimlari foydalanuvchi afzalliklariga asoslanib turli xil marshrutlash algoritmlaridan (masalan, eng qisqa masofa, eng tez vaqt, eng kam tirbandlik) foydalanadi.

Strategy shablonining afzalliklari

• Moslashuvchanlik: Kontekstni o'zgartirmasdan yangi strategiyalarni osongina qo'shishingiz mumkin.
• Qayta ishlatish: Strategiyalar turli kontekstlarda qayta ishlatilishi mumkin.
• Inkapsulatsiya: Har bir strategiya o'z sinfida inkapsulatsiyalanadi, bu modullik va aniqlikni oshiradi.
• Ochiq/Yopiq Prinsip: Mavjud kodni o'zgartirmasdan yangi strategiyalar qo'shish orqali tizimni kengaytirishingiz mumkin.

Strategy shablonining kamchiliklari

• Murakkablikning ortishi: Sinfalar soni ko'payishi mumkin, bu esa tizimni yanada murakkablashtiradi.
• Mijozning xabardorligi: Mijoz mavjud turli strategiyalardan xabardor bo'lishi va mosini tanlashi kerak.

Command shabloni

Command shabloni nima?

Command shabloni so'rovni obyekt sifatida inkapsulatsiyalaydi, shu bilan mijozlarni turli so'rovlar bilan parametrlash, so'rovlarni navbatga qo'yish yoki qayd etish, va bekor qilinadigan operatsiyalarni qo'llab-quvvatlash imkonini beradi. U operatsiyani chaqiruvchi obyektni uni qanday bajarishni biladigan obyektdan ajratadi.

Restoranni tasavvur qiling. Siz (mijoz) ofitsiantga (chaqiruvchiga) buyurtma (buyruq) berasiz. Ofitsiant ovqatni o'zi tayyorlamaydi; u buyurtmani oshpazga (qabul qiluvchiga) beradi, u esa haqiqiy harakatni bajaradi. Command shabloni buyurtma berish jarayonini pishirish jarayonidan ajratish imkonini beradi.

Command shablonining komponentlari

• Command: So'rovni bajarish uchun usulni e'lon qiluvchi interfeys yoki abstrakt sinf.
• KonkretCommand (ConcreteCommand): Command interfeysining konkret amalga oshirilishlari bo'lib, ular qabul qiluvchi obyektni harakatga bog'laydi.
• Qabul qiluvchi (Receiver): Haqiqiy ishni bajaruvchi obyekt.
• Chaqiruvchi (Invoker): Buyruqdan so'rovni bajarishni so'raydigan obyekt. U Command obyektini saqlaydi va operatsiyani boshlash uchun uning `execute` usulini chaqiradi.
• Mijoz (Client): KonkretCommand obyektlarini yaratadi va ularning qabul qiluvchisini o'rnatadi.

Python'da amalga oshirish

Mana Command shablonini ko'rsatuvchi Python misoli:

class Command:
    def execute(self):
        raise NotImplementedError


class ConcreteCommand(Command):
    def __init__(self, receiver, action):
        self._receiver = receiver
        self._action = action

    def execute(self):
        self._receiver.action(self._action)


class Receiver:
    def action(self, action):
        print(f"Receiver: Performing action '{action}'")


class Invoker:
    def __init__(self):
        self._commands = []

    def add_command(self, command):
        self._commands.append(command)

    def execute_commands(self):
        for command in self._commands:
            command.execute()


# Example Usage
receiver = Receiver()

command1 = ConcreteCommand(receiver, "Operation 1")
command2 = ConcreteCommand(receiver, "Operation 2")

invoker = Invoker()
invoker.add_command(command1)
invoker.add_command(command2)

invoker.execute_commands()

Ushbu misolda, `Command` interfeysi `execute()` usulini aniqlaydi. `ConcreteCommand` `Receiver` obyektini ma'lum bir harakatga bog'laydi. `Invoker` sinfi `Command` obyektlari ro'yxatini saqlaydi va ularni ketma-ket bajaradi. Mijoz `ConcreteCommand` obyektlarini yaratadi va ularni `Invoker`ga qo'shadi.

Real hayotdagi qo'llanilishi

• GUI asboblar panellari va menyulari: Har bir tugma yoki menyu elementi buyruq sifatida ifodalanishi mumkin. Foydalanuvchi tugmani bosganda, mos keladigan buyruq bajariladi.
• Tranzaktsiyalarni qayta ishlash: Ma'lumotlar bazasi tizimlarida har bir tranzaktsiya buyruq sifatida ifodalanishi mumkin. Bu bekor qilish/qaytarish funksiyalarini va tranzaktsiyalarni qayd etishni ta'minlaydi.
• Makroslarni yozish: Dasturiy ilovalardagi makroslarni yozish funksiyalari foydalanuvchi harakatlarini yozib olish va qayta ijro etish uchun Command shablonidan foydalanadi.
• Ish navbatlari: Vazifalarni asinxron tarzda qayta ishlaydigan tizimlar ko'pincha ish navbatlaridan foydalanadi, bu yerda har bir ish buyruq sifatida ifodalanadi.
• Uzoqdan protsedura chaqiruvlari (RPC): RPC mexanizmlari uzoqdan usul chaqiruvlarini inkapsulatsiyalash uchun Command shablonidan foydalanadi.

Command shablonining afzalliklari

• Ajratish: Chaqiruvchi va qabul qiluvchi bir-biridan ajratilgan bo'lib, bu katta moslashuvchanlik va qayta ishlatish imkoniyatini beradi.
• Navbatga qo'yish va qayd etish: Buyruqlar navbatga qo'yilishi va qayd etilishi mumkin, bu bekor qilish/qaytarish va audit izlari kabi funksiyalarni ta'minlaydi.
• Parametrlash: Buyruqlar turli xil so'rovlar bilan parametrlanishi mumkin, bu ularni yanada ko'p qirrali qiladi.
• Bekor qilish/Qaytarishni qo'llab-quvvatlash: Command shabloni bekor qilish/qaytarish funksiyasini amalga oshirishni osonlashtiradi.

Command shablonining kamchiliklari

• Murakkablikning ortishi: Sinfalar soni ko'payishi mumkin, bu esa tizimni yanada murakkablashtiradi.
• Qo'shimcha yuk: Buyruq obyektlarini yaratish va bajarish biroz qo'shimcha yuk keltirishi mumkin.

Xulosa

Observer, Strategy va Command shablonlari Python'da moslashuvchan, texnik xizmat ko'rsatishga yaroqli va miqyoslanuvchi dasturiy ta'minot tizimlarini yaratish uchun kuchli vositalardir. Ularning maqsadini, amalga oshirilishini va real hayotdagi qo'llanilishini tushunish orqali siz ushbu shablonlardan umumiy dizayn muammolarini hal qilish va yanada mustahkam va moslashuvchan ilovalar yaratish uchun foydalanishingiz mumkin. Har bir shablon bilan bog'liq bo'lgan o'zaro kelishuvlarni hisobga olishni va o'zingizning aniq ehtiyojlaringizga eng mos keladiganini tanlashni unutmang. Ushbu xulq-atvor shablonlarini o'zlashtirish dasturiy ta'minot muhandisi sifatidagi imkoniyatlaringizni sezilarli darajada oshiradi.