पायथन में थोड़ी देर का लूप कैसे बनाएं: 9 कदम

2024 लेखक: John Day | [email protected]. अंतिम बार संशोधित: 2024-01-30 09:20

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

थोड़ी देर का लूप एक बेहतरीन टूल है जो आपको प्रोग्रामिंग करते समय चरणों के एक सेट के माध्यम से कुशलतापूर्वक लूप करने देता है, जबकि आपके कोड को साफ और संक्षिप्त रखता है। नीचे दिए गए चरण आपको दिखाएंगे कि एक सूची के माध्यम से पायथन से लूप में थोड़ी देर का लूप कैसे बनाया जाए। यह अभ्यास उन शुरुआती लोगों के लिए है जिन्हें सरणियों के बारे में कुछ ज्ञान है, जिन्हें पायथन में "सूचियाँ" कहा जाता है। इस १५ मिनट के अभ्यास के लिए, हम संख्याओं की एक सूची के माध्यम से लूप करेंगे और प्रत्येक संख्या मान को पांच से बढ़ाएंगे। उदाहरण के लिए, यदि सूची में संख्याएँ [1, 2, 4, 7] हैं, तो लूप एक नई सूची तैयार करेगा जिसमें संख्याएँ [6, 7, 9, 12] होंगी।

आपूर्ति

पायथन 3 (डाउनलोड करने के लिए लिंक पर क्लिक करें)

चरण 1: फ़ंक्शन को परिभाषित करें

पहला कदम एक फ़ंक्शन को एक पैरामीटर के साथ परिभाषित करना है जो एक सूची में लेता है। नीचे दिए गए उदाहरण में, AddFive नामक एक फ़ंक्शन बनाया गया है और पैरामीटर lst (सूची के लिए छोटा) दिया गया है। परिभाषित फ़ंक्शन स्टेटमेंट के अंत में एक कोलन जोड़ना सुनिश्चित करें।

डीईएफ़ ऐडफाइव (एलएसटी):

चरण 2: एक खाली सूची आरंभ करें

इसके बाद, हमें एक खाली सूची शुरू करने की आवश्यकता है, जिसका उपयोग हम एक नई सूची बनाने के लिए करेंगे जिसमें फ़ंक्शन के चलने के बाद संख्या में वृद्धि हुई होगी [6, 7, 9, 12]। मानों को एक नई सूची में रखने से हम मूल सूची को अपरिवर्तित रख सकेंगे।

नीचे दिए गए उदाहरण में, वेरिएबल nlst के साथ एक नई सूची बनाई गई है और फिर, बंद कोष्ठक टाइप करके एक खाली सूची के बराबर पर सेट किया गया है। चर को इंडेंट करना सुनिश्चित करें।

डीईएफ़ ऐडफाइव (एलएसटी):

एनएलएसटी =

चरण 3: एक चर "सूचकांक" को संख्या 0. पर सेट करें

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

डीईएफ़ ऐडफाइव (एलएसटी):

nlst = सूचकांक = 0

चरण 4: लूप स्टेटमेंट के दौरान शुरू करें

अगला, हम नीचे दिए गए उदाहरण में उपयुक्त सशर्त विवरण लिखकर अपना लूप शुरू करेंगे। लूप के लिए शुरुआती स्टेटमेंट बनाने के बाद, हम अगले लूप के लिए अपने स्टेप्स लिखेंगे। लूप कंडीशनल स्टेटमेंट के अंत में कोलन शामिल करना सुनिश्चित करें।

डीईएफ़ ऐडफाइव (एलएसटी):

nlst = अनुक्रमणिका = 0 जबकि अनुक्रमणिका <लेन (lst):

