लूप के लिए: उदाहरण और संभावित त्रुटियां

कंप्यूटर विज्ञान में, एक लूप के लिए उपयोग किया जाता हैएक ही प्रकार की क्रिया को कई बार करना। उदाहरण के लिए, आप एक-एक करके सूची से किसी उत्पाद को निकाल सकते हैं, एक निश्चित सीमा में संख्याओं पर पुनरावृति कर सकते हैं और उनमें से प्रत्येक के लिए संबंधित स्क्रिप्ट निष्पादित कर सकते हैं।

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

अजगर में, एक लूप के लिए निम्न शामिल हैं:

• ऑपरेटर के लिए;
• असाइन किए जाने वाले चर का नाम;
• संसाधित की जा रही सूची;
• फ़ंक्शन बॉडी और अतिरिक्त ऑपरेटर।

सी जैसी भाषाओं के विपरीत, निर्देश नहीं हैंघुंघराले ब्रेसिज़ {} द्वारा सीमांकित। ऐसा करने के लिए, लूप के शरीर में स्थितियों और सारणीकरण के ब्लॉक के बाद ऑपरेटर ":" का उपयोग करें। टैब इंडेंटेशन के बिना, कोड विफल हो जाएगा और एक त्रुटि दिखाई देगी।

जैसा कि अतिरिक्त ऑपरेटर जारी रखते हैं, ब्रेक, पास का उपयोग किया जाता है - पुनरावृत्ति को छोड़ने के लिए संकेत, लूप का अंत, पुनरावृत्ति को छोड़ दें। वे कुछ इफ-शर्तों के ब्लॉक के बाद निर्दिष्ट किए जाते हैं।

पाश के लिए

इस लूप का उपयोग संग्रह के सभी तत्वों पर पुनरावृति करने के लिए किया जाता है। प्रारूप में निर्दिष्ट

सूची में चर के लिए: बयान

यह C ++ से फ़ॉरच लूप जैसा दिखता है

foreach (सेट में आइटम टाइप) {};  "हैलो दुनिया" में मैं के लिए:  प्रिंट (i * 2, अंत = "")  hheelllloo wwoorrlldd

पायथन में, लूप के लिए सहयोगी है - अनुक्रम के स्पष्ट रूप से निर्दिष्ट किए बिना सूची के प्रत्येक सदस्य के लिए शरीर के निर्देशों को निष्पादित किया जाता है। निर्देशों को सबसे इष्टतम क्रम में निष्पादित किया जाता है।

चर मैं से प्रत्येक वस्तु को सौंपा गया हैसंग्रह। सूची के तत्व संख्यात्मक और स्ट्रिंग हो सकते हैं, लेकिन वे पूर्णांक प्रकार के होने चाहिए। बहुआयामी सरणियों के साथ काम करते समय, चर I को नेस्टेड सरणियों के रूप में समझा जाएगा।

