Python मध्ये loop असताना. ते कसे कार्य करते, वापराची उदाहरणे

लूप हे कोणत्याही भाषेच्या मुख्य साधनांपैकी एक आहे. Python मध्ये दोन मूलभूत लूप आहेत, त्यापैकी एक आहे while. याचा विचार करा, आणि चित्राच्या अधिक चांगल्या प्रकारे समजून घेण्यासाठी, आणखी एक. खरंच, तत्सम एखाद्या गोष्टीच्या तुलनेत, कोणतीही सामग्री समजून घेणे खूप सोपे आहे, नाही का?

सायकलची संकल्पना

जेव्हा एखादी विशिष्ट क्रिया अनेक वेळा करावी लागते तेव्हा लूप आवश्यक असतो. हे खूप सोपे आहे, कारण प्रत्यक्षात सायकलसाठी अनुप्रयोगांची श्रेणी खूप विस्तृत आहे. Python मध्ये लूपचे दोन मुख्य प्रकार आहेत: for आणि while. साठी सर्वात लोकप्रिय आहे.

विशिष्ट क्रियांव्यतिरिक्त, तुम्ही एका विशिष्ट बिंदूपर्यंत कोडचे वेगवेगळे तुकडे लूप करू शकता. हे ठराविक वेळा असू शकते, किंवा जोपर्यंत विशिष्ट स्थिती सत्य आहे तोपर्यंत.

आम्ही लूपचे प्रकार समजून घेण्यास सुरुवात करण्यापूर्वी आणि विशेषतः, आम्हाला अद्याप पुनरावृत्ती म्हणजे काय हे समजून घेणे आवश्यक आहे. वर्तमान ऍप्लिकेशन रनमध्ये चालू चक्रादरम्यान क्रियेची ही एक पुनरावृत्ती किंवा क्रियेचा क्रम आहे.

साठी सायकल

इतर अनेक भाषांप्रमाणे आमचे फॉर लूप हे काउंटर नाही. त्याचे कार्य मूल्यांच्या विशिष्ट क्रमांची गणना करणे आहे. याचा अर्थ काय? समजा आपल्याकडे घटकांची यादी आहे. प्रथम, लूप प्रथम, द्वितीय, तृतीय, इत्यादी घेते.

पायथनमधील या लूपचा फायदा असा आहे की लूपमधून कधी बाहेर पडायचे हे जाणून घेण्यासाठी तुम्हाला घटकाची अनुक्रमणिका निर्धारित करण्याची आवश्यकता नाही. सर्व काही आपोआप होईल.

>>> स्पिसोक = [१०, ४०, २०, ३०]

>>> spisok मधील घटकासाठी:

… प्रिंट (घटक + 2)

...

12

42

22

32

आमच्या उदाहरणात, आम्ही व्हेरिएबल वापरले घटक फॉर कमांड नंतर. सर्वसाधारणपणे, नाव काहीही असू शकते. उदाहरणार्थ, एक लोकप्रिय पदनाम म्हणजे i. आणि प्रत्येक पुनरावृत्तीसह, या व्हेरिएबलला सूचीमधून एक विशिष्ट ऑब्जेक्ट नियुक्त केला जाईल, ज्याला आम्ही योग्य शब्द म्हणतो.

आमच्या बाबतीत, यादी 10,40,20,30 संख्यांचा क्रम आहे. प्रत्येक पुनरावृत्तीवर, व्हेरिएबलमध्ये संबंधित मूल्य दिसून येते. उदाहरणार्थ, लूप सुरू होताच, व्हेरिएबल घटक मूल्य 10 नियुक्त केले आहे. पुढील पुनरावृत्तीवर, दहा संख्या 40 मध्ये वळते, तिसऱ्या वेळी ते 20 क्रमांकामध्ये बदलते आणि शेवटी, लूपच्या शेवटच्या पुनरावृत्तीवर, ते 30 मध्ये बदलते.

चक्राच्या समाप्तीचा सिग्नल सूचीमधील घटकांचा शेवट आहे.

