लूप्स
ऐसी स्थिति की कल्पना करें जहां हमें "
Hello" 10 बार। हमें क्या करना चाहिए?
आप कमांड को 10 बार ले और लिख सकते हैं
print("Hello")
<पूर्व>
प्रिंट ("हैलो")
प्रिंट ("हैलो")
प्रिंट ("हैलो")
प्रिंट ("हैलो")
प्रिंट ("हैलो")
प्रिंट ("हैलो")
प्रिंट ("हैलो")
प्रिंट ("हैलो")
प्रिंट ("हैलो")
प्रिंट ("हैलो")
लेकिन क्या होगा अगर आपको 10 बार नहीं, बल्कि 20, 30, 40 बार की जरूरत है? और अगर 200 बार? ऐसे में नकल में काफी समय लगेगा। और यदि यह आवश्यक है कि उपयोगकर्ता स्वयं यह चुन सके कि उसे कितनी बार स्क्रीन पर कुछ जानकारी प्रदर्शित करने की आवश्यकता है?
एक विशेष निर्माण हमें इस कार्य से निपटने में मदद करेगा,
जिसे
लूप कहा जाता है।
लूप - एक एल्गोरिद्मिक कंस्ट्रक्शन है जिसमें कमांड्स का एक निश्चित क्रम कई बार दोहराया जाता है।< /दिवि>
अधिकांश प्रोग्रामिंग भाषाओं में, दो प्रकार के लूप होते हैं: एक चर के साथ एक लूप (<कोड>के लिए) और एक शर्त के साथ एक लूप (<कोड>जबकि)
चलिए पहले प्रकार से साइकिल से परिचित होना शुरू करते हैं।
एक चर के साथ लूप, या चरणों की एक ज्ञात संख्या के साथ (लूप <कोड>के लिए)
अक्सर ऐसा होता है कि हम किसी क्रिया की पुनरावृत्ति की संख्या जानते हैं, या हम ज्ञात डेटा का उपयोग करके दोहराव की संख्या की गणना कर सकते हैं। कुछ प्रोग्रामिंग लैंग्वेज में एक कमांड होती है जो कमांड द्वारा रूसी में लिखी जाती है
REPEAT (number_of_repetitions)।
इस मामले में, हम दोहराव की एक विशिष्ट संख्या निर्दिष्ट कर सकते हैं।
यह देखना दिलचस्प है कि यह चक्र मशीन स्तर पर कैसे काम करता है:
1. एक निश्चित मेमोरी सेल को मेमोरी में आवंटित किया जाता है और उसमें दोहराव की संख्या लिखी जाती है,
2. जब प्रोग्राम लूप बॉडी को एक बार निष्पादित करता है, तो इस सेल (काउंटर) की सामग्री एक से कम हो जाती है।
3. इस सेल के शून्य होने पर लूप निष्पादन समाप्त हो जाता है।
Python में ऐसा कोई निर्माण नहीं है, लेकिन एक for है।
<दिव>
याद रखने की जरूरत है!
for लूप ऑपरेटर का सामान्य रूप इस प्रकार है:
<पूर्व>
<गिनती चर> <काउंटर वेरिएबल के मान> में:
# लूप बॉडी
1. काउंटर वेरिएबल का नाम कुछ भी हो सकता है (अधिक बार वे अक्षर i)
का उपयोग करते हैं
2. लूप हेडर (के लिए) के साथ लाइन के सापेक्ष लूप बॉडी को दाईं ओर शिफ्ट के साथ लिखा गया है। PEP8 मानक 4 रिक्त स्थान से बदलता है।
आइए उदाहरण देखें कि आप "
Hello" शब्द का आउटपुट कैसे लिख सकते हैं। 10 बार।
उदाहरण 1
<पूर्व>
फॉर आई इन रेंज (10): # वेरिएबल i के लिए रेंज में म्यूटेबल (रेंज में)
# 0 से 10 (10 शामिल नहीं है)
प्रिंट ("हैलो") # प्रिंट हैलो
i चर लूप के पूर्ण पुनरावृत्तियों (चरणों) का एक काउंटर है। इस मामले में, लूप
i = 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 के लिए चलता है। यह ठीक 10 गुना है।
एक ही प्रोग्राम को अलग तरह से लिखा जा सकता है।
उदाहरण 2
<पूर्व>
मैं के लिए [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] में:
प्रिंट ("हैलो")
उदाहरण 2 में, हम वेरिएबल
i के सभी मानों को सूचीबद्ध करते हैं जिसके लिए हमें लूप की आवश्यकता होती है। बड़ी संख्या में मानों के साथ, अंतर्निहित फ़ंक्शन
श्रेणी() का उपयोग करना अधिक सुविधाजनक है।
श्रेणी() फ़ंक्शन द्वारा निर्मित मानों का क्रम परिमित है। लूप हमेशा समाप्त होगा।