പൈത്തൺ ക്രിയേഷണൽ ഡിസൈൻ പാറ്റേണുകൾ കണ്ടെത്തുക: സിംഗിൾട്ടൺ, ഫാക്ടറി, അബ്സ്ട്രാക്റ്റ് ഫാക്ടറി, ബിൽഡർ, പ്രോട്ടോടൈപ്പ്. അവയുടെ ഉപയോഗക്രമങ്ങൾ, ഗുണങ്ങൾ, ലോകത്തിലെ ഉപയോഗങ്ങൾ എന്നിവ പഠിക്കുക.
പൈത്തൺ ഡിസൈൻ പാറ്റേണുകൾ: ക്രിയേഷണൽ പാറ്റേണുകളിലേക്ക് ഒരു ആഴത്തിലുള്ള പഠനം
സോഫ്റ്റ്വെയർ ഡിസൈനിലെ സാധാരണ പ്രശ്നങ്ങൾക്കുള്ള പരിഹാരങ്ങളാണ് ഡിസൈൻ പാറ്റേണുകൾ. കോഡ് വീണ്ടും ഉപയോഗിക്കാനും നിലനിർത്താനും എളുപ്പമാക്കാനും ഇത് സഹായിക്കുന്നു. ക്രിയേഷണൽ ഡിസൈൻ പാറ്റേണുകൾ, സാഹചര്യത്തിന് അനുയോജ്യമായ രീതിയിൽ ഒബ്ജക്റ്റുകൾ നിർമ്മിക്കുന്നതിനുള്ള മെക്കാനിസവുമായി ബന്ധപ്പെട്ടതാണ്. ഈ ലേഖനം, വിശദമായ വിശദീകരണങ്ങൾ, കോഡ് ഉദാഹരണങ്ങൾ, ആഗോളതലത്തിലുള്ള പ്രായോഗിക ആപ്ലിക്കേഷനുകൾ എന്നിവ ഉൾപ്പെടെ പൈത്തണിലെ ക്രിയേഷണൽ ഡിസൈൻ പാറ്റേണുകളെക്കുറിച്ച് വിശദമായി പറയുന്നു.
എന്താണ് ക്രിയേഷണൽ ഡിസൈൻ പാറ്റേണുകൾ?
ക്രിയേഷണൽ ഡിസൈൻ പാറ്റേണുകൾ ഇൻസ്റ്റൻ്റിയേഷൻ പ്രക്രിയയെ വേർതിരിക്കുന്നു. ഇത് ക്ലയിന്റ് കോഡിനെ ഇൻസ്റ്റൻ്റിയേറ്റ് ചെയ്യുന്ന പ്രത്യേക ക്ലാസുകളിൽ നിന്ന് വേർപെടുത്തുന്നു. ഇത് ഒബ്ജക്റ്റ് നിർമ്മാണത്തിന് കൂടുതൽ വഴക്കവും നിയന്ത്രണവും നൽകുന്നു. ഈ പാറ്റേണുകൾ ഉപയോഗിക്കുന്നതിലൂടെ, ഏത് ഒബ്ജക്റ്റിൻ്റെ ക്ലാസ്സാണ് നിർമ്മിക്കേണ്ടതെന്ന് വ്യക്തമാക്കാതെ തന്നെ നിങ്ങൾക്ക് ഒബ്ജക്റ്റുകൾ നിർമ്മിക്കാൻ കഴിയും. ഇത് കോഡിനെ കൂടുതൽ ശക്തവും പരിപാലിക്കാൻ എളുപ്പവുമാക്കുന്നു.
ക്രിയേഷണൽ പാറ്റേണുകളുടെ പ്രാഥമിക ലക്ഷ്യം ഒബ്ജക്റ്റ് ഇൻസ്റ്റൻ്റിയേഷൻ പ്രക്രിയയെ വേർതിരിക്കുക എന്നതാണ്. ഒബ്ജക്റ്റ് നിർമ്മാണത്തിൻ്റെ സങ്കീർണ്ണതകൾ ക്ലയിന്റിൽ നിന്ന് മറയ്ക്കുന്നു. ഇത് ഡെവലപ്പർമാരെ ഒബ്ജക്റ്റ് നിർമ്മാണത്തിൻ്റെ ചെറിയ വിശദാംശങ്ങളിൽ കുടുങ്ങാതെ അവരുടെ ആപ്ലിക്കേഷനുകളുടെ ഉയർന്ന തലത്തിലുള്ള ലോജിക്കിൽ ശ്രദ്ധ കേന്ദ്രീകരിക്കാൻ അനുവദിക്കുന്നു.
ക്രിയേഷണൽ ഡിസൈൻ പാറ്റേണുകളുടെ തരങ്ങൾ
ഈ ലേഖനത്തിൽ നമ്മൾ താഴെ പറയുന്ന ക്രിയേഷണൽ ഡിസൈൻ പാറ്റേണുകൾ ചർച്ചചെയ്യുന്നു:
- സിംഗിൾട്ടൺ: ഒരു ക്ലാസ്സിന് ഒരു ഇൻസ്റ്റൻസ് മാത്രമേ ഉണ്ടാകൂ എന്ന് ഉറപ്പാക്കുകയും അതിലേക്ക് ഒരു ഗ്ലോബൽ പോയിൻ്റ് നൽകുകയും ചെയ്യുന്നു.
- ഫാക്ടറി മെത്തേഡ്: ഒരു ഒബ്ജക്റ്റ് നിർമ്മിക്കുന്നതിനുള്ള ഇൻ്റർഫേസ് നിർവചിക്കുന്നു, എന്നാൽ ഏത് ക്ലാസ്സാണ് ഇൻസ്റ്റൻ്റിയേറ്റ് ചെയ്യേണ്ടതെന്ന് ഉപവിഭാഗങ്ങൾക്ക് തീരുമാനിക്കാം.
- അബ്സ്ട്രാക്റ്റ് ഫാക്ടറി: ബന്ധപ്പെട്ടതോ ആശ്രിതമായതോ ആയ ഒബ്ജക്റ്റുകളുടെ ഫാമിലികൾ ഉണ്ടാക്കുന്നതിന് ഒരു ഇൻ്റർഫേസ് നൽകുന്നു.
- ബിൽഡർ: ഒരു കോംപ്ലക്സ് ഒബ്ജക്റ്റിൻ്റെ നിർമ്മാണത്തെ അതിൻ്റെ പ്രാതിനിധ്യത്തിൽ നിന്ന് വേർതിരിക്കുന്നു, ഒരേ നിർമ്മാണ പ്രക്രിയ ഉപയോഗിച്ച് വ്യത്യസ്ത പ്രാതിനിധ്യങ്ങൾ ഉണ്ടാക്കാൻ അനുവദിക്കുന്നു.
- പ്രോട്ടോടൈപ്പ്: ഒരു പ്രോട്ടോടൈപ്പിക്കൽ ഇൻസ്റ്റൻസ് ഉപയോഗിച്ച് ഉണ്ടാക്കേണ്ട ഒബ്ജക്റ്റുകളുടെ തരം വ്യക്തമാക്കുന്നു, ഈ പ്രോട്ടോടൈപ്പ് പകർത്തുന്നതിലൂടെ പുതിയ ഒബ്ജക്റ്റുകൾ ഉണ്ടാക്കുന്നു.
1. സിംഗിൾട്ടൺ പാറ്റേൺ
ഒരു ക്ലാസ്സിന് ഒരു ഇൻസ്റ്റൻസ് മാത്രമേ ഉണ്ടാകൂ എന്ന് സിംഗിൾട്ടൺ പാറ്റേൺ ഉറപ്പാക്കുകയും അതിലേക്ക് ഒരു ഗ്ലോബൽ പോയിൻ്റ് നൽകുകയും ചെയ്യുന്നു. സിസ്റ്റത്തിലുടനീളമുള്ള പ്രവർത്തനങ്ങൾ ഏകോപിപ്പിക്കാൻ ഒരു ഒബ്ജക്റ്റ് മാത്രം ആവശ്യമുള്ളപ്പോൾ ഈ പാറ്റേൺ ഉപയോഗപ്രദമാണ്. ഇത് പലപ്പോഴും ഉറവിടങ്ങൾ, ലോഗിംഗ് അല്ലെങ്കിൽ കോൺഫിഗറേഷൻ ക്രമീകരണങ്ങൾ കൈകാര്യം ചെയ്യാൻ ഉപയോഗിക്കുന്നു.
നടപ്പാക്കൽ
സിംഗിൾട്ടൺ പാറ്റേണിൻ്റെ പൈത്തൺ ഉപയോഗക്രമം ഇതാ:
class Singleton:
_instance = None
def __new__(cls, *args, **kwargs):
if not cls._instance:
cls._instance = super(Singleton, cls).__new__(cls, *args, **kwargs)
return cls._instance
# Example usage
s1 = Singleton()
s2 = Singleton()
print(s1 is s2) # Output: True
വിശദീകരണം:
_instance: ഈ ക്ലാസ് വേരിയബിൾ ക്ലാസ്സിൻ്റെ ഒരൊറ്റ ഇൻസ്റ്റൻസ് സംഭരിക്കുന്നു.__new__: ഒരു ഒബ്ജക്റ്റ് ഉണ്ടാക്കുമ്പോൾ__init__എന്നതിന് മുമ്പാണ് ഈ രീതി വിളിക്കുന്നത്. ഒരു ഇൻസ്റ്റൻസ് നിലവിലുണ്ടോയെന്ന് ഇത് പരിശോധിക്കുന്നു. ഇല്ലെങ്കിൽ,super().__new__(cls)ഉപയോഗിച്ച് ഒരു പുതിയ ഇൻസ്റ്റൻസ് ഉണ്ടാക്കുകയും അത്_instanceൽ സംഭരിക്കുകയും ചെയ്യുന്നു. ഒരു ഇൻസ്റ്റൻസ് നിലവിലുണ്ടെങ്കിൽ, അത് നിലവിലുള്ള ഇൻസ്റ്റൻസ് നൽകുന്നു.
ഉപയോഗിക്കേണ്ട സന്ദർഭങ്ങൾ
- ഡാറ്റാബേസ് കണക്ഷൻ: ഒരു സമയം ഒരു ഡാറ്റാബേസ് കണക്ഷൻ മാത്രമേ തുറന്നിട്ടുള്ളൂ എന്ന് ഉറപ്പാക്കുന്നു.
- കോൺഫിഗറേഷൻ മാനേജർ: ആപ്ലിക്കേഷൻ കോൺഫിഗറേഷൻ ക്രമീകരണങ്ങളിലേക്ക് ഒരു പോയിൻ്റ് നൽകുന്നു.
- ലോഗർ: ആപ്ലിക്കേഷനിലെ എല്ലാ ലോഗിംഗ് പ്രവർത്തനങ്ങളും കൈകാര്യം ചെയ്യാൻ ഒരു ലോഗിംഗ് ഇൻസ്റ്റൻസ് ഉണ്ടാക്കുന്നു.
ഉദാഹരണം
സിംഗിൾട്ടൺ പാറ്റേൺ ഉപയോഗിച്ച് നടപ്പിലാക്കിയ ഒരു കോൺഫിഗറേഷൻ മാനേജരുടെ ലളിതമായ ഉദാഹരണം നോക്കാം:
class ConfigurationManager(Singleton):
def __init__(self):
if not hasattr(self, 'config'): # Ensure __init__ is only called once
self.config = {}
def set_config(self, key, value):
self.config[key] = value
def get_config(self, key):
return self.config.get(key)
# Example usage
config_manager1 = ConfigurationManager()
config_manager1.set_config('database_url', 'localhost:5432')
config_manager2 = ConfigurationManager()
print(config_manager2.get_config('database_url')) # Output: localhost:5432
2. ഫാക്ടറി മെത്തേഡ് പാറ്റേൺ
ഫാക്ടറി മെത്തേഡ് പാറ്റേൺ ഒരു ഒബ്ജക്റ്റ് ഉണ്ടാക്കുന്നതിന് ഒരു ഇൻ്റർഫേസ് നിർവചിക്കുന്നു, എന്നാൽ ഏത് ക്ലാസ്സാണ് ഇൻസ്റ്റൻ്റിയേറ്റ് ചെയ്യേണ്ടതെന്ന് ഉപവിഭാഗങ്ങൾക്ക് തീരുമാനിക്കാം. ഫാക്ടറി രീതി ഒരു ക്ലാസ്സിനെ ഉപവിഭാഗങ്ങളിലേക്ക് മാറ്റിവയ്ക്കാൻ അനുവദിക്കുന്നു. ഈ പാറ്റേൺ അയഞ്ഞ ബന്ധത്തെ പ്രോത്സാഹിപ്പിക്കുകയും നിലവിലുള്ള കോഡ് മാറ്റാതെ തന്നെ പുതിയ ഉൽപ്പന്ന തരങ്ങൾ ചേർക്കാൻ നിങ്ങളെ അനുവദിക്കുകയും ചെയ്യുന്നു.
നടപ്പാക്കൽ
ഫാക്ടറി മെത്തേഡ് പാറ്റേണിൻ്റെ ഒരു പൈത്തൺ ഉപയോഗക്രമം ഇതാ:
from abc import ABC, abstractmethod
class Animal(ABC):
@abstractmethod
def speak(self):
pass
class Dog(Animal):
def speak(self):
return "Woof!"
class Cat(Animal):
def speak(self):
return "Meow!"
class AnimalFactory(ABC):
@abstractmethod
def create_animal(self):
pass
class DogFactory(AnimalFactory):
def create_animal(self):
return Dog()
class CatFactory(AnimalFactory):
def create_animal(self):
return Cat()
# Client code
def get_animal(factory: AnimalFactory):
animal = factory.create_animal()
return animal.speak()
dog_sound = get_animal(DogFactory())
cat_sound = get_animal(CatFactory())
print(f"Dog says: {dog_sound}") # Output: Dog says: Woof!
print(f"Cat says: {cat_sound}") # Output: Cat says: Meow!
വിശദീകരണം:
Animal: എല്ലാ മൃഗങ്ങളുടെ തരത്തിനുമുള്ള ഇൻ്റർഫേസ് നിർവചിക്കുന്ന ഒരു അബ്സ്ട്രാക്റ്റ് അടിസ്ഥാന ക്ലാസ്.DogഉംCatഉം:Animalഇൻ്റർഫേസ് നടപ്പിലാക്കുന്ന കോൺക്രീറ്റ് ക്ലാസുകൾ.AnimalFactory: മൃഗങ്ങളെ ഉണ്ടാക്കുന്നതിനുള്ള ഇൻ്റർഫേസ് നിർവചിക്കുന്ന ഒരു അബ്സ്ട്രാക്റ്റ് അടിസ്ഥാന ക്ലാസ്.DogFactoryഉംCatFactoryഉം:AnimalFactoryഇൻ്റർഫേസ് നടപ്പിലാക്കുന്ന കോൺക്രീറ്റ് ക്ലാസുകൾ, യഥാക്രമംDog,Catഇൻസ്റ്റൻസുകൾ ഉണ്ടാക്കുന്നതിന് ഉത്തരവാദികൾ.get_animal: ഒരു മൃഗത്തെ ഉണ്ടാക്കാനും ഉപയോഗിക്കാനും ഫാക്ടറി ഉപയോഗിക്കുന്ന ഒരു ക്ലയിന്റ് ഫംഗ്ഷൻ.
ഉപയോഗിക്കേണ്ട സന്ദർഭങ്ങൾ
- UI ഫ്രെയിംവർക്കുകൾ: വ്യത്യസ്ത ഓപ്പറേറ്റിംഗ് സിസ്റ്റങ്ങൾക്കായി വ്യത്യസ്ത ഫാക്ടറികൾ ഉപയോഗിച്ച് പ്ലാറ്റ്ഫോമിന് അനുയോജ്യമായ UI ഘടകങ്ങൾ (ഉദാഹരണത്തിന്, ബട്ടണുകൾ, ടെക്സ്റ്റ് ഫീൽഡുകൾ) ഉണ്ടാക്കുന്നു.
- ഗെയിം ഡെവലപ്മെൻ്റ്: ഗെയിം ലെവൽ അല്ലെങ്കിൽ ഉപയോക്താവിൻ്റെ തിരഞ്ഞെടുക്കലിനെ അടിസ്ഥാനമാക്കി വ്യത്യസ്ത തരം ഗെയിം കഥാപാത്രങ്ങളോ ഒബ്ജക്റ്റുകളോ ഉണ്ടാക്കുന്നു.
- ഡോക്യുമെൻ്റ് പ്രോസസ്സിംഗ്: ആവശ്യമുള്ള ഔട്ട്പുട്ട് ഫോർമാറ്റിനെ അടിസ്ഥാനമാക്കി വ്യത്യസ്ത ഫാക്ടറികൾ ഉപയോഗിച്ച് വ്യത്യസ്ത തരം ഡോക്യുമെന്റുകൾ (ഉദാഹരണത്തിന്, PDF, Word, HTML) ഉണ്ടാക്കുന്നു.
ഉദാഹരണം
ഉപയോക്താവിൻ്റെ തിരഞ്ഞെടുക്കലിനെ അടിസ്ഥാനമാക്കി വ്യത്യസ്ത തരം പേയ്മെൻ്റ് രീതികൾ ഉണ്ടാക്കാൻ നിങ്ങൾ ആഗ്രഹിക്കുന്ന ഒരു സാഹചര്യം പരിഗണിക്കുക. ഫാക്ടറി മെത്തേഡ് പാറ്റേൺ ഉപയോഗിച്ച് നിങ്ങൾക്ക് ഇത് എങ്ങനെ നടപ്പിലാക്കാം:
from abc import ABC, abstractmethod
class Payment(ABC):
@abstractmethod
def process_payment(self, amount):
pass
class CreditCardPayment(Payment):
def process_payment(self, amount):
return f"Processing credit card payment of ${amount}"
class PayPalPayment(Payment):
def process_payment(self, amount):
return f"Processing PayPal payment of ${amount}"
class PaymentFactory(ABC):
@abstractmethod
def create_payment_method(self):
pass
class CreditCardPaymentFactory(PaymentFactory):
def create_payment_method(self):
return CreditCardPayment()
class PayPalPaymentFactory(PaymentFactory):
def create_payment_method(self):
return PayPalPayment()
# Client code
def process_payment(factory: PaymentFactory, amount):
payment_method = factory.create_payment_method()
return payment_method.process_payment(amount)
credit_card_payment = process_payment(CreditCardPaymentFactory(), 100)
paypal_payment = process_payment(PayPalPaymentFactory(), 50)
print(credit_card_payment) # Output: Processing credit card payment of $100
print(paypal_payment) # Output: Processing PayPal payment of $50
3. അബ്സ്ട്രാക്റ്റ് ഫാക്ടറി പാറ്റേൺ
അബ്സ്ട്രാക്റ്റ് ഫാക്ടറി പാറ്റേൺ ബന്ധപ്പെട്ടതോ ആശ്രിതമായതോ ആയ ഒബ്ജക്റ്റുകളുടെ ഫാമിലികൾ ഉണ്ടാക്കുന്നതിന് ഒരു ഇൻ്റർഫേസ് നൽകുന്നു. സ്ഥിരതയും അനുയോജ്യതയും ഉറപ്പാക്കുന്നതിനായി ഒരുമിച്ച് പ്രവർത്തിക്കാൻ രൂപകൽപ്പന ചെയ്തിരിക്കുന്ന ഒബ്ജക്റ്റുകൾ ഉണ്ടാക്കാൻ ഇത് നിങ്ങളെ അനുവദിക്കുന്നു.
നടപ്പാക്കൽ
അബ്സ്ട്രാക്റ്റ് ഫാക്ടറി പാറ്റേണിൻ്റെ ഒരു പൈത്തൺ ഉപയോഗക്രമം ഇതാ:
from abc import ABC, abstractmethod
class Button(ABC):
@abstractmethod
def paint(self):
pass
class Checkbox(ABC):
@abstractmethod
def paint(self):
pass
class GUIFactory(ABC):
@abstractmethod
def create_button(self):
pass
@abstractmethod
def create_checkbox(self):
pass
class WinFactory(GUIFactory):
def create_button(self):
return WinButton()
def create_checkbox(self):
return WinCheckbox()
class MacFactory(GUIFactory):
def create_button(self):
return MacButton()
def create_checkbox(self):
return MacCheckbox()
class WinButton(Button):
def paint(self):
return "Rendering a Windows button"
class MacButton(Button):
def paint(self):
return "Rendering a Mac button"
class WinCheckbox(Checkbox):
def paint(self):
return "Rendering a Windows checkbox"
class MacCheckbox(Checkbox):
def paint(self):
return "Rendering a Mac checkbox"
# Client code
def paint_ui(factory: GUIFactory):
button = factory.create_button()
checkbox = factory.create_checkbox()
return button.paint(), checkbox.paint()
win_button, win_checkbox = paint_ui(WinFactory())
mac_button, mac_checkbox = paint_ui(MacFactory())
print(win_button) # Output: Rendering a Windows button
print(win_checkbox) # Output: Rendering a Windows checkbox
print(mac_button) # Output: Rendering a Mac button
print(mac_checkbox) # Output: Rendering a Mac checkbox
വിശദീകരണം:
ButtonഉംCheckboxഉം: UI ഘടകങ്ങൾക്കുള്ള ഇൻ്റർഫേസുകൾ നിർവചിക്കുന്ന അബ്സ്ട്രാക്റ്റ് അടിസ്ഥാന ക്ലാസുകൾ.WinButton,MacButton,WinCheckbox, കൂടാതെMacCheckbox: Windows, Mac പ്ലാറ്റ്ഫോമുകൾക്കായി UI ഘടക ഇൻ്റർഫേസുകൾ നടപ്പിലാക്കുന്ന കോൺക്രീറ്റ് ക്ലാസുകൾ.GUIFactory: UI ഘടകങ്ങളുടെ ഫാമിലികൾ ഉണ്ടാക്കുന്നതിനുള്ള ഇൻ്റർഫേസ് നിർവചിക്കുന്ന ഒരു അബ്സ്ട്രാക്റ്റ് അടിസ്ഥാന ക്ലാസ്.WinFactoryഉംMacFactoryഉം:GUIFactoryഇൻ്റർഫേസ് നടപ്പിലാക്കുന്ന കോൺക്രീറ്റ് ക്ലാസുകൾ, യഥാക്രമം Windows, Mac പ്ലാറ്റ്ഫോമുകൾക്കായി UI ഘടകങ്ങൾ ഉണ്ടാക്കുന്നതിന് ഉത്തരവാദികൾ.paint_ui: UI ഘടകങ്ങൾ ഉണ്ടാക്കാനും പെയിൻ്റ് ചെയ്യാനും ഫാക്ടറി ഉപയോഗിക്കുന്ന ഒരു ക്ലയിന്റ് ഫംഗ്ഷൻ.
ഉപയോഗിക്കേണ്ട സന്ദർഭങ്ങൾ
- UI ഫ്രെയിംവർക്കുകൾ: ഒരു പ്രത്യേക ഓപ്പറേറ്റിംഗ് സിസ്റ്റത്തിൻ്റെയോ പ്ലാറ്റ്ഫോമിൻ്റെയോ രൂപത്തിനും ഭാവത്തിനും അനുയോജ്യമായ UI ഘടകങ്ങൾ ഉണ്ടാക്കുന്നു.
- ഗെയിം ഡെവലപ്മെൻ്റ്: ഒരു പ്രത്യേക ഗെയിം ലെവലിൻ്റെയോ തീമിൻ്റെയോ ശൈലിയുമായി പൊരുത്തപ്പെടുന്ന ഗെയിം ഒബ്ജക്റ്റുകൾ ഉണ്ടാക്കുന്നു.
- ഡാറ്റാ ആക്സസ്: ഒരു പ്രത്യേക ഡാറ്റാബേസുമായോ ഡാറ്റാ ഉറവിടവുമായോ പൊരുത്തപ്പെടുന്ന ഡാറ്റാ ആക്സസ് ഒബ്ജക്റ്റുകൾ ഉണ്ടാക്കുന്നു.
ഉദാഹരണം
വിവിധ ശൈലികളിലുള്ള (ഉദാഹരണത്തിന്, മോഡേൺ, വിക്ടോറിയൻ) വ്യത്യസ്ത തരം ഫർണിച്ചറുകൾ (ഉദാഹരണത്തിന്, കസേരകൾ, മേശകൾ) ഉണ്ടാക്കാൻ നിങ്ങൾ ആഗ്രഹിക്കുന്ന ഒരു സാഹചര്യം പരിഗണിക്കുക. അബ്സ്ട്രാക്റ്റ് ഫാക്ടറി പാറ്റേൺ ഉപയോഗിച്ച് നിങ്ങൾക്ക് ഇത് എങ്ങനെ നടപ്പിലാക്കാം:
from abc import ABC, abstractmethod
class Chair(ABC):
@abstractmethod
def create(self):
pass
class Table(ABC):
@abstractmethod
def create(self):
pass
class FurnitureFactory(ABC):
@abstractmethod
def create_chair(self):
pass
@abstractmethod
def create_table(self):
pass
class ModernFurnitureFactory(FurnitureFactory):
def create_chair(self):
return ModernChair()
def create_table(self):
return ModernTable()
class VictorianFurnitureFactory(FurnitureFactory):
def create_chair(self):
return VictorianChair()
def create_table(self):
return VictorianTable()
class ModernChair(Chair):
def create(self):
return "Creating a modern chair"
class VictorianChair(Chair):
def create(self):
return "Creating a Victorian chair"
class ModernTable(Table):
def create(self):
return "Creating a modern table"
class VictorianTable(Table):
def create(self):
return "Creating a Victorian table"
# Client code
def create_furniture(factory: FurnitureFactory):
chair = factory.create_chair()
table = factory.create_table()
return chair.create(), table.create()
modern_chair, modern_table = create_furniture(ModernFurnitureFactory())
victorian_chair, victorian_table = create_furniture(VictorianFurnitureFactory())
print(modern_chair) # Output: Creating a modern chair
print(modern_table) # Output: Creating a modern table
print(victorian_chair) # Output: Creating a Victorian chair
print(victorian_table) # Output: Creating a Victorian table
4. ബിൽഡർ പാറ്റേൺ
ബിൽഡർ പാറ്റേൺ ഒരു കോംപ്ലക്സ് ഒബ്ജക്റ്റിൻ്റെ നിർമ്മാണത്തെ അതിൻ്റെ പ്രാതിനിധ്യത്തിൽ നിന്ന് വേർതിരിക്കുന്നു. ഒരേ നിർമ്മാണ പ്രക്രിയ ഉപയോഗിച്ച് വ്യത്യസ്ത പ്രാതിനിധ്യങ്ങൾ ഉണ്ടാക്കാൻ അനുവദിക്കുന്നു. ഒന്നിലധികം ഓപ്ഷണൽ ഘടകങ്ങളുള്ള കോംപ്ലക്സ് ഒബ്ജക്റ്റുകൾ ഉണ്ടാക്കുമ്പോൾ ഇത് ഉപയോഗപ്രദമാണ്.
നടപ്പാക്കൽ
ബിൽഡർ പാറ്റേണിൻ്റെ ഒരു പൈത്തൺ ഉപയോഗക്രമം ഇതാ:
class Pizza:
def __init__(self):
self.dough = None
self.sauce = None
self.topping = None
def __str__(self):
return f"Pizza with dough: {self.dough}, sauce: {self.sauce}, and topping: {self.topping}"
class PizzaBuilder:
def __init__(self):
self.pizza = Pizza()
def set_dough(self, dough):
self.pizza.dough = dough
return self
def set_sauce(self, sauce):
self.pizza.sauce = sauce
return self
def set_topping(self, topping):
self.pizza.topping = topping
return self
def build(self):
return self.pizza
# Client code
pizza_builder = PizzaBuilder()
pizza = pizza_builder.set_dough("Thin crust").set_sauce("Tomato").set_topping("Pepperoni").build()
print(pizza) # Output: Pizza with dough: Thin crust, sauce: Tomato, and topping: Pepperoni
വിശദീകരണം:
Pizza: നിർമ്മിക്കേണ്ട കോംപ്ലക്സ് ഒബ്ജക്റ്റിനെ പ്രതിനിധീകരിക്കുന്ന ഒരു ക്ലാസ്.PizzaBuilder:Pizzaഒബ്ജക്റ്റിൻ്റെ വിവിധ ഘടകങ്ങൾ സജ്ജീകരിക്കുന്നതിനുള്ള രീതികൾ നൽകുന്ന ഒരു ബിൽഡർ ക്ലാസ്.
ഉപയോഗിക്കേണ്ട സന്ദർഭങ്ങൾ
- ഡോക്യുമെൻ്റ് ജനറേഷൻ: വ്യത്യസ്ത വിഭാഗങ്ങളും ഫോർമാറ്റിംഗ് ഓപ്ഷനുകളുമുള്ള കോംപ്ലക്സ് ഡോക്യുമെന്റുകൾ (ഉദാഹരണത്തിന്, റിപ്പോർട്ടുകൾ, ഇൻവോയ്സുകൾ) ഉണ്ടാക്കുന്നു.
- ഗെയിം ഡെവലപ്മെൻ്റ്: വ്യത്യസ്ത ആട്രിബ്യൂട്ടുകളും ഘടകങ്ങളുമുള്ള കോംപ്ലക്സ് ഗെയിം ഒബ്ജക്റ്റുകൾ (ഉദാഹരണത്തിന്, കഥാപാത്രങ്ങൾ, ലെവലുകൾ) ഉണ്ടാക്കുന്നു.
- ഡാറ്റാ പ്രോസസ്സിംഗ്: വ്യത്യസ്ത നോഡുകളും ബന്ധങ്ങളുമുള്ള കോംപ്ലക്സ് ഡാറ്റാ ഘടനകൾ (ഉദാഹരണത്തിന്, ഗ്രാഫുകൾ, ട്രീകൾ) ഉണ്ടാക്കുന്നു.
ഉദാഹരണം
വിവിധ ഘടകങ്ങളുള്ള (ഉദാഹരണത്തിന്, CPU, RAM, സ്റ്റോറേജ്) വ്യത്യസ്ത തരം കമ്പ്യൂട്ടറുകൾ ഉണ്ടാക്കാൻ നിങ്ങൾ ആഗ്രഹിക്കുന്ന ഒരു സാഹചര്യം പരിഗണിക്കുക. ബിൽഡർ പാറ്റേൺ ഉപയോഗിച്ച് നിങ്ങൾക്ക് ഇത് എങ്ങനെ നടപ്പിലാക്കാം:
class Computer:
def __init__(self):
self.cpu = None
self.ram = None
self.storage = None
self.graphics_card = None
def __str__(self):
return f"Computer with CPU: {self.cpu}, RAM: {self.ram}, Storage: {self.storage}, Graphics Card: {self.graphics_card}"
class ComputerBuilder:
def __init__(self):
self.computer = Computer()
def set_cpu(self, cpu):
self.computer.cpu = cpu
return self
def set_ram(self, ram):
self.computer.ram = ram
return self
def set_storage(self, storage):
self.computer.storage = storage
return self
def set_graphics_card(self, graphics_card):
self.computer.graphics_card = graphics_card
return self
def build(self):
return self.computer
# Client code
computer_builder = ComputerBuilder()
computer = computer_builder.set_cpu("Intel i7").set_ram("16GB").set_storage("1TB SSD").set_graphics_card("Nvidia RTX 3080").build()
print(computer)
# Output: Computer with CPU: Intel i7, RAM: 16GB, Storage: 1TB SSD, Graphics Card: Nvidia RTX 3080
5. പ്രോട്ടോടൈപ്പ് പാറ്റേൺ
പ്രോട്ടോടൈപ്പ് പാറ്റേൺ ഒരു പ്രോട്ടോടൈപ്പിക്കൽ ഇൻസ്റ്റൻസ് ഉപയോഗിച്ച് ഉണ്ടാക്കേണ്ട ഒബ്ജക്റ്റുകളുടെ തരം വ്യക്തമാക്കുന്നു, ഈ പ്രോട്ടോടൈപ്പ് പകർത്തുന്നതിലൂടെ പുതിയ ഒബ്ജക്റ്റുകൾ ഉണ്ടാക്കുന്നു. നിലവിലുള്ള ഒരു ഒബ്ജക്റ്റ് ക്ലോൺ ചെയ്ത് പുതിയ ഒബ്ജക്റ്റുകൾ ഉണ്ടാക്കാൻ ഇത് നിങ്ങളെ അനുവദിക്കുന്നു. ഒബ്ജക്റ്റുകൾ ആദ്യം മുതൽ ഉണ്ടാക്കേണ്ടതില്ലാത്തതിനാൽ ഇത് ഉപയോഗപ്രദമാകും.
നടപ്പാക്കൽ
പ്രോട്ടോടൈപ്പ് പാറ്റേണിൻ്റെ ഒരു പൈത്തൺ ഉപയോഗക്രമം ഇതാ:
import copy
class Prototype:
def __init__(self):
self._objects = {}
def register_object(self, name, obj):
self._objects[name] = obj
def unregister_object(self, name):
del self._objects[name]
def clone(self, name, **attrs):
obj = copy.deepcopy(self._objects.get(name))
if attrs:
obj.__dict__.update(attrs)
return obj
class Car:
def __init__(self):
self.name = ""
self.color = ""
self.options = []
def __str__(self):
return f"Car: Name={self.name}, Color={self.color}, Options={self.options}"
# Client code
prototype = Prototype()
car = Car()
car.name = "Generic Car"
car.color = "White"
car.options = ["AC", "GPS"]
prototype.register_object("generic", car)
car1 = prototype.clone("generic", name="Sports Car", color="Red", options=["AC", "GPS", "Spoiler"])
car2 = prototype.clone("generic", name="Family Car", color="Blue", options=["AC", "GPS", "Sunroof"])
print(car1)
# Output: Car: Name=Sports Car, Color=Red, Options=['AC', 'GPS', 'Spoiler']
print(car2)
# Output: Car: Name=Family Car, Color=Blue, Options=['AC', 'GPS', 'Sunroof']
വിശദീകരണം:
Prototype: പ്രോട്ടോടൈപ്പുകളെ കൈകാര്യം ചെയ്യുകയും അവയെ ക്ലോൺ ചെയ്യുന്നതിനുള്ള ഒരു രീതി നൽകുകയും ചെയ്യുന്ന ഒരു ക്ലാസ്.Car: ക്ലോൺ ചെയ്യേണ്ട ഒബ്ജക്റ്റിനെ പ്രതിനിധീകരിക്കുന്ന ഒരു ക്ലാസ്.
ഉപയോഗിക്കേണ്ട സന്ദർഭങ്ങൾ
- ഗെയിം ഡെവലപ്മെൻ്റ്: പരസ്പരം സാമ്യമുള്ള ഗെയിം ഒബ്ജക്റ്റുകൾ ഉണ്ടാക്കുന്നു.
- ഡോക്യുമെൻ്റ് പ്രോസസ്സിംഗ്: ഒരു ടെംപ്ലേറ്റിനെ അടിസ്ഥാനമാക്കിയുള്ള ഡോക്യുമെന്റുകൾ ഉണ്ടാക്കുന്നു.
- കോൺഫിഗറേഷൻ മാനേജ്മെൻ്റ്: സ്ഥിരസ്ഥിതി കോൺഫിഗറേഷനെ അടിസ്ഥാനമാക്കിയുള്ള കോൺഫിഗറേഷൻ ഒബ്ജക്റ്റുകൾ ഉണ്ടാക്കുന്നു.
ഉദാഹരണം
വിവിധ ആട്രിബ്യൂട്ടുകളുള്ള (ഉദാഹരണത്തിന്, പേര്, പങ്ക്, വകുപ്പ്) വ്യത്യസ്ത തരം ജീവനക്കാരെ ഉണ്ടാക്കാൻ നിങ്ങൾ ആഗ്രഹിക്കുന്ന ഒരു സാഹചര്യം പരിഗണിക്കുക. പ്രോട്ടോടൈപ്പ് പാറ്റേൺ ഉപയോഗിച്ച് നിങ്ങൾക്ക് ഇത് എങ്ങനെ നടപ്പിലാക്കാം:
import copy
class Employee:
def __init__(self):
self.name = None
self.role = None
self.department = None
def __str__(self):
return f"Employee: Name={self.name}, Role={self.role}, Department={self.department}"
class Prototype:
def __init__(self):
self._objects = {}
def register_object(self, name, obj):
self._objects[name] = obj
def unregister_object(self, name):
del self._objects[name]
def clone(self, name, **attrs):
obj = copy.deepcopy(self._objects.get(name))
if attrs:
obj.__dict__.update(attrs)
return obj
# Client code
prototype = Prototype()
employee = Employee()
employee.name = "Generic Employee"
employee.role = "Developer"
employee.department = "IT"
prototype.register_object("generic", employee)
employee1 = prototype.clone("generic", name="John Doe", role="Senior Developer")
employee2 = prototype.clone("generic", name="Jane Smith", role="Project Manager", department="Management")
print(employee1)
# Output: Employee: Name=John Doe, Role=Senior Developer, Department=IT
print(employee2)
# Output: Employee: Name=Jane Smith, Role=Project Manager, Department=Management
ഉപസംഹാരം
ക്രിയേഷണൽ ഡിസൈൻ പാറ്റേണുകൾ, ഒബ്ജക്റ്റ് ഉണ്ടാക്കുന്നതിനെ കൈകാര്യം ചെയ്യുന്നതിനുള്ള ശക്തമായ ഉപകരണങ്ങൾ നൽകുന്നു. ഈ പാറ്റേണുകൾ മനസ്സിലാക്കുന്നതിലൂടെ, നിങ്ങൾക്ക് വൃത്തിയുള്ളതും എളുപ്പത്തിൽ മാറ്റങ്ങൾ വരുത്താൻ കഴിയുന്നതുമായ കോഡ് എഴുതാൻ സാധിക്കും. ഈ ലേഖനത്തിൽ അഞ്ച് പ്രധാന ക്രിയേഷണൽ പാറ്റേണുകൾ - സിംഗിൾട്ടൺ, ഫാക്ടറി മെത്തേഡ്, അബ്സ്ട്രാക്റ്റ് ഫാക്ടറി, ബിൽഡർ, പ്രോട്ടോടൈപ്പ് എന്നിവ വിശദമായ ഉദാഹരണങ്ങൾ നൽകി.
ഒരു പാറ്റേൺ തിരഞ്ഞെടുക്കുന്നത് നിങ്ങൾ പരിഹരിക്കാൻ ശ്രമിക്കുന്ന പ്രത്യേക പ്രശ്നത്തെ ആശ്രയിച്ചിരിക്കുന്നുവെന്ന് ഓർമ്മിക്കുക. ഒബ്ജക്റ്റ് ഉണ്ടാക്കുന്നതിൻ്റെ സങ്കീർണ്ണത, വഴക്കത്തിൻ്റെ ആവശ്യം, ഭാവിയിലെ മാറ്റങ്ങൾ എന്നിവ പരിഗണിക്കുക. അങ്ങനെ ചെയ്യുന്നതിലൂടെ, സാധാരണ സോഫ്റ്റ്വെയർ ഡിസൈൻ വെല്ലുവിളികൾക്ക് മനോഹരവും കാര്യക്ഷമവുമായ പരിഹാരങ്ങൾ ഉണ്ടാക്കാൻ കഴിയും.