python - रुबी से पाइथन सीखना; मतभेद और समानताएं




ruby (4)

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

मैं जावास्क्रिप्टर्स के लिए लर्निंग लूआ के लिए लिखे गए प्राइमर की तरह एक सूची की तलाश में हूं: व्हाइट्स स्पेस महत्व और लूपिंग संरचनाओं जैसी सरल चीजें; पायथन में nil का नाम, और मूल्यों को "सच्चाई" माना जाता है; क्या यह map के बराबर और each के बराबर उपयोग करने के लिए बेवकूफ है, या कुछ गड़बड़ कर रहे हैं मानदंड मानक मानते हैं ?

अगर मुझे जवाबों की एक अच्छी विविधता मिलती है तो मुझे उन्हें एक समुदाय विकी में एकत्रित करने में खुशी होती है। अन्यथा आप एक सच्ची व्यापक सूची बनाने की कोशिश करने के लिए एक दूसरे से लड़ सकते हैं और पालना कर सकते हैं।

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


मुझे थोड़ा रूबी पता है, लेकिन आपके द्वारा उल्लिखित चीजों के बारे में कुछ बुलेट बिंदु यहां दिए गए हैं:

  • nil , मूल्य की कमी का संकेत देने वाला मान, None होगा (ध्यान दें कि आप इसकी जांच करते हैं जैसे कि x is None या x is not None , न कि == - या बूलियन के लिए जबरन द्वारा, अगली बिंदु देखें)।
  • None , शून्य-एस्क्यू संख्याएं ( 0 , 0.0 , 0j (जटिल संख्या)) और खाली संग्रह ( [] , {} , set() , खाली स्ट्रिंग "" इत्यादि) को गलत साबित माना जाता है, बाकी सब कुछ सत्य माना जाता है।
  • साइड इफेक्ट्स के लिए, (के for ) लूप स्पष्ट रूप से। साइड इफेक्ट्स के बिना सामान का एक नया गुच्छा पैदा करने के लिए, सूची समझ (या उनके रिश्तेदार - आलसी वन-टाइम इटरेटर्स के लिए जेनरेटर एक्सप्रेशन, कथित संग्रह के लिए निर्देश / सेट समझ) का उपयोग करें।

लूपिंग के बारे में: आपके पास for , जो एक अस्थिर (! कोई गिनती) पर काम करता है, और while , जो आप उम्मीद करेंगे। थियेटर कहीं अधिक शक्तिशाली है, इसके लिए व्यापक समर्थन के लिए धन्यवाद। सूची के बजाए एक इटरेटर नहीं होने वाला लगभग हर चीज एक इटरेटर (कम से कम पायथन 3 में - पायथन 2 में, आपके पास दोनों हैं और डिफ़ॉल्ट एक सूची है, दुख की बात है)। इटरेटर्स के साथ काम करने के लिए कई टूल हैं - zip समानांतर में किसी भी संख्या में पुनरावृत्तियों को पुनरावृत्त करता है, enumerate आपको (index, item) ( किसी भी इष्टतम पर, न केवल सूचियों पर) देता है, यहां तक ​​कि abritary (संभवतः बड़े या अनंत) पुनरावृत्तियों को टुकड़ा करता है! मैंने पाया कि ये कई लूपिंग कार्यों को बहुत आसान बनाते हैं। कहने की जरूरत नहीं है, वे सूची समझ, जेनरेटर अभिव्यक्ति इत्यादि के साथ ठीक है।


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

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


