(पायथन) लूप्स। काउंटर के साथ लूप - के लिए


लूप्स

ऐसी स्थिति की कल्पना करें जहां हमें "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 के सभी मानों को सूचीबद्ध करते हैं जिसके लिए हमें लूप की आवश्यकता होती है। बड़ी संख्या में मानों के साथ, अंतर्निहित फ़ंक्शन श्रेणी()
का उपयोग करना अधिक सुविधाजनक है।  श्रेणी() फ़ंक्शन द्वारा निर्मित मानों का क्रम परिमित है। लूप हमेशा समाप्त होगा। 

Training problem

प्रोग्रामिंग में लूप्स

के लिए

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

फ़ंक्शन प्रविष्टि का सामान्य रूप इस प्रकार है: <पूर्व> श्रेणी([प्रारंभ], रोकें[, कदम]) <उल>
  • प्रारंभ करें: अनुक्रम की प्रारंभ संख्या।
  • रोकें: संख्या तक संख्या उत्पन्न करता है लेकिन दिए गए नंबर को शामिल नहीं करता है।
  • चरण: अनुक्रम (चरण) में प्रत्येक संख्या के बीच का अंतर
    • <दिव>

    आपको याद रखना होगा!
    <उल>
  • सभी पैरामीटर पूर्णांक होने चाहिए:
  • प्रत्येक पैरामीटर सकारात्मक या नकारात्मक हो सकता है।
  • श्रेणी() (और सामान्य रूप से Python) इंडेक्स 0 पर आधारित है। इसका मतलब है कि इंडेक्स सूची 0 से शुरू होती है, 1 से नहीं।  फ़ंक्शन  श्रेणी()  रोकें पर निर्भर करता है लेकिन इसे शामिल नहीं करेगा। उदाहरण के लिए, श्रेणी(0, 5) पूर्णांक 0, 1, 2, 3, 4 उत्पन्न करता है, 5 सहित नहीं।


    • उदाहरण 1
    <पूर्व> मैं सीमा में (10, 0, -1) के लिए: प्रिंट (मैं * मैं) कार्यक्रम अवरोही क्रम में 10 से 1 तक प्राकृतिक संख्याओं के वर्गों को प्रदर्शित करता है <उल>
  • 10: अनुक्रम में पहला अंक।
  • 0: अनुक्रम की अंतिम संख्या (इस संख्या को छोड़कर)।
  • -1: चरण


    • उदाहरण 2
    <पूर्व> मैं सीमा में (0, 101, 5) के लिए: प्रिंट (मैं) कार्यक्रम 5 की वृद्धि में 0 से 100 तक सभी संख्याओं को प्रदर्शित करता है <उल>
  • 0: अनुक्रम में पहला अंक।
  • 101: अनुक्रम की अंतिम संख्या (इस संख्या को छोड़कर)।
  • 5: चरण

    • Training problem

    लूप के लिए सुविधाएँ

    एन बार दोहराएं

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

    उदाहरण के लिए, हमें 1 से N तक की संख्याओं के वर्ग प्रदर्शित करने की आवश्यकता है, जहां वेरिएबल N का मान कीबोर्ड से दर्ज किया जाता है उपयोगकर्ता।
    इस तरह दिखेगा कार्यक्रम: <पूर्व> एन = इंट (इनपुट ()) # कीबोर्ड से इनपुट एन for i in range(1, N+1): # लूप: सभी i के लिए 1 से N  - वेरिएबल i # क्रमिक रूप से 1 से N तक मान लेगा   प्रिंट ("वर्ग", i, "=", i*i)  # किसी संख्या का वर्ग प्रिंट करें लूप में प्रवेश करते समय, असाइनमेंट स्टेटमेंट i = 1 निष्पादित किया जाता है, और फिर वेरिएबल i को प्रत्येक चरण के साथ एक से बढ़ाया जाता है (i += 1 कोड>)। स्थिति i <= N के सत्य होने पर लूप निष्पादित किया जाता है। लूप की बॉडी में, केवल आउटपुट स्टेटमेंट ही संख्या और उसके वर्ग को निर्दिष्ट प्रारूप के अनुसार स्क्रीन पर प्रिंट करता है।
    वर्ग करने या अन्य निम्न घातांकों के लिए, गुणन का उपयोग करना बेहतर होता है।

    प्रोग्राम को रन करें और वेरिएबल N के विभिन्न मानों के साथ इसके कार्य का परिणाम देखें।
     
     

    Training problem

    एन बार दोहराएं