आइए इस सशर्त कथन को तोड़ें। बयान के रूप में पढ़ता है, "जबकि सूचकांक सूची की लंबाई से कम है।. ।" सूची की लंबाई [१, २, ४, ७] ४ के बराबर है क्योंकि सूची में ४ संख्या तत्व हैं। चूंकि किसी सूची का सूचकांक 0 से शुरू होता है, इसलिए अंतिम सूचकांक हमेशा सूची की लंबाई घटा 1 होगा। हमारे सूची उदाहरण [1, 2, 4, 7] में, सूची का अंतिम सूचकांक 4 - 1 के बराबर है।, जो 3 के बराबर है। इसलिए, सूचकांक 3 सूची में अंतिम सूचकांक है।

सूची में तत्वों के साथ अनुक्रमणिका कैसे संरेखित होती है, इसके उदाहरण के लिए ऊपर दिया गया चार्ट देखें। इंडेक्स 0 में नंबर 1 है, इंडेक्स 1 में नंबर 2, इंडेक्स 2 में नंबर 4 और इंडेक्स 3 में नंबर 7 है।

हम ऊपर दिए गए चार्ट में देख सकते हैं कि कैसे इंडेक्स 3 सूची में आखिरी इंडेक्स है। चूंकि अनुक्रमणिका ३ सूची का अंतिम सूचकांक है, अब हम जानते हैं कि सूचकांक ३ अंतिम सूचकांक है जिसे लूप को समाप्त करने से पहले ५ से बढ़ाना चाहिए। इसलिए, हम लूपिंग रखने के लिए अपना लूप सशर्त स्टेटमेंट सेट करते हैं, जबकि वेरिएबल इंडेक्स सूची (4) की लंबाई से कम है, क्योंकि संख्या 3 संख्या 4 से एक कम है।

चरण 5: जोड़ें विधि जोड़ें

अब लूप की बॉडी बनाने का समय आ गया है। शरीर में कदमों के लिए, पहले सूचकांक के लिए क्या करना है, इसके बारे में सोचें। हमारा जबकि लूप शेष इंडेक्स के लिए चरणों को दोहराएगा। सूची [1, 2, 4, 7] के पहले सूचकांक (सूचकांक 0) में, हम संख्या 1 लेना चाहते हैं और उसमें 5 जोड़ना चाहते हैं, फिर खाली सूची nlst में नया नंबर जोड़ें।

एक खाली सूची में एक तत्व जोड़ने के लिए, हमें एपेंड विधि का उपयोग करके तत्व को सूची में जोड़ना होगा। एपेंड विधि का उपयोग करने के लिए, हम nlst.append() लिखते हैं जैसा कि नीचे दिए गए उदाहरण में दिखाया गया है, यह सुनिश्चित करते हुए कि विधि कॉल के अंत में कोष्ठक रखें। फिर कोष्ठक के अंदर, हम कोड जोड़ते हैं जो वर्तमान संख्या तत्व प्लस 5 (यानी 1 + 5 = 6) को जोड़ देगा।

डीईएफ़ ऐडफाइव (एलएसटी):

nlst = अनुक्रमणिका = 0 जबकि अनुक्रमणिका < len(lst): nlst.append()

चरण 6: परिशिष्ट के अंदर गणित व्यंजक डालें

वर्तमान संख्या तत्व प्राप्त करने के लिए, हम इस तरह के सूचकांक का उपयोग करके सूची तत्व का उपयोग करते हैं:

एलएसटी [0] = 1

पहली [1] = २

पहली [2] = 4

एलएसटी [3] = 7

इसलिए, लूप के दौरान सूची में पहले तत्व तक पहुंचने के लिए, कोड lst[index] होगा क्योंकि शुरुआत में, हम वेरिएबल इंडेक्स को 0 पर सेट करते हैं। एलिमेंट में 5 जोड़ने के लिए, हम lst लिखकर जोड़ देते हैं। इंडेक्स] + 5. पहले इंडेक्स (इंडेक्स 0) के लिए, यह 1 + 5 देगा, जो 6 के बराबर है।

अब जब हमने नए तत्व संख्या 6 की गणना की है, तो हमें इस सूची को जोड़कर इस संख्या को खाली सूची में रखना होगा। कोड के लिए नीचे दिया गया उदाहरण देखें।

डीईएफ़ ऐडफाइव (एलएसटी):

