पायथन और जावास्क्रिप्ट में एनालॉग्स। भाग तीन

हम पायथन और जावास्क्रिप्ट में एनालॉग्स के बारे में लेखों की एक श्रृंखला का अनुवाद करना जारी रखते हैं

पिछले रिलीज में, हम ECMAScript 5 पर आधारित पायथन (2.7) और JS के क्लासिक संस्करणों के वाक्य विन्यास पर निर्भर थे। इस बार हम नए कार्यों का उपयोग करेंगे जो ECMAScript 6 मानक के 3.6 और JS में दिखाई दिए।

ECMAScript 6 अधिकांश आधुनिक ब्राउज़रों द्वारा समर्थित एक अपेक्षाकृत नया मानक है । पुराने ब्राउज़रों में मानक 6 का उपयोग करने के लिए आपको क्रॉस-ब्राउज़र समर्थन के लिए आधुनिक जेएस 6 डिज़ाइनों का अनुवाद करने के लिए बैबेल की आवश्यकता होगी।

आज के लेख में: स्ट्रिंग्स में चर, अनपैकिंग लिस्ट, लैम्ब्डा फ़ंक्शन, इंडेक्स के बिना पुनरावृत्ति, जनरेटर और सेट।

अन्य मुद्दों की सामग्री:

1. पहला भाग - टाइप कन्वर्जन, टर्नरी ऑपरेटर, प्रॉपर्टी नाम से संपत्ति तक पहुँच, शब्दकोष, सूचियाँ, तार, स्ट्रिंग संयोजन
2. दूसरा भाग शब्दकोशों, JSON, नियमित, त्रुटियों और अपवादों का क्रमांकन है।
3. यह लेख
4. चौथा हिस्सा फ़ंक्शन तर्क, कक्षाएं, विरासत, सेटर गेटर्स और क्लास प्रॉपर्टीज़ के साथ बनाना और काम करना है।

पंक्तियों में चर

चर के साथ तार के निर्माण का पारंपरिक तरीका तार और चर के संयोजन का उपयोग करता है:

name = 'World' value = 'Hello, ' + name + '!\nWelcome!' 

ऐसा रिकॉर्ड बिखरा हुआ और खराब पढ़ा जा सकता है, और आप अक्सर लाइनों में शब्दों के आसपास के रिक्त स्थान में गलती कर सकते हैं।

पायथन में संस्करण 3.6 के साथ और JS ECMAScrip6 में शुरू करके, आप स्ट्रिंग इंटरपोलेशन का उपयोग कर सकते हैं, या, पायथन शब्दों में, एफ-स्ट्रिंग्स। ये स्ट्रिंग पैटर्न हैं जिसमें चर से मूल्यों को प्रतिस्थापित किया जाता है।

पायथन में, उद्धरण चिह्नों से पहले एफ-लाइनों को एक एफ के साथ चिह्नित किया जाता है:

 name = 'World' value = f"""Hello, {name}! Welcome!""" price = 14.9 value = f'Price: {price:.2f} €' # 'Price: 14.90 €' 

