क्या आप पाइथन का उपयोग ज्यादातर कार्यात्मक या ऑब्जेक्ट उन्मुख सुविधाओं के लिए करते हैं?

Question

मुझे लगता है कि स्टैक ओवरव्लो पर पाइथन डेवलपर्स के बहुमत की तरह लग रहा है जैसे कि लैम्ब्डा, मानचित्र, फ़िल्टर इत्यादि जैसे संक्षिप्त कार्यात्मक औजारों का उपयोग करते हुए, जबकि अन्य कहते हैं कि उनका कोड स्पष्ट नहीं है और उनका उपयोग करके अधिक रखरखाव योग्य है। आपकी वरीयता क्या है?

इसके अलावा, अगर आप एक कट्टर कार्यात्मक प्रोग्रामर या कट्टर OO में कर रहे हैं, तो आप अन्य क्या विशिष्ट प्रोग्रामिंग प्रथाओं का उपयोग आपको लगता है कि अपनी शैली के लिए सबसे अच्छा कर रहे हैं करते हैं?

आपकी राय के लिए अग्रिम धन्यवाद!

Answer 1

मैं ऑब्जेक्ट उन्मुख और प्रक्रियात्मक शैलियों का उपयोग कर पाइथन का उपयोग करता हूं। पाइथन वास्तव में कार्यात्मक प्रोग्रामिंग के लिए विशेष रूप से उपयुक्त नहीं है।

लोगों का एक बहुत लगता है कि वे lambda के बहुत सारे का उपयोग कर, map, filter, और reduce द्वारा कार्यात्मक अजगर कोड लिख रहे हैं, लेकिन यह थोड़ा अति सरल है। कार्यात्मक प्रोग्रामिंग की विशेषता विशेषता राज्य या साइड इफेक्ट्स की कमी है। एक कार्यात्मक शैली के महत्वपूर्ण तत्व शुद्ध कार्य, पुनरावर्ती एल्गोरिदम, और प्रथम श्रेणी के कार्य हैं।

• शुद्ध कार्यों महान हैं:

  यहाँ कार्यात्मक प्रोग्रामिंग और अजगर पर मेरे विचार कर रहे हैं। मैं अपने मॉड्यूल-स्तरीय कार्यों को शुद्ध करने के लिए अपनी पूरी कोशिश करता हूं।

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

• क्लास-आधारित प्रोग्रामिंग शुद्ध हो सकती है। आप अजगर वर्गों का उपयोग शुद्ध कार्यों के लिए एक बराबर (जो कभी कभी लेकिन हमेशा नहीं तुम क्या चाहते है),

  • अपने उदाहरणों अपरिवर्तनीय बनाने चाहते हैं। विशेष रूप से, यह मुख्य रूप से आपके तरीकों को हमेशा चालू करने के बजाए अपनी कक्षा के नए उदाहरण वापस करने का मतलब है।
  • वैश्विक दायरे से सामान (आयातित मॉड्यूल की तरह) प्राप्त करने के बजाय निर्भरता इंजेक्शन का उपयोग करें।
  • यह हमेशा वही नहीं हो सकता जो आप चाहते हैं।

• सभी को एक साथ राज्य से बचने की कोशिश न करें। यह पायथन में एक उचित रणनीति नहीं है। उदाहरण के लिए, some_list.append(foo) का उपयोग new_list = some_list + [foo] के बजाय करें, जिनमें से पूर्व अधिक मूर्ख और कुशल है। (दरअसल, "कार्यात्मक" समाधानों का एक टन जो मुझे लगता है कि पाइथन में लोग उपयोग करते हैं, वे सरल या सरल समाधानों की तुलना में एल्गोरिदमिक रूप से उप-विशिष्ट हैं जो कार्यात्मक नहीं हैं या केवल कार्यात्मक हैं लेकिन कार्यात्मक दिखने वाले टूल का उपयोग नहीं करते हैं।)

• कार्यात्मक प्रोग्रामिंग से सर्वोत्तम सबक सीखें, उदाहरण के लिए परिवर्तनीय स्थिति खतरनाक है। अपने आप से पूछें, क्या मैं वास्तव में इस एक्स को बदलना चाहता हूं या क्या मुझे एक नया एक्स चाहिए?

  • एक वास्तव में आम जगह इस आता है जब एक सूची के प्रसंस्करण है। मैं

    foo = [bar(item.baz()) for item in foo] 
    

    बजाय

    for index, _ in enumerate(foo): 
        foo[index] = bar(foo[index].baz()) 
    

    और ऐसा लगता है सामान का प्रयोग करेंगे। यह उलझन में बग से बचाता है जहां एक ही सूची वस्तु कहीं और संग्रहीत होती है और इसे बदला नहीं जाना चाहिए। (यदि यह बदलना चाहिए, तो एक सभ्य मौका है कि आपके पास डिज़ाइन त्रुटि है। कुछ सूचीओं को म्यूट करना जो आपने कई स्थानों का संदर्भ दिया है, राज्य साझा करने का एक शानदार तरीका नहीं है।)