nlst = अनुक्रमणिका = 0 जबकि अनुक्रमणिका <लेन(lst): nlst.append(lst[index] + 5)

चरण 7: "सूचकांक" चर बढ़ाएँ 1

अगली पंक्ति सरल है। एक बार इंडेक्स 0 के लिए नई संख्या की गणना करने के बाद, हम अन्य सभी इंडेक्स के लिए समान गणना करना चाहते हैं। शुक्र है, जब तक हम अंतिम इंडेक्स तक नहीं पहुंच जाते, तब तक लूप बार-बार कदमों को संभालता है! अब, हमें केवल यह सुनिश्चित करने की आवश्यकता है कि लूप अगले इंडेक्स का चयन करता है और हर बार वर्तमान इंडेक्स के साथ किया जाता है।

लूप को अगले इंडेक्स का चयन करने के लिए, हमें बस इंडेक्स वेरिएबल को 1 से बढ़ाना होगा। प्रत्येक लूप के अंत में इंडेक्स वेरिएबल को 1 से बढ़ाकर, लूप फिर से चलने पर अगले इंडेक्स को पकड़ लेगा। लूप के अंत में इंडेक्स वेरिएबल को बढ़ाने के लिए नीचे दिया गया उदाहरण कोड देखें।

डीईएफ़ ऐडफाइव (एलएसटी):

nlst = अनुक्रमणिका = 0 जबकि अनुक्रमणिका <लेन(lst): nlst.append(lst[index] + 5) अनुक्रमणिका = अनुक्रमणिका + 1

चरण 8: रिटर्न स्टेटमेंट जोड़ें

हमने इसे लूप फ़ंक्शन बनाने के अंतिम चरण में बना दिया है! अब, हम सूची को किसी भी वेरिएबल पर वापस करने के लिए केवल एक रिटर्न स्टेटमेंट जोड़ते हैं, जिसे हम इसे सेट करना चाहते हैं। रिटर्न स्टेटमेंट को अन-इंडेंट करना सुनिश्चित करें ताकि जब लूप पूरी तरह से पूरे पैरामीटर lst के माध्यम से लूप हो जाए तो यह केवल nlst लौटाएगा।

डीईएफ़ ऐडफाइव (एलएसटी):

nlst = अनुक्रमणिका = 0 जबकि अनुक्रमणिका <लेन(lst): nlst.append(lst[index] + 5) अनुक्रमणिका = अनुक्रमणिका + 1 वापसी nlst

चरण 9: जबकि लूप फ़ंक्शन का परीक्षण करें

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

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

>> ए = [1, 2, 4, 7]

>> b = addFive(a) >>> b [6, 7, 9, 12] >>> a [1, 2, 4, 7]

*सूचना सूची a AddFive फ़ंक्शन को कॉल करने के बाद समान रहती है। ऐसा इसलिए है क्योंकि हमने फ़ंक्शन बॉडी में एक नई सूची बनाई है। इसे एक गैर-विनाशकारी कार्य माना जाता है क्योंकि मूल सूची नष्ट नहीं हुई थी।

बधाई हो! आपने अपना पहला जबकि लूप पायथन में लिखा है। थोड़ी देर का लूप एक बेहतरीन टूल है जो आपको प्रोग्रामिंग करते समय चरणों के एक सेट के माध्यम से कुशलतापूर्वक लूप करने देता है। यह लूप आपको बार-बार कोड लिखने से बचने की अनुमति देकर आपको क्लीन कोड लिखने में भी मदद करता है। यदि आप कभी किसी टीम के साथ किसी प्रोजेक्ट पर काम कर रहे हैं, तो आपके प्रोग्राम को पढ़ते समय अनावश्यक कोड की अतिरिक्त पंक्तियों के माध्यम से नहीं जाने के लिए आपकी टीम के सदस्य आभारी होंगे। थोड़ी देर का लूप एक शक्तिशाली टूल है जो आपकी कोडिंग यात्रा में आपकी मदद करता रहेगा!