रूबी के पास क्या है कि पायथन नहीं करता है, और इसके विपरीत?

| | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | |

पायथन बनाम रूबी के बारे में बहुत सारी चर्चाएं हैं, और मैं उन्हें पूरी तरह से अनुपयोगी पाता हूं, क्योंकि वे सभी इस बात पर ध्यान देते हैं कि फीचर एक्स भाषा वाई में क्यों बेकार है, या दावा भाषा वाई में एक्स नहीं है, हालांकि वास्तव में यह करता है। मुझे यह भी पता है कि मैं पायथन को क्यों पसंद करता हूं, लेकिन यह भी व्यक्तिपरक है, और किसी को भी चुनने में मदद नहीं करेगा, क्योंकि हो सकता है कि उनके विकास में मेरे जैसा स्वाद न हो।

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

कृपया एक उत्तर में कई अंतर नहीं हैं, कृपया। और जिन्हें आप जानते हैं उन्हें वोट दें, और जिन्हें आप जानते हैं वे गलत हैं (या व्यक्तिपरक हैं)। साथ ही, वाक्य रचना में अंतर दिलचस्प नहीं है। हम जानते हैं कि पायथन इंडेंटेशन के साथ वही करता है जो रूबी कोष्ठक और सिरों के साथ करती है, और उस @ को पायथन में स्वयं कहा जाता है।

अपडेट करें: यह अब एक समुदाय विकी है, इसलिए हम यहां बड़े अंतर जोड़ सकते हैं। p>

रूबी के पास क्लास बॉडी में क्लास रेफरेंस है

रूबी में आपके पास क्लास बॉडी में पहले से ही क्लास (स्वयं) का संदर्भ है। पायथन में आपके पास कक्षा का निर्माण समाप्त होने तक कक्षा का कोई संदर्भ नहीं होता है। /pre>

स्वयं इस मामले में वर्ग है, और यह कोड "काका" प्रिंट करेगा। कक्षा के नाम को प्रिंट करने का कोई तरीका नहीं है या अन्य तरीकों से पायथन में वर्ग परिभाषा निकाय से कक्षा तक पहुंचने का कोई तरीका नहीं है (बाहर मेथड डेफिनिशन्स)।

रूबी में सभी क्लासेज म्यूटेबल हैं

इससे आप कोर क्लासेस के एक्सटेंशन विकसित कर सकते हैं। यहां रेल एक्सटेंशन का एक उदाहरण दिया गया है:

 वर्ग स्ट्रिंग def start_with?(other) head = self[0, other.length] head == other end end 

Python (कल्पना कीजिए कि कोई "" नहीं था। startwith विधि):

def start_with(s, उपसर्ग): वापसी s[:len(prefix)] == उपसर्ग 

आप इसे किसी भी क्रम पर इस्तेमाल कर सकते हैं (सिर्फ तार नहीं)। इसका उपयोग करने के लिए आपको इसे स्पष्ट रूप से आयात करना चाहिए, उदाहरण के लिए, some_module import start_with से।

Ruby में Perl जैसी स्क्रिप्टिंग विशेषताएं हैं

रूबी में प्रथम श्रेणी के regexps, $-variables, awk/perl लाइन बाय लाइन इनपुट लूप और अन्य विशेषताएं हैं जो इसे छोटी शेल स्क्रिप्ट लिखने के लिए अधिक अनुकूल बनाती हैं जो टेक्स्ट फ़ाइलों को मंग करती हैं या अन्य प्रोग्राम के लिए ग्लू कोड के रूप में कार्य करती हैं।

रूबी में प्रथम श्रेणी निरंतरता है

कॉलसीसी स्टेटमेंट के लिए धन्यवाद। पायथन में आप विभिन्न तकनीकों द्वारा निरंतरता बना सकते हैं, लेकिन भाषा में अंतर्निहित कोई समर्थन नहीं है। रूबी में लाइन अनाम फ़ंक्शन, जिसे do के सामने विधि में एक तर्क के रूप में पारित किया जाएगा, और वहां से कॉल किया जाएगा। पायथन में आप इसके बजाय या तो एक विधि पास करके या जनरेटर के साथ ऐसा करेंगे।

रूबी:

amethod { |here| कई = लाइन्स+ऑफ़+कोड चला जाता है (यहां) } 

पायथन (रूबी ब्लॉक पायथन में विभिन्न निर्माणों के अनुरूप हैं):

amethod() के साथ यहाँ: # `amethod () एक संदर्भ प्रबंधक है कई=पंक्तियाँ+का+कोड जाता है(यहाँ) 

या

यहाँ के लिए amethod() : # `amethod()` एक चलने योग्य है कई=पंक्तियां+का+कोड जाता है(यहां) 

या

def function(here): कई =lines+of+code चला जाता है (यहां) एमेथोड (फ़ंक्शन) # `फ़ंक्शन` एक कॉलबैक है 

दिलचस्प बात यह है कि रूबी में ब्लॉक को कॉल करने के लिए सुविधा स्टेटमेंट को "यील्ड" कहा जाता है, जो पायथन में एक जनरेटर बनाएगा।

रूबी:

def themethod उपज 5 end themethod do |foo| फू एंड डालता है 

पायथन:

def themethod(): यील्ड 5 for foo in themethod(): Print foo 

हालांकि सिद्धांत अलग हैं, परिणाम आश्चर्यजनक रूप से समान है।

रूबी अधिक आसानी से कार्यात्मक शैली (पाइप जैसी) प्रोग्रामिंग का समर्थन करता है

myList.map(& :विवरण).अस्वीकार करें(&:खाली?).शामिल हों("") f mylist में) " ".join(filter(len, descriptions)) 

पायथन में बिल्ट-इन जेनरेटर हैं (जो रूबी ब्लॉक की तरह उपयोग किए जाते हैं, जैसा कि ऊपर बताया गया है)

पायथन के पास भाषा में जेनरेटर के लिए समर्थन है। रूबी 1.8 में आप जनरेटर मॉड्यूल का उपयोग कर सकते हैं जो एक ब्लॉक से जनरेटर बनाने के लिए निरंतरता का उपयोग करता है। या, आप केवल ब्लॉक/प्रोक/लैम्ब्डा का उपयोग कर सकते हैं! इसके अलावा, रूबी में 1.9 फाइबर हैं, और जनरेटर के रूप में उपयोग किए जा सकते हैं, और एन्यूमरेटर वर्ग एक अंतर्निहित जनरेटर है 4

docs.python। org में यह जनरेटर उदाहरण है:

def रिवर्स (डेटा): रेंज में इंडेक्स के लिए (लेन (डेटा) -1, -1, -1): उपज डेटा [इंडेक्स] 

उपरोक्त ब्लॉक उदाहरणों के साथ इसकी तुलना करें।

पायथन में लचीला नाम स्थान प्रबंधन है

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

पायथन में, फ़ाइल एक मॉड्यूल है, और आप इसके निहित नामों को मॉड्यूल आयात से *, जिससे आप चाहें तो नाम स्थान को प्रदूषित कर सकते हैं। लेकिन आप मॉड्यूल इंपोर्ट एनाम से, दूसरा के साथ केवल चयनित नामों को भी इम्पोर्ट कर सकते हैं या आप बस मॉड्यूल को इम्पोर्ट कर सकते हैं और फिर themodule.aname. यदि आप अपने नाम स्थान में अधिक स्तर चाहते हैं तो आपके पास पैकेज हो सकते हैं, जो मॉड्यूल वाली निर्देशिकाएं और एक __init__.py फ़ाइल है।

पायथन में डॉकस्ट्रिंग हैं

डॉकस्ट्रिंग ऐसे तार हैं जो मॉड्यूल, कार्यों और विधियों से जुड़े होते हैं और रनटाइम पर आत्मनिरीक्षण किए जा सकते हैं। यह हेल्प कमांड और स्वचालित दस्तावेज़ीकरण जैसी चीज़ें बनाने में मदद करता है।

def frobnicate(bar): """frobnicate एक बार लेता है और इसे >>> bar = Bar( ) >>> bar.is_frobnicated() गलत >>>frobnicate(bar) >>> bar.is_frobnicated() True "" 

रूबी "एस समकक्ष javadocs के समान हैं, और इसके बजाय विधि के ऊपर स्थित हैं। उन्हें 1.9"s Method#source_location उदाहरण उपयोग

पायथन के पास एकाधिक वंशानुक्रम है

रूबी नहीं करता ("उद्देश्य पर" -- देखें रूबी की वेबसाइट, यहां देखें कि यह कैसा है "रूबी में किया गया)। यह एक प्रकार की अमूर्त कक्षाओं के रूप में मॉड्यूल अवधारणा का पुन: उपयोग करता है। x रेंज में x के लिए(1, 10)]

रूबी:

res = (0..9).map { |x| x * x } 

पायथन:

>>> (x*x रेंज में x के लिए(10)) <जनरेटर ऑब्जेक्ट <genexpr> 0xb7c1ccd4> >>> सूची (_) [0, 1, 4, 9, 16, 25, 36, 49, 64, 81] 

रूबी:

p = खरीद {|x| x * x } (0..9).मैप(&p) 

पायथन 2.7+:

> ;>> {x:str(y*y) x,y के लिए {1:2, 3:4}.items()} {1: "4", 3: "16"} 

रूबी:

>> हैश[{1=>2, 3=>4}.नक्शा{|x,y| [x,(y*y).to_s]}] => {1=>"4", 3=>"16"} 

पायथन में डेकोरेटर हैं

रूबी में डेकोरेटर जैसी चीजें भी बनाई जा सकती हैं, और यह भी तर्क दिया जा सकता है कि वे "पायथन के रूप में आवश्यक नहीं हैं।

वाक्यविन्यास अंतर

रूबी को अपने सभी क्षेत्रों को बंद करने के लिए "अंत" या "}" की आवश्यकता है, जबकि पायथन केवल व्हाइट-स्पेस का उपयोग करता है। रूबी में हाल ही में व्हाइटस्पेस केवल इंडेंटेशन की अनुमति देने के प्रयास किए गए हैं http://github.com /माइकलेडगर/निर्बाध