यहां कुछ महत्वपूर्ण अंतर हैं:

  1. रूबी में ब्लॉक हैं; पायथन नहीं करता है।

  2. पायथन में कार्य है; रूबी नहीं करता है। पायथन में, आप कोई फ़ंक्शन या विधि ले सकते हैं और इसे किसी अन्य फ़ंक्शन पर भेज सकते हैं। रूबी में, सब कुछ एक विधि है, और तरीकों को सीधे पारित नहीं किया जा सकता है। इसके बजाय, आपको उन्हें पारित करने के लिए प्रो में उन्हें लपेटना होगा।

  3. रूबी और पायथन दोनों समर्थन बंद, लेकिन विभिन्न तरीकों से। पायथन में, आप किसी अन्य फ़ंक्शन के अंदर फ़ंक्शन को परिभाषित कर सकते हैं। आंतरिक फ़ंक्शन ने बाहरी फ़ंक्शन से चरों तक पहुंच को पढ़ा है, लेकिन पहुंच लिखना नहीं है। रूबी में, आप ब्लॉक का उपयोग करके बंद परिभाषित करते हैं। बंदरगाहों को बाहरी क्षेत्र से चरों को पूर्ण पढ़ने और लिखने के लिए लिखा है।

  4. पायथन में सूची की समझ है, जो बहुत अभिव्यक्तिपूर्ण हैं। उदाहरण के लिए, यदि आपके पास संख्याओं की एक सूची है, तो आप लिख सकते हैं

    [x*x for x in values if x > 15]
    

    15 से अधिक मूल्यों के वर्गों की एक नई सूची प्राप्त करने के लिए। रूबी में, आपको निम्नलिखित लिखना होगा:

    values.select {|v| v > 15}.map {|v| v * v}
    

    रूबी कोड कॉम्पैक्ट के रूप में महसूस नहीं करता है। यह भी उतना कुशल नहीं है क्योंकि यह पहले मान सरणी को एक छोटे इंटरमीडिएट सरणी में परिवर्तित करता है जिसमें 15 से अधिक मान होते हैं। फिर, यह इंटरमीडिएट सरणी लेता है और इंटरमीडिएट्स के वर्ग वाले अंतिम सरणी उत्पन्न करता है। इंटरमीडिएट सरणी को बाहर फेंक दिया जाता है। तो, गणना के दौरान रूबी स्मृति में 3 सरणी के साथ समाप्त होता है; पायथन केवल इनपुट सूची और परिणामी सूची की आवश्यकता है।

    पायथन भी इसी तरह की नक्शा समझ प्रदान करता है।

  5. पाइथन tuples का समर्थन करता है; रूबी नहीं करता है। रुबी में, आपको ट्यूपल्स अनुकरण करने के लिए सरणी का उपयोग करना होगा।

  6. रूबी स्विच / केस स्टेटमेंट का समर्थन करता है; पायथन नहीं करता है।

  7. रूबी मानक expr ? val1 : val2 का समर्थन करता है expr ? val1 : val2 expr ? val1 : val2 ternary ऑपरेटर; पायथन नहीं करता है।

  8. रूबी केवल एक विरासत का समर्थन करता है। यदि आपको एकाधिक विरासत की नकल करने की आवश्यकता है, तो आप मॉड्यूल को परिभाषित कर सकते हैं और मॉड्यूल विधियों को कक्षाओं में खींचने के लिए मिश्रण-इन्स का उपयोग कर सकते हैं। पाइथन मॉड्यूल मिश्रण-इन्स की बजाय एकाधिक विरासत का समर्थन करता है।

  9. पायथन केवल एकल लाइन लैम्ब्डा कार्यों का समर्थन करता है। रूबी ब्लॉक, जो लैम्ब्डा कार्यों के प्रकार / प्रकार हैं, मनमाने ढंग से बड़े हो सकते हैं। इस वजह से, रूबी कोड आमतौर पर पाइथन कोड की तुलना में अधिक कार्यात्मक शैली में लिखा जाता है। उदाहरण के लिए, रूबी में एक सूची पर लूप करने के लिए, आप आमतौर पर करते हैं

    collection.each do |value|
      ...
    end
    

    ब्लॉक collection.each लिए पारित एक समारोह की तरह बहुत काम करता है। यदि आप पाइथन में एक ही चीज़ करना चाहते थे, तो आपको एक नामित आंतरिक फ़ंक्शन को परिभाषित करना होगा और उसके बाद प्रत्येक विधि को संग्रहित करना होगा (यदि सूची इस विधि का समर्थन करती है):

    def some_operation(value):
      ...
    
    collection.each(some_operation)
    

    यह बहुत अच्छी तरह से बहती नहीं है। इसलिए, आमतौर पर निम्नलिखित गैर-कार्यात्मक दृष्टिकोण का उपयोग पायथन में किया जाएगा:

    for value in collection:
      ...
    
  10. एक सुरक्षित तरीके से संसाधनों का उपयोग करना दो भाषाओं के बीच काफी अलग है। यहां, समस्या यह है कि आप कुछ संसाधन आवंटित करना चाहते हैं (फ़ाइल खोलें, डेटाबेस कर्सर प्राप्त करें, आदि), उस पर कुछ मनमानी ऑपरेशन करें, और फिर अपवाद होने पर भी इसे सुरक्षित तरीके से बंद करें।

    रूबी में, क्योंकि ब्लॉक का उपयोग करना इतना आसान है (देखें # 9), आप आमतौर पर इस पैटर्न को एक विधि के रूप में कोड करेंगे जो संसाधन पर प्रदर्शन करने के लिए मनमाने ढंग से ऑपरेशन के लिए एक ब्लॉक लेता है।

    पायथन में, मनमाने ढंग से कार्रवाई के लिए एक समारोह में गुजरना थोड़ा छोटा है क्योंकि आपको नामित, आंतरिक कार्य (# 9 देखें) लिखना है। इसके बजाय, पाइथन सुरक्षित संसाधन हैंडलिंग के लिए एक कथन का उपयोग करता है। देखें कि मैं पाइथन ऑब्जेक्ट को सही तरीके से कैसे साफ़ करूं? अधिक जानकारी के लिए।


रूबी में, उदाहरण चर और विधियां पूरी तरह से असंबंधित होती हैं, सिवाय इसके कि जब आप उन्हें स्पष्ट रूप से attr_accessor या उससे कुछ संबंधित करते हैं।

पायथन में, विधियां केवल विशेषता का एक विशेष वर्ग हैं: एक निष्पादन योग्य है।

तो उदाहरण के लिए:

>>> class foo:
...     x = 5
...     def y(): pass
... 
>>> f = foo()
>>> type(f.x)
<type 'int'>
>>> type(f.y)
<type 'instancemethod'>

उस अंतर में बहुत सारे प्रभाव हैं, उदाहरण के लिए कि एफएक्स का जिक्र करने से विधि ऑब्जेक्ट को संदर्भित करने के बजाए संदर्भित किया जाता है। साथ ही, जैसा कि आप देख सकते हैं, एफएक्स डिफ़ॉल्ट रूप से सार्वजनिक है, जबकि रूबी में, उदाहरण चर डिफ़ॉल्ट रूप से निजी होते हैं।







ruby