इतर प्रोग्रामिंग भाषांप्रमाणे मूल्यांची क्लासिक गणन करण्यासाठी तुम्हाला लूपची आवश्यकता असल्यास, आम्हाला आवश्यक असलेल्या मूल्यापर्यंत नैसर्गिक संख्यांचा क्रम असलेली सूची तयार करावी.

>>> स्पिसोक = [१,२,३,४,५]

किंवा फंक्शन वापरा लेन(), यादीची लांबी निश्चित करण्यासाठी. परंतु या प्रकरणात लूप वापरणे चांगले आहे असताना, कारण व्हेरिएबल वापरण्याची गरज नाही.

जर तुम्हाला सूचीतील मूल्यांचा क्रम बदलायचा असेल तर लूप करा साठी आणि येथे बचावासाठी येतो. हे करण्यासाठी, प्रत्येक पुनरावृत्तीवर, सूचीतील प्रत्येक घटकास योग्य मूल्य नियुक्त करणे आवश्यक आहे.

पळवाट असताना

सायकलच्या विपरीत साठी, जे फक्त अनुक्रम, लूपच्या मूल्यांवर पुनरावृत्ती करते तर अधिक उपयोग आहेत. या प्रकारच्या चक्रांचे नाव "अद्याप" असे भाषांतरित केले आहे. म्हणजे, “तोपर्यंत”.

हा एक सार्वत्रिक लूप आहे जो सर्व प्रोग्रामिंग भाषांमध्ये आढळतो. आणि काही मार्गांनी ते सशर्त ऑपरेटरसारखे दिसते यू, जे विशिष्ट अट पूर्ण झाले आहे की नाही हे पाहण्यासाठी तपासणी करते. केवळ सशर्त ऑपरेटरच्या विरूद्ध, तर प्रत्येक पुनरावृत्तीवर तपासणी करते, फक्त एकदाच नाही. आणि कंडिशन असत्य असेल तरच, लूप संपतो आणि त्यानंतर येणारी कमांड कार्यान्वित केली जाते. सोप्या शब्दात, जर तो ज्या परिस्थितीत काम करतो तो यापुढे वैध नसेल.

जर आपण सायकल काढली तर साधेपणाने, हे अशा योजनेचा वापर करून केले जाते.Python मध्ये loop असताना. ते कसे कार्य करते, वापराची उदाहरणे

प्रोग्रामची मुख्य शाखा (जी लूपच्या बाहेर चालते) या आकृतीमध्ये निळ्या आयताने चित्रित केली आहे. नीलमणी चक्राच्या शरीराचे प्रतिनिधित्व करते. या बदल्यात, समभुज चौकोन ही अशी स्थिती आहे जी प्रत्येक पुनरावृत्तीवर तपासली जाते.

चक्र तर दोन अपवाद होऊ शकतात:

  1. जर लूपच्या सुरूवातीस तार्किक अभिव्यक्ती सत्यात परत येत नसेल, तर ते कार्यान्वित होण्यापूर्वी पूर्ण झाल्यानंतर सुरू होत नाही. सर्वसाधारणपणे, ही परिस्थिती सामान्य आहे, कारण विशिष्ट परिस्थितीत, अनुप्रयोग लूप बॉडीमध्ये अभिव्यक्तींच्या उपस्थितीसाठी प्रदान करू शकत नाही.
  2. अभिव्यक्ती नेहमी सत्य असल्यास, यामुळे पळवाट होऊ शकते. म्हणजेच सायकलच्या अंतहीन स्क्रोलिंगपर्यंत. म्हणून, अशा प्रोग्राममध्ये, नेहमी लूप किंवा प्रोग्राममधून एक्झिट स्टेटमेंट असावे. तथापि, जर प्रोग्राम एखाद्या विशिष्ट स्थितीचे सत्य किंवा असत्यता निर्धारित करण्यात सक्षम असेल तर ही परिस्थिती उद्भवेल. जर ती हे करण्यात अयशस्वी झाली, तर प्रोग्रामच्या समाप्तीसह त्रुटी परत केली जाईल. किंवा आपण त्रुटी हाताळू शकता, आणि नंतर, ती आढळल्यास, विशिष्ट कोड कार्यान्वित केला जाईल.