• map और दोस्तों के अनावश्यक प्रयोग न करें। ऐसा करने के बारे में और कुछ भी कार्यात्मक नहीं है।

  • map/filter अधिक सूची comprehensions से कार्यात्मक नहीं हैं। सूची की समझ हास्केल, एक शुद्ध कार्यात्मक भाषा से उधार ली गई थी। map और विशेष रूप से filter सूची समझ से समझने में कठिन हो सकता है। मैं कभी भी लैम्ब्डा के साथ map या filter का उपयोग नहीं करता लेकिन शायद अगर मेरे पास कोई ऐसा कार्य था जो पहले से मौजूद था; मैं map एक सभ्य बिट का उपयोग करता हूं।
  • जनरेटर अभिव्यक्तियों की तुलना में itertools.imap/ifilter के लिए यह वही है। (ये चीजें कुछ हद तक आलसी हैं, जो कुछ महान है जो हम कार्यात्मक दुनिया से उधार ले सकते हैं।)
  • साइड इफेक्ट्स के लिए map और filter का उपयोग न करें। मैं इसे map के साथ बहुत कुछ देखता हूं, जो दोनों हार्ड-टू-समझ कोड, अनियंत्रित सूचियां बनाता है, और निश्चित रूप से कार्यात्मक नहीं है (लोगों को लगता है कि यह map के कारण होना चाहिए।) बस लूप के लिए उपयोग करें।
  • reduce बहुत ही सरल मामलों को छोड़कर भ्रमित है। पाइथन के पास लूप के लिए है और इनका उपयोग करने में कोई चोट नहीं है।

• रिकर्सिव एल्गोरिदम का उपयोग न करें। यह कार्यात्मक प्रोग्रामिंग पायथन का एक हिस्सा है जो अच्छी तरह से समर्थन नहीं करता है। सीपीथॉन (और मुझे लगता है कि अन्य सभी पायथन) पूंछ कॉल अनुकूलन का समर्थन नहीं करते हैं। इसके बजाय पुनरावृत्ति का उपयोग करें।

• जब आप फ्लाई पर फ़ंक्शंस को परिभाषित कर रहे हैं तो केवल lambda का उपयोग करें। बेनामी फ़ंक्शन नामित फ़ंक्शंस से बेहतर नहीं हैं, जिनमें से बाद में अधिक मजबूत, रखरखाव योग्य और दस्तावेज होते हैं।

Answer 2

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

Answer 3

अजगर केवल सीमांत कार्यात्मक प्रोग्रामिंग इसलिए सुविधाओं मैं अगर कई लोगों को विशेष रूप से उस के लिए यह प्रयोग करेंगे आश्चर्य होगा है। उदाहरण के लिए फ़ंक्शन संरचना करने के लिए कोई मानक तरीका नहीं है और मानक लाइब्रेरी के reduce() को स्पष्ट लूप के पक्ष में बहिष्कृत कर दिया गया है।

इसके अलावा, मुझे नहीं लगता कि map() या filter() आम तौर पर अनुमोदित होते हैं। इसके विपरीत, आमतौर पर सूची की समझ को प्राथमिकता दी जाती है।

Answer 4

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

यदि मैं वास्तव में कार्यात्मक प्रोग्रामिंग चाहता हूं, तो मैं लिस्प का उपयोग करता हूं।

Answer 5

StackOverflow पर अधिकांश उत्तर संक्षिप्त, संक्षिप्त जवाब हैं, और अजगर के कार्यात्मक पहलुओं आसान जवाब उस तरह का लेखन करते हैं।

पायथन के OO-सुविधाओं बस 10-20 रेखा जवाब में आवश्यकता नहीं होती है, तो आप उन्हें यहाँ के आसपास के रूप में ज्यादा नहीं दिख रहा।

Answer 6

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

तो बुनियादी तौर पर, वर्गों में एक आवेदन सड़ते हुए जब एक प्रणाली को डिजाइन करने में बहुत मददगार है। जब आप वास्तविक कार्यान्वयन कर रहे हैं, तो एफपी सही कोड लिखने में मदद करता है।

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

पायथन में एफपी ज्यादातर जेनरेटर और उनके रिश्तेदारों (सूची समझ) और itertools मॉड्यूल में चीजों को लिखने के आसपास घूमता है। स्पष्ट नक्शा/फ़िल्टर/कॉल कम करना सिर्फ अनियंत्रित हैं।