जेएस में, स्ट्रिंग पैटर्न एक बैकट्रिक `के साथ शुरू और समाप्त होते हैं

 name = 'World'; value = `Hello, ${name}! Welcome!`; price = 14.9; value = `Price ${price.toFixed(2)} €`; // 'Price: 14.90 €' 

ध्यान दें कि पैटर्न सिंगल-लाइन और मल्टी-लाइन दोनों हो सकते हैं।
पायथन में, आप चर का प्रारूपण सेट कर सकते हैं।

अनपैकिंग सूची

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

 [a, b, c] = [1, 2, 3] 

टुपल्स के लिए, कोष्ठक छोड़े जा सकते हैं।
पायथन में दो चर के मूल्यों का आदान-प्रदान करने के तरीके के बाद निम्न उदाहरण बहुत लोकप्रिय है:

 a = 1 b = 2 a, b = b, a #   

JS6 + में, यह भी संभव है:

 a = 1; b = 2; [a, b] = [b, a]; //   

पायथन में, अगर हमारे पास किसी सूची या टपल में तत्वों की अनिश्चित संख्या है, तो हम इन तत्वों को एक वैरिएबल के वेरिएबल में असाइन कर सकते हैं जिसमें अंतिम कुछ मान सूची के रूप में वापस आते हैं:

 first, second, *the_rest = [1, 2, 3, 4] # first == 1 # second == 2 # the_rest == [3, 4] 

जेएस (ECMAScrip6) में भी ऐसा ही किया जा सकता है:

 [first, second, ...the_rest] = [1, 2, 3, 4]; // first === 1 // last === 2 // the_rest === [3, 4] 

लैम्ब्डा कार्य करता है

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

पायथन में, आप lambda कीवर्ड का उपयोग करके एक लैम्ब्डा फ़ंक्शन को परिभाषित कर सकते हैं:

 sum = lambda x, y: x + y square = lambda x: x ** 2 

जेएस => संकेतन का उपयोग करता है। यदि एक से अधिक तर्क हैं, तो उन्हें कोष्ठक में रखा गया है:

 sum = (x, y) => x + y; square = x => Math.pow(x, 2); 

अनुक्रमित के बिना Iteration

कई पीएल आपको केवल इंडेक्स संख्या द्वारा विशिष्ट तत्व तक पहुंचने और इस सूचकांक की वृद्धि के साथ चक्र को बायपास करने की अनुमति देते हैं।

 for (i=0; i<items.length; i++) { console.log(items[i]); } 

यह बहुत सुंदर रिकॉर्ड नहीं है, और शुरुआती लोगों के लिए थोड़ा जटिल है - ऐसा रिकॉर्ड प्राकृतिक नहीं दिखता है। पायथन के पास सूची में आने के लिए एक सुंदर, संक्षिप्त तरीका है:

 for item in ['A', 'B', 'C']: print(item) 

आधुनिक JS में, इसे for..of ऑपरेटर का उपयोग करके कार्यान्वित किया for..of है:

 for (let item of ['A', 'B', 'C']) { console.log(item); } 

तुम भी पायथन में चरित्र द्वारा लाइन चरित्र को बायपास कर सकते हैं:

 for character in 'ABC': print(character) 

और आधुनिक जावास्क्रिप्ट में:

 for (let character of 'ABC') { console.log(character); } 

जनरेटर

पायथन और आधुनिक जेएस दोनों आपको विशेष कार्यों को परिभाषित करने की अनुमति देते हैं जो पुनरावृत्तियों की तरह दिखेंगे। प्रत्येक कॉल (पुनरावृत्ति) के साथ, वे अनुक्रम से अगला उत्पन्न मान लौटाएंगे। ऐसे कार्यों को जनरेटर कहा जाता है।

जेनरेटर आमतौर पर उपयोग करने के लिए उपयोग किए जाते हैं: एक रेंज से नंबर, एक फाइल से लाइनें, एक बाहरी एपीआई से पेज द्वारा डेटा पेज, रिट्रेसमेंट नंबर और अन्य गतिशील रूप से उत्पन्न अनुक्रम।

तकनीकी रूप से, जनरेटर सामान्य कार्यों की तरह दिखते हैं, लेकिन एकल मान वापस करने के बजाय (और काम रोककर), वे अगली कॉल तक एक ही मूल्य और संचालन रोकते हैं। वे सूची के अंत तक पहुंचने तक प्रत्येक कॉल के साथ सूची से निम्नलिखित मान उत्पन्न करेंगे।

पायथन में एक उदाहरण पर विचार करें, जिसमें उलटी गिनती () जनरेटर बनाया गया है, जो किसी संख्या में 1 से रिवर्स ऑर्डर में संख्या (10,9,8, ..., 1) देता है:

 def countdown(counter): while counter > 0: yield counter counter -= 1 for counter in countdown(10): print(counter) 

वही आधुनिक जेएस में प्राप्त किया जा सकता है, लेकिन फ़ंक्शन के विवरण में * पर ध्यान दें। यह उसे एक जनरेटर के रूप में परिभाषित करता है:

 function* countdown(counter) { while (counter > 0) { yield counter; counter--; } } for (let counter of countdown(10)) { console.log(counter); } 

सेट (सेट)

हम पहले से ही सूचियों (सूचियों), ट्यूपल्स (ट्यूपल्स), सरणियों (सरणियों) से परिचित हो गए। लेकिन एक अन्य प्रकार का डेटा है - सेट। सेट डेटा सरणियाँ हैं जिनमें प्रत्येक अद्वितीय तत्व केवल एक प्रति में मौजूद है। सेट सिद्धांत संघ, चौराहे और अंतर के रूप में सेट के साथ संचालन को परिभाषित करता है, लेकिन हम अब उन पर विचार नहीं करेंगे।

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

 s = set(['A']) s.add('B'); s.add('C') 'A' in s len(s) == 3 for elem in s: print(elem) s.remove('C') 

जेएस पर एक ही बात:

 s = new Set(['A']); s.add('B').add('C'); s.has('A') === true; s.size === 3; for (let elem of s.values()) { console.log(elem); } s.delete('C') 

संक्षेप में देना

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

अगले भाग में, हम फ़ंक्शन तर्कों, कक्षाओं, वंशानुक्रम और गुणों के बारे में बात करेंगे।