एरर कशी हाताळायची यासाठी अनेक पर्याय असू शकतात. उदाहरणार्थ, प्रोग्राम वापरकर्त्यास योग्यरित्या डेटा प्रविष्ट करण्यास सांगू शकतो. म्हणून, जर एखाद्या व्यक्तीने नकारात्मक संख्या दर्शविली जिथे ती फक्त सकारात्मक असू शकते किंवा अक्षरे प्रविष्ट केली जिथे फक्त संख्या असावी, तर प्रोग्राम त्याबद्दल सांगू शकतो.

लूप उदाहरणे असताना

येथे कोडचे एक उदाहरण आहे जे या प्रकरणात त्रुटी हाताळते.

n = इनपुट ("पूर्णांक प्रविष्ट करा: ") 

टाइप करताना (n) != int:

    प्रयत्न:

        n = int(n)

    व्हॅल्यूएरर वगळताः

        प्रिंट ("चुकीची नोंद!")

        n = इनपुट ("पूर्णांक प्रविष्ट करा: ") 

जर n % 2 == 0:

    मुद्रित करा (“सम”)

अन्यथा:

    प्रिंट ("विचित्र")

लक्षात ठेवा की जटिल कोड रचना घोषित करण्यासाठी पायथन कोलन वापरतो.

वरील कोडमध्ये, आम्ही एक अट म्हणून परिभाषित केले आहे की आम्ही संख्या पूर्णांक आहे की नाही हे तपासले पाहिजे. जर होय, तर खोटे परत केले जाईल. नसेल तर खरे.

कोडच्या दुसऱ्या भागात, जिथे ऑपरेटर वापरला जातो if, विभागणी ऑपरेशननंतर उर्वरित शोधण्यासाठी आम्ही % ऑपरेटर वापरला. पुढील पायरी म्हणजे संख्या सम आहे का ते तपासणे. नसल्यास, या प्रकरणात उर्वरित एक आहे. त्यानुसार, संख्या विषम आहे. 

सोप्या भाषेत, वरील कोड प्रथम वापरकर्त्याने प्रविष्ट केलेली स्ट्रिंग संख्या आहे का ते तपासते. जर होय, तर दोनने भागाकार शिल्लक आहे का हे पाहण्यासाठी दुसरी तपासणी केली जाते. परंतु वापरकर्त्याने प्रविष्ट केलेले मूल्य संख्यात्मक होईपर्यंत दुसरा ब्लॉक कार्यान्वित केला जाणार नाही.

म्हणजेच, स्थिती येईपर्यंत लूप नियमितपणे अंमलात येईल. या परिस्थितीत, हे असे कार्य करते. 

म्हणजेच, तुम्ही विरुद्ध दिशेने जाऊ शकता: घटना खोटी होईपर्यंत एक विशिष्ट क्रिया लूप करा.

कोड पार्सिंग

आता हा कोड कसा काम करतो ते अधिक तपशीलवार पाहू. हे करण्यासाठी, आम्ही चरण-दर-चरण विश्लेषण करू.

  1. प्रथम, वापरकर्ता एक स्ट्रिंग प्रविष्ट करतो, जी व्हेरिएबल n द्वारे स्वीकारली जाते. 
  2. लूप वापरणे तर या व्हेरिएबलचा प्रकार तपासला आहे. पहिल्या प्रवेशावर, ते समान नाही int. त्यामुळे चाचणीच्या परिणामी ही स्थिती खरी असल्याचे आढळून आले आहे. म्हणून, लूप बॉडीमध्ये प्रवेश केला जातो.
  3. ऑपरेटरच्या मदतीने प्रयत्न आम्ही स्ट्रिंगला नंबरमध्ये रूपांतरित करण्याचा प्रयत्न करत आहोत. जर हे केले तर कोणतीही त्रुटी उद्भवणार नाही. त्यानुसार, त्यावर प्रक्रिया करण्याची आवश्यकता नाही. म्हणून, दुभाषी लूपच्या सुरूवातीस परत येतो आणि तपासणीच्या निकालांनुसार, तो पूर्णांक बनला आहे. तर चरण 7 वर जाऊया
  4. जर रूपांतरण अयशस्वी झाले, तर व्हॅल्यूएरर टाकली जाईल. या प्रकरणात, प्रोग्राम प्रवाह वगळता हँडलरकडे पाठविला जातो.
  5. वापरकर्ता नवीन मूल्य प्रविष्ट करतो, जे व्हेरिएबल n ला नियुक्त केले जाते.
  6. दुभाषी चरण 2 वर परत येतो आणि पुन्हा तपासतो. पूर्णांक मूल्य असल्यास, चरण 7 वर जा. नसल्यास, चरण 3 नुसार रूपांतरणाचा पुन्हा प्रयत्न केला जाईल.
  7. ऑपरेटरच्या मदतीने if संख्येला 2 ने भाग केल्यावर काही शिल्लक आहे का ते निर्धारित करते. 
  8. नसल्यास, "सम" मजकूर परत केला जातो.
  9. नसल्यास, "विचित्र" मजकूर परत केला जातो.

