पाइप्स, पाइथोनिक तरीका

कुछ पायथनवादी कोड पढ़ना पसंद करते हैं, अन्य संक्षिप्त पसंद करते हैं। दुर्भाग्य से, पहले और दूसरे के बीच संतुलन - निर्णय वास्तव में सुरुचिपूर्ण हैं - शायद ही कभी व्यवहार में पाया जाता है। अधिक बार लाइनों की तरह

my_function(sum(filter(lambda x: x % 3 == 1, [x for x in range(100)]))) 

या क्वात्रिन्स ला

 xs = [x for x in range(100)] xs_filtered = filter(lambda x: x % 3 == 1, xs) xs_sum = sum(xs_filtered) result = my_function(xs_sum) 

आदर्शवादी कुछ इस तरह लिखना चाहेंगे

 result = [x for x in range(100)] \ | where(lambda x: x % 3 == 1)) \ | sum \ | my_function 

पायथन में नहीं?

इस तरह की श्रृंखलाओं का एक सरल कार्यान्वयन हाल ही में एक निश्चित जूलियन पालार्ड ने अपने पाइप पुस्तकालय में प्रस्तावित किया था।

चलिए एक उदाहरण के साथ शुरू करते हैं:

 from pipe import * [1,2,3,4] | where(lambda x: x<=2) #<generator object <genexpr> at 0x88231e4> 

उफ़, सहज आवेग ने सवारी नहीं की। पाइप जनरेटर को लौटाता है, जिसमें से मूल्यों को अभी तक निकाला जाना है।

 [1,2,3,4] | where(lambda x: x<=2) | as_list #[1, 2] 

यह जनरेटर से मानों को प्रकार सूची () के अंतर्निहित कास्ट फ़ंक्शन के साथ निकालना संभव होगा, लेकिन उपकरण के लेखक ने अपने शोध में संगत था और हमें पाइप फ़ंक्शन as_list की पेशकश की।

जैसा कि आप देख सकते हैं, उदाहरण में पाइप के लिए डेटा स्रोत एक साधारण सूची है। सामान्यतया, आप पायथन के किसी भी चलने (चलने योग्य) इकाई का उपयोग कर सकते हैं। कहो, "जोड़े" (टुपल्स) या, और अधिक दिलचस्प, एक ही जनरेटर:

 def fib(): u"""    """ a, b = 0, 1 while 1: yield a a, b = b, a + b fib() | take_while(lambda x: x<10) | as_list #0 #1 #1 #2 #3 #5 #8 

कई सबक यहां से सीखे जा सकते हैं:

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

निश्चित रूप से, आनंद अधूरा होगा यदि यह हमारे लिए आसानी से अपने स्वयं के पाइप बनाने के लिए नहीं है। एक उदाहरण:

 @Pipe def custom_add(x): return sum(x) [1,2,3,4] | custom_add #10 

तर्क? आसान:

 @Pipe def sum_head(x, number_to_sum=2): acc = 0 return sum(x[:number_to_sum]) [1,2,3,4] | sum_head(3) #6 

लेखक ने कृपया बहुत सारे तैयार किए गए पाइप प्रदान किए। उनमें से कुछ:

