मेरे अनुभव में, पायथन में कुछ पैटर्न अभी भी उपयोगी हैं, और अधिक स्थिर भाषाओं की तुलना में स्थापित करना आसान है। कुछ पैटर्न ओटोह की जरूरत नहीं है, या यहां तक कि सिंगलटन पैटर्न की तरह, पर भी डूब गए हैं। इसके बजाय एक मॉड्यूल स्तर चर या फ़ंक्शन का उपयोग करें। या बोर्ग पैटर्न का उपयोग करें।
एक सृजनात्मक प्रतिमान स्थापित करने के बजाय यह अक्सर एक कॉल करने योग्य पास करने के लिए पर्याप्त है जो ऑब्जेक्ट बनाता है। यह एक कार्य हो सकता है, एक __call__विधि या एक वर्ग के साथ एक वस्तु , क्योंकि new()पायथन में कोई भी नहीं है, केवल कक्षा का एक आह्वान:
def make_da_thing(maker, other, stuff):
da_thing = maker(other + 1, stuff + 2)
# ... do sth
return da_thing
def maker_func(x, y):
return x * y
class MakerClass(object):
def __init__(self, x, y):
self.x = x
self.y = y
...
a = make_da_thing(maker_func, 5, 8)
b = make_da_thing(MakerClass, 6, 7)
राज्य और रणनीति पैटर्न सी ++ और जावा जैसी भाषाओं में एक समान संरचना साझा करते हैं। पायथन में इतना कम। रणनीति पैटर्न कमोबेश एक जैसा रहता है, लेकिन स्टेट पैटर्न ज्यादातर अनावश्यक हो जाता है। स्टेटिक भाषाओं में स्टेट पैटर्न, रनटाइम पर क्लास के बदलाव का अनुकरण करता है। पायथन में, आप बस इतना कर सकते हैं: रनटाइम पर किसी ऑब्जेक्ट की क्लास बदलें। जब तक आप इसे नियंत्रित, संक्षिप्त तरीके से करते हैं, तब तक आपको ठीक होना चाहिए:
class On(object):
is_on = True
def switch(self):
self.__class__ = Off
class Off(object):
is_on = False
def switch(self):
self.__class__ = On
...
my_switch = On()
assert my_switch.is_on
my_switch.switch()
assert not my_switch.is_on
स्टैटिक टाइप डिस्पैच पर भरोसा करने वाले पैटर्न काम नहीं करेंगे, या काफी अलग तरीके से काम करेंगे। आपको उतने अधिक बॉयलर प्लेट कोड लिखने की ज़रूरत नहीं है, उदाहरण के लिए विज़िटर पैटर्न: जावा और सी ++ में आपको हर यात्रा योग्य कक्षा में एक स्वीकार पद्धति लिखनी होगी, जबकि पायथन में आप विजिबल की तरह एक मिश्रित वर्ग के माध्यम से उस कार्यक्षमता को प्राप्त कर सकते हैं:
class Visitable(object):
def accept(self, visitor):
visit = getattr(visitor, 'visit' + self.__class__.__name__)
return visit(self)
...
class On(Visitable):
''' exactly like above '''
class Off(Visitable):
''' exactly like above '''
class SwitchStatePrinter(object): # Visitor
def visitOn(self, switch):
print 'the switch is on'
def visitOff(self, switch):
print 'the switch is off'
class SwitchAllOff(object): # Visitor
def visitOn(self, switch):
switch.switch()
def visitOff(self, switch):
pass
...
print_state = SwitchStatePrinter()
turn_em_off = SwitchAllOff()
for each in my_switches:
each.accept(print_state)
each.accept(turn_em_off)
कई स्थितियाँ जो स्टैटिक लैंग्वेज में एक पैटर्न के आवेदन के लिए कहती हैं, वे पायथन में उतनी नहीं हैं। कई चीज़ों को अन्य आदेशों के साथ हल किया जा सकता है, जैसे कि उच्च ऑर्डर फ़ंक्शंस (सज्जाकार, फ़ंक्शन फ़ैक्टरी) या मेटा क्लास।