आता अशाच उदाहरणाचा विचार करा. हे चक्र किती वेळा जाईल हे ठरवण्याचा प्रयत्न करा?

एकूण = 100 

मी = 0

मी < 5 असताना:

    n = int(इनपुट())

    एकूण = एकूण — n

    i = i + 1 

प्रिंट ("उर्वरित", एकूण)

बरोबर उत्तर 5 आहे. सुरुवातीला व्हेरिएबलचे मूल्य i - शून्य. दुभाषी व्हेरिएबल समान आहे का ते तपासतो i 4 किंवा कमी. जर होय, तर मूल्य परत केले जाईल. खरे, आणि त्यानुसार लूप कार्यान्वित केला जातो. मूल्य एकाने वाढले आहे.

पहिल्या पुनरावृत्तीनंतर, व्हेरिएबलचे मूल्य 1 होते. एक तपासणी केली जाते आणि प्रोग्रामला समजते की ही संख्या पुन्हा 5 पेक्षा कमी आहे. त्यानुसार, लूप बॉडी दुसऱ्यांदा कार्यान्वित केली जाते. पायऱ्या सारख्या असल्याने, मूल्य देखील एक ने वाढले आहे आणि व्हेरिएबल आता 2 च्या बरोबरीचे आहे.

हे मूल्य देखील पाचपेक्षा कमी आहे. नंतर लूप तिसऱ्यांदा चालवला जातो, व्हेरिएबलमध्ये जोडला जातो i 1 आणि त्याला मूल्य 3 नियुक्त केले आहे. हे पुन्हा पाच पेक्षा कमी आहे. आणि म्हणून ते लूपच्या सहाव्या पुनरावृत्तीवर येते, ज्यावर व्हेरिएबलचे मूल्य असते i 5 च्या बरोबरीचे (आमच्या लक्षात येईपर्यंत ते मूळतः शून्य होते). त्यानुसार, ही स्थिती चाचणी उत्तीर्ण होत नाही, आणि लूप आपोआप संपुष्टात आणला जातो आणि पुढील चरणावर संक्रमण, जे त्याच्या बाहेर आहे (किंवा प्रोग्राम समाप्ती, जर खालील चरण प्रदान केले नाहीत तर) चालते.

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

एकूण = 100 

एकूण > ० असताना:

    n = int(इनपुट())

    एकूण = एकूण — n 

प्रिंट ("संसाधन संपले")

हा प्रोग्राम काय करतो याचा अंदाज लावण्याचा प्रयत्न करा! याची कल्पना करा व्हेरिएबलमध्ये एकूण प्रोग्राम संसाधनाविषयी माहिती संग्रहित केली जाते. प्रत्येक वेळी दुभाषी संसाधन अस्तित्वात आहे का ते तपासतो. नसल्यास, "संसाधन संपले" हा मजकूर प्रदर्शित होईल आणि प्रोग्राम बंद होईल. आणि लूपच्या प्रत्येक पुनरावृत्तीसह, वापरकर्त्याने निर्दिष्ट केलेल्या संख्येने संसाधन कमी होते.

आणि आता गृहपाठ. वरील कोड बदलण्याचा प्रयत्न करा जेणेकरून व्हेरिएबल भौतिकरित्या नकारात्मक होऊ शकत नाही. 

3 टिप्पणी

  1. si कोड ahaan usoo गुडबी

प्रत्युत्तर द्या