OOP- मुक्त डिजाइन पैटर्न

उन दिनों में जब मैंने लिस्प में लिखा था और ओओपी से बिल्कुल परिचित नहीं था, मैंने उन डिज़ाइन पैटर्न को खोजने की कोशिश की, जिन्हें मैं अपने कोड में लागू कर सकता था। और हर समय मैं कुछ खौफनाक श्रेणी की योजनाओं में आया। नतीजतन, मैंने निष्कर्ष निकाला कि ये पैटर्न कार्यात्मक प्रोग्रामिंग में लागू नहीं हैं।

अब मैं पायथन में लिखता हूं और ओओपी से परिचित हूं। और पैटर्न अब मेरे लिए बहुत स्पष्ट हैं। लेकिन मैं अभी भी फैल रही वर्ग योजनाओं से पीछे हट गया हूं। एक कार्यात्मक प्रतिमान में कई पैटर्न महान काम करते हैं। मैं कुछ उदाहरणों का वर्णन करूंगा।
मैं पैटर्न के शास्त्रीय कार्यान्वयन नहीं दूंगा। जो लोग उनसे परिचित नहीं हैं वे विकिपीडिया या अन्य स्रोतों में रुचि ले सकते हैं।

प्रेक्षक

यह सुनिश्चित करना आवश्यक है कि कुछ ऑब्जेक्ट संदेशों की सदस्यता ले सकते हैं, और किसी तरह इन संदेशों को भेज सकते हैं।
इसे एक शब्दकोश द्वारा लागू किया गया है, जो "मेल" है। चाबियाँ न्यूज़लेटर्स के नाम हैं, और मान ग्राहकों की सूची हैं।

from collections import defaultdict mailing_list = defaultdict(list) def subscribe(mailbox, subscriber): #   subscriber     mailbox mailing_list[mailbox].append(subscriber) def notify(mailbox, *args, **kwargs): #    mailbox,    for sub in mailing_list[mailbox]: sub(*args, **kwargs) 

अब आप न्यूज़लेटर्स के लिए कोई भी कार्य कर सकते हैं। मुख्य बात यह है कि समान वितरण समूह में शामिल कार्यों का इंटरफ़ेस संगत है।

 def fun(insert): print 'FUN %s' % insert def bar(insert): print 'BAR %s' % insert 

हम न्यूज़लेटर के लिए अपने कार्यों की सदस्यता लेते हैं:

 >>> subscribe('insertors', fun) >>> subscribe('insertors', bar) >>> subscribe('bars', bar) 

कोड में किसी भी स्थान पर, हम इन समाचार पत्रों के लिए सूचनाएं ट्रिगर करते हैं और निरीक्षण करते हैं कि सभी ग्राहक घटना पर प्रतिक्रिया देते हैं:

 >>> notify('insertors', insert=123) FUN 123 BAR 123 >>> notify('bars', 456) BAR 456 

टेम्पलेट विधि

एल्गोरिथ्म के ढांचे को नामित करना और उपयोगकर्ताओं को इसमें कुछ चरणों को फिर से परिभाषित करने के लिए सक्षम करना आवश्यक है।
उच्च-क्रम के कार्य, जैसे कि मानचित्र, फ़िल्टर, कम, अनिवार्य रूप से ऐसे पैटर्न हैं। लेकिन आइए देखें कि आप खुद को कैसे क्रैंक कर सकते हैं।

 def approved_action(checker, action, obj): # ,     obj  action, #   checker    if checker(obj): action(obj) import os def remove_file(filename): approved_action(os.path.exists, os.remove, filename) import shutil def remove_dir(dirname): approved_action(os.path.exists, shutil.rmtree, dirname) 

हमारे पास एक फ़ाइल और एक फ़ोल्डर को हटाने के लिए कार्य हैं, अग्रिम में जांचना कि क्या हमारे लिए हटाने के लिए कुछ भी है।
यदि एक "पैटर्न" को कॉल करना सीधे एक पैटर्न के विपरीत लगता है, तो आप करी का उपयोग करके कार्यों को परिभाषित कर सकते हैं। ठीक है, एल्गोरिथ्म के सभी भागों के "पुनर्वित्त" की संभावना को ढेर करने के लिए।

 def approved_action(obj, checker=lambda x: True, action=lambda x: None): if checker(obj): action(obj) from functools import partial remove_file = partial(approved_action, checker=os.path.exists, action=os.remove) remove_dir = partial(approved_action, checker=os.path.exists, action=shutil.rmtree) import sys printer = partial(approved_action, action=sys.stdout.write) 

राज्य

अपने राज्य के आधार पर ऑब्जेक्ट के विभिन्न व्यवहार को प्रदान करना आवश्यक है।
आइए कल्पना करें कि हमें आवेदन की प्रक्रिया का वर्णन करने की आवश्यकता है, जिसके लिए अनुमोदन के कई चक्रों की आवश्यकता हो सकती है।

 from random import randint # ,      . #       #  randint  ,  -       def start(claim): print u' ' claim['state'] = 'analyze' def analyze(claim): print u' ' if randint(0, 2) == 2: print u'   ' claim['state'] = 'processing' else: print u' ' claim['state'] = 'clarify' def processing(claim): print u'   ' claim['state'] = 'close' def clarify(claim): if randint(0, 4) == 4: print u'   ' claim['state'] = 'close' else: print u' ' claim['state'] = 'analyze' def close(claim): print u' ' claim['state'] = None #   .       state = {'start': start, 'analyze': analyze, 'processing': processing, 'clarify': clarify, 'close': close} #     def run_claim(): claim = {'state': 'start'} #   while claim['state'] is not None: #  ,     fun = state[claim['state']] #    fun(claim) 

जैसा कि आप देख सकते हैं, कोड का मुख्य भाग "व्यावसायिक तर्क" द्वारा कब्जा कर लिया गया है, और पैटर्न के आवेदन पर ओवरहेड द्वारा नहीं। ऑटोमेटन को केवल राज्य शब्दकोश में कार्यों को जोड़ने / बदलने के द्वारा विस्तार और संशोधित करना आसान है।

सुनिश्चित करें कि यह काम करता है:

 >>> run_claim()                     >>> run_claim()             

टीम

कार्य "कॉलबैक" व्यवस्थित करना है। यही है, ताकि कॉल की गई वस्तु अपने कोड से कॉल करने वाले तक पहुंच सके।
यह पैटर्न स्पष्ट रूप से स्थैतिक भाषाओं की सीमाओं के कारण उत्पन्न हुआ। कार्यात्मक श्रमिकों ने भी उन्हें एक पैटर्न के खिताब से सम्मानित नहीं किया होगा। एक फ़ंक्शन है - कृपया इसे पास करें जहां आप चाहते हैं, सहेजें, कॉल करें।

 def foo(arg1, arg2): #   print 'FOO %s, %s' (arg1, arg2) def bar(cmd, arg2): #  .      foo... print 'BAR %s' % arg2 cmd(arg2 * 2) # ...   

कमांड पैटर्न के शुरुआती कार्यों में, कमांड ऑब्जेक्ट को अग्रिम में कुछ मापदंडों को स्थानांतरित करने की क्षमता भी है। सुविधा के आधार पर, यह या तो करी के द्वारा तय किया जाता है ...

 >>> from functools import partial >>> bar(partial(foo, 1), 2) BAR 2 FOO 1, 4 

... या तो मेमने में लपेट कर

 >>> bar(lambda x: foo(x, 5), 100) BAR 100 FOO 200, 5 

सामान्य निष्कर्ष

अमूर्त वर्गों, कंक्रीट कक्षाओं, इंटरफेस आदि के बगीचे को बाड़ देना आवश्यक नहीं है। पहली कक्षा की वस्तुओं के रूप में कार्यों को संभालने की न्यूनतम संभावनाएं पहले से ही हमें समान रूप से एक ही डिजाइन पैटर्न का उपयोग करने की अनुमति देती हैं। कभी-कभी बिना सूचना के भी :)