• गिनती - आने वाले चलने के तत्वों की संख्या की गणना करें
• take (n) - इनपुट से चलने वाले पहले n तत्वों को iterable से निकालता है।
• tail (n) - अंतिम n तत्वों को पुनः प्राप्त करता है।
• स्किप (n) - स्काइप n प्रथम तत्व।
• सभी (पूर्व) - सही है अगर सभी पुनरावृत्त तत्व पूर्ववर्ती भविष्यवाणी को पूरा करते हैं।
• किसी भी (पूर्व) - कम से कम एक पुनरावृत्ति तत्व को सही भविष्यवाणी को पूरा करता है, तो सही है।
• as_list / as_dist - अगर सूची में परिवर्तन संभव हो, तो यदि यह संभव हो, तो एक सूची / शब्दकोश में ले जाया जा सकता है।
• क्रमपरिवर्तन (आर = कोई नहीं) - इनपुट पुनरावृत्ति के आर तत्वों के सभी संभव संयोजनों को बनाता है। यदि आर को परिभाषित नहीं किया जाता है, तो आर को लेन (चलने योग्य) के रूप में लिया जाता है।
• stdout - मानक स्ट्रीम में आउटपुट एक स्ट्रिंग में डालने के बाद पूरी तरह से चलने योग्य।
• टी - मानक धारा के लिए चलने योग्य तत्व का उत्पादन और इसे आगे की प्रक्रिया के लिए पास करें।
• चयन (चयनकर्ता) - चयनकर्ता फ़ंक्शन को उनके पास लागू करने के बाद आगे की प्रक्रिया के लिए चलने योग्य तत्वों को पास करें।
• जहां (विधेय) - आगे के लिए चलने योग्य तत्वों को संसाधित करने के लिए गुजरते हैं जो कि विधेय को पूरा करते हैं।

लेकिन ये अधिक दिलचस्प हैं:

• netcat (होस्ट, पोर्ट) - प्रत्येक चलने योग्य तत्व के लिए, सॉकेट खोलें, तत्व को स्वयं (निश्चित रूप से, स्ट्रिंग) स्थानांतरित करें, आगे की प्रक्रिया के लिए मेजबान प्रतिक्रिया को संचारित करें।
• netwrite (होस्ट, पोर्ट) - एक ही बात, डेटा भेजने के बाद सॉकेट से नहीं पढ़ें।

इन और अन्य पाइपों को डेटा स्ट्रीम को सॉर्ट करने, बायपास करने और संसाधित करने के लिए डिफ़ॉल्ट रूप से मॉड्यूल में ही शामिल किया जाता है, क्योंकि उन्हें बनाना बहुत आसान है।

पाइप डेकोरेटर के हुड के नीचे

ईमानदारी से, यह देखना आश्चर्यजनक था कि मॉड्यूल का आधार कोड लैकोनिक कैसे था! खुद के लिए न्यायाधीश:

 class Pipe: def __init__(self, function): self.function = function def __ror__(self, other): return self.function(other) def __call__(self, *args, **kwargs): return Pipe(lambda x: self.function(x, *args, **kwargs)) 

वास्तव में यही सब है। सामान्य सज्जाकार वर्ग।

कंस्ट्रक्टर में, डेकोरेटर फ़ंक्शन को सजाने के लिए बचाता है, इसे पाइप क्लास के ऑब्जेक्ट में बदल देता है।

यदि पाइप को __call__ विधि द्वारा बुलाया जाता है, तो दिए गए तर्कों के साथ फ़ंक्शन का एक नया पाइप वापस आ जाता है।

मुख्य सूक्ष्मता __ror__ विधि है। यह एक उलटा ऑपरेटर है, जो "या" ऑपरेटर (__or__) के अनुरूप है, जिसे एक तर्क के रूप में बाएं ऑपरेटर के साथ दाहिने ऑपरेटर पर कहा जाता है।

यह पता चला है कि श्रृंखला की गणना बाएं से दाएं शुरू होती है। पहला तत्व दूसरे के तर्क के रूप में पारित किया गया है; दूसरे से तीसरे और इतने पर कंप्यूटिंग का परिणाम है। जेनरेटर भी दर्द रहित श्रृंखला से गुजरते हैं।

मेरी राय में, बहुत, बहुत सुरुचिपूर्ण।

अंतभाषण

इस तरह के पाइपों के लिए वाक्यविन्यास वास्तव में सरल और सुविधाजनक है, मैं लोकप्रिय रूपरेखाओं में कुछ इस तरह देखना चाहता हूं; डेटा धाराओं को संसाधित करने के लिए; या - एक घोषणात्मक रूप में - कॉलबैक श्रृंखला को अस्तर।

कार्यान्वयन का एकमात्र दोष स्वयं अस्पष्ट त्रुटि के निशान हैं।

विचारों और वैकल्पिक कार्यान्वयन के विकास पर - निम्नलिखित लेखों में।