list_of_lists = [["हैमरहेड", "ग्रेट व्हाइट", "डॉगफ़िश"], [0, 1, 2], [9.9, 8.8, 7.7]  list_of_lists में सूची के लिए:  प्रिंट (सूची)  ["हैमरहेड", "ग्रेट व्हाइट", "डॉगफ़िश"]  [०, १, २]  [9.9, 8.8, 7.7]

नेस्टेड सरणी के प्रत्येक तत्व को प्रदर्शित करने के लिए, आपको नेस्टेड छोरों का उपयोग करना होगा।

जारी रखें

ऑपरेटर आपको लूप के लिए हिस्सा छोड़ देता है औरअगली यात्रा पर जाएं। यह तब किया जाता है जब कोई बाहरी कारक उत्पन्न होता है। जारी रखें यदि अतिरिक्त ब्लॉक के बाद निर्दिष्ट किया गया है, लेकिन मुख्य बयान से पहले हालत खुद ही लूप के अंदर है।

संख्या = 0  रेंज में संख्या के लिए (10):  संख्या = संख्या + 1  यदि संख्या == 5:  जारी # यहाँ जारी बयान है  प्रिंट (str (संख्या))  प्रिंट ("समाप्त")

मानों की सूची में प्रत्येक संख्या 0 से 10 तकचर संख्या में वृद्धि, जो शुरू में शून्य है। जब संख्या 5 मान पर पहुंचती है, तो लूप समाप्त हो जाएगा और अगला पुनरावृत्ति शुरू हो जाएगा। यह पता चला जाएगा:

एक  २  ३  चार  ६  ।  ।  ९  दस  समाप्त

टूटना

ऑपरेटर का उपयोग यदि इस शर्त के साथ किया जाता है। यह डिज़ाइन पूरी तरह से चक्र को बाधित करता है जब कुछ कारक होता है।

संख्या = 0  रेंज में संख्या के लिए (10):  संख्या + = 1  यदि संख्या == 5:  तोड़ना # तोड़ना  प्रिंट ("संख्या =" + स्ट्रेट (संख्या))  प्रिंट ("लूप से बाहर")

यहाँ यदि कथन एक शर्त को परिभाषित करता है: यदि चर संख्या का मान 5 है, तो लूप समाप्त हो जाता है। प्रत्येक पुनरावृत्ति पर, पहला प्रिंट () पद्धति निष्पादित होती है और एक अधिसूचना प्रदर्शित करती है

संख्या = ५।

जब लूप को ब्रेक स्टेटमेंट द्वारा समाप्त किया जाता है, तो अगला प्रिंट () विधि निष्पादित होती है।

एक अन्य उदाहरण यह जांचता है कि क्या दूसरी संख्या पहली के बिना शेष से विभाज्य है।

एन में सीमा के लिए (2, 10): सीमा में x के लिए (2, n): यदि n% x == 0: प्रिंट (n, "बराबर", x, "*", n // x) टूटना अन्य: # लूप एक कारक खोजने के बिना के माध्यम से गिर गया प्रिंट (n, "एक अभाज्य संख्या है")

इस मामले में, एक नेस्टेड लूप का उपयोग किया जाता है।सबसे पहले, 2 से 10 तक की संख्या के सेट से सभी शब्दों को n के रूप में लिया जाता है। प्रत्येक एन के लिए, 2 से एन तक के तत्वों के साथ एक नई सूची परिभाषित की गई है। इस प्रकार, हमारे पास अलग-अलग लंबाई के 8 सरणियां हैं। परिणामी संग्रह से सभी तत्व x चर द्वारा निर्दिष्ट किए गए हैं। यदि स्थिति अब जाँचती है कि n / x का परिणाम पूर्णांक मान है। यदि सही है, तो लूप टूट जाता है, स्क्रीन पर कुछ संदेश प्रदर्शित करता है। यदि n / x को शेष से विभाजित किया जाता है, तो एक और संदेश प्रदर्शित होता है।

उत्तीर्ण करना

अतिरिक्त स्थितियों को अनदेखा करने के लिए ऑपरेटर की आवश्यकता होती है।

संख्या = 0 रेंज में संख्या के लिए (10): संख्या + = 1 यदि संख्या == 5: उत्तीर्ण करना प्रिंट (str (संख्या)) प्रिंट ("समाप्त")

कार्यक्रम ऐसा व्यवहार करता है मानो संख्या == 5 मौजूद न हो। मॉनिटर प्रदर्शित करेगा

एक  २  ३  चार  पंज  ६  ।  ।  ९  दस  समाप्त

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

वर्ग MyClass (ऑब्जेक्ट):  मेथ_आ (स्व) को हराया:  उत्तीर्ण करना  डीईई मेथ_ बी (सेल्फ):  प्रिंट करें "I" m meth_b "

Meth_a फ़ंक्शन का अभी तक अपना निर्देश नहीं है। लेकिन पायथन की आवश्यकता है कि अगर, को छोड़कर, डीईएफ, वर्ग कोड ब्लॉक खाली नहीं हैं। अन्यथा, एक त्रुटि संदेश दिखाई देगा।

अभिस्थापन त्रुटि: किसी अभिस्थापन अवरोध की संभावना।

आप इसके बजाय पास निर्दिष्ट कर सकते हैं।

वर्ग CompileError (अपवाद):  उत्तीर्ण करना

पास स्टेटमेंट का उपयोग करने का एक अन्य उद्देश्य स्पष्ट रूप से कुछ नहीं करने के लिए कहना है।

यह एक और पास लूप के अन्य उदाहरण में देखा जा सकता है:

टी के लिए रेंज में (25):  करो (टी)  यदि t == 20:  उत्तीर्ण करना

यह कोड स्निपेट सूची आइटम पर पुनरावृत्त करता है0 से 25 तक। उन्हें एक चर टी के रूप में माना जाता है। प्रत्येक पुनरावृत्ति पर, कुछ कार्य () फ़ंक्शन निष्पादित होता है। यदि आप कुछ मूल्य पर कुछ भी नहीं करना चाहते हैं, तो पास निर्दिष्ट किया जाता है। उदाहरण के लिए, फ़ंक्शन 24 बार संदेश प्रिंट करता है और निर्देश को t = 20 पर छोड़ता है।

सरणियों

लूप कार्यक्रमों के लिए आप मूल्यों का एक क्रम बनाने में मदद करते हैं और उन्हें चर में असाइन करते हैं।

निम्नलिखित रिकॉर्ड संभव है:

में मैं के लिए [0, 1, 2, 3, 4, 5]:  प्रिंट मैं ** 2

यदि सूची में अधिक तत्व थे, तो एक अलग सरणी बनाना अधिक तर्कसंगत होगा।

सरणी = [1, 2, 3, 4, 5, 6, 7, 8, 9]  सरणी में:  प्रिंट करो

जैसी सूचियाँ बनाना

सरणी = [1, 2, 3, 4, 5, 6, 7, 8, 9] 

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

रेंज (0, 10, 2)

हम पाते हैं:

0, 2, 4, 6, 8, 10

स्ट्रिंग सूची

ऐसी सूचियों के साथ काम करना संख्यात्मक अंकों के समान है। उदाहरण के लिए, एक सूची है

रंग = ["लाल", "हरा", "नीला", "पीला"]

C के आदी डेवलपर्स निम्नलिखित फ़ंक्शन लिख सकते हैं।

मैं सीमा में (लेन (रंग)): प्रिंट रंग [i]

कोड त्रुटि के बिना चलेगा, लेकिन लूप के लिए अधिक सही उपयोग इस तरह दिखता है:

रंग = ["लाल", "हरा", "नीला", "पीला"] रंगों में रंग के लिए: प्रिंट का रंग

यदि आपको अंतिम से शून्य तक की सूची के माध्यम से पुनरावृति करने की आवश्यकता है, तो उलट () फ़ंक्शन का उपयोग किया जाता है।

रंग = ["लाल", "हरा", "नीला", "पीला"] उलट (रंग) में रंग के लिए: प्रिंट का रंग

निम्न प्रविष्टि गलत है। फिर, सी भाषा से एक समान बात आई।

सूचियाँ और सूचकांक

पायथन सरणी अनुक्रमणिका में हेरफेर करने के लिए अंतर्निहित एन्युमरेट () फ़ंक्शन प्रदान करता है। वे छोरों के लिए अजगर में उपयोग करने के लिए सुविधाजनक हैं।

मूल्यों का एक क्रम तर्क के रूप में लिया जाता है। एन्यूमरेट () फ़ंक्शन निम्न कोड का उपयोग करना आसान बनाता है:

i for रेंज (len (L)): आइटम = एल [i] # ... आइटम के आधार पर कुछ परिणाम की गणना करें ...

यहां लेन () पद्धति का उपयोग किया जाता है। यह तत्वों की संख्या लौटाता है, इस मामले में, सरणी एल। बहुत सारे तत्वों को सीमा () फ़ंक्शन के तर्क के रूप में स्वीकार किया जाता है। इस प्रकार, हम सूची को परिभाषित करते हैं [0, ... n]।

L [i] की मदद से हम L के प्रत्येक तत्व तक पहुँच प्राप्त करते हैं।

एल [०], एल [१], एल [२], आदि।

एनामर्ट () फ़ंक्शन काउंटर चर बी को इनिशियलाइज़ करने की आवश्यकता को समाप्त करता है और इसे लिखना आसान बनाता है

काउंटर के लिए, गणना में मान (एल): प्रिंट ("सूचकांक:" काउंटर, "मूल्य:" मूल्य) "

Enumerate () एक काउंटर-आइटम जोड़ी लौटाता है, इसलिए लूप स्टेटमेंट के लिए दो चर निर्दिष्ट किए जाते हैं।

आइटम () और पुनरावृत्तियाँ () फ़ंक्शन, जो विधियों के रूप में उपयोग किए जाते हैं, समान हैं।

d.items ()  d.ititems ()

दो सूचियाँ

जब कई सूचियों के सदस्यों का उपयोग करना आवश्यक होता है, तो ज़िप () फ़ंक्शन का उपयोग किया जाता है।

यह सूची ए और बी सूची लेता है, उनमें से एक एकल ज़िप वस्तु बनाता है, जिसमें नेस्टेड ट्यूपल्स होते हैं। नई वस्तु का प्रत्येक तत्व सूचियों A और B के सदस्यों को सम्मिलित करता है और उन्हें अनुक्रमणिका द्वारा क्रमबद्ध करता है।

zip_object [1] = [ए [1], बी [1]];

यदि ज़िप () इनपुट 4 सरणियों को निर्दिष्ट करता है,ज़िप सरणी के तत्वों में प्रत्येक में 4 तत्व होंगे। अलग-अलग लंबाई के पैकिंग सरणियों में त्रुटि नहीं होती है। केवल उन तत्वों को शामिल किया गया है जो एक वैल्यू पेयर रखते हैं।

जिप_लॉन्गेस्ट () का उपयोग टुपल में हर तत्व को शामिल करने के लिए किया जाता है, यहां तक ​​कि एक जोड़े के बिना भी।

सूची (itertools.zip_longest ((1,2,3), [4])) # [(१, ४), (२, कोई नहीं), (३, कोई नहीं)]

कुंजी के आधार पर छाँटें

जब यह न केवल किसी सरणी के तत्वों के माध्यम से जाना आवश्यक है, बल्कि इसे संशोधित करने के लिए, कुंजी () फ़ंक्शन का उपयोग किया जाता है।

विधि डुप्लिकेट और उपलब्ध शब्दकोश कुंजियों की सूची लौटाती है।

k में d.keys () के लिए: यदि k.startswith ("R"): डेल डी [के]

एक सरणी है d। इसके तत्वों की नकल कुंजी () विधि से की जाती है। प्रत्येक तत्व एक चर k है। यह स्टार्टस्विथ का उपयोग करके संसाधित किया जाता है, अगर कोई मैच होता है, तो आइटम मुख्य सरणी से हटा दिया जाता है।

स्टार्टस्विथ () एक ध्वज लौटाता है जो यह बताता है कि क्या स्ट्रिंग उपसर्ग के साथ शुरू होती है। फ़ंक्शन के तीन तर्क हैं: उपसर्ग, प्रारंभ, अंत।

str.startswith (उपसर्ग [, प्रारंभ [, अंत]]) -> बूल

केवल पहले की आवश्यकता है - उपसर्ग। यह एक स्ट्रिंग या एक ट्यूपल हो सकता है।

my_str.startswith (‘मान’)

या

my_str.startswith ((’value1’, ’value2 '))

यदि पैरामीटर फ़ील्ड में कई लाइनें आवश्यक हैं, तो तत्व अतिरिक्त कोष्ठक () में लिपटे हुए हैं।

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

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

सूचियों का मेल

यदि आपको दो सरणियों के तत्वों को जोड़ने की आवश्यकता है,सबसे तेज़ तरीका है कि आप तानाशाह (izip (सरणी 1, सरणी 1)) के तरीकों का एक गुच्छा इस्तेमाल करें। इस मामले में, तत्वों को एक के बाद एक क्रमिक रूप से व्यवस्थित नहीं किया जाता है, लेकिन इस रूप में:

'एरे तत्व 1': 'एरे तत्व 2'

नाम = ["रेमंड", "रैशेल", "मैथ्यू"] रंग = ["लाल", "हरा", "नीला"] डी = तानाशाही (ज़िप, नाम, रंग) # {"मैथ्यू": "ब्लू", "रैशेल": "ग्रीन", "रेमंड": "रेड"}

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

d ['रेमंड']  # नस्ल

एक सूची के सदस्यों की गिनती

यह जानने के लिए कि किसी सूची में कितने तत्व हैं, गेट () फ़ंक्शन का उपयोग करें।

d.get (कुंजी, डिफ़ॉल्ट = कोई नहीं)

यह विधि कुंजी की उपस्थिति के लिए डिक्शनरी की जांच करती है, और इंडेक्स कुंजी [इंडेक्स] को लौटा देती है।

रंग = ["लाल", "हरा", "लाल", "नीला", "हरा", "लाल"] d = {} रंगों में रंग के लिए: d [रंग] = d.get (रंग, ०) + १

Get () विधि निम्नलिखित कोड का अधिक सुविधाजनक और तेज़ एनालॉग है।

रंग = ["लाल", "हरा", "लाल", "नीला", "हरा", "लाल"]  d = {}  रंगों में रंग के लिए:  यदि रंग d में नहीं है:  घ [रंग] = ०  d [रंग] + = 1

लूप के लिए ये मूल उदाहरण और संभावित त्रुटियां हैं।