python loops while
यह वीडियो ट्यूटोरियल पायथन में लूप्स की भूमिका, उनके प्रकारों की व्याख्या करता है: क्योंकि, जबकि, वाक्य रचना और व्यावहारिक प्रोग्रामिंग के साथ नेस्टेड लूप्स:
हमने चार अलग-अलग के बारे में सीखा पायथन में सशर्त बयान हमारे पिछले ट्यूटोरियल में।
लूप्स शक्तिशाली प्रोग्रामिंग अवधारणाएं हैं जो लगभग सभी आधुनिक प्रोग्रामिंग भाषाओं द्वारा समर्थित हैं। यह एक कार्यक्रम को पुनरावृत्तियों को लागू करने की अनुमति देता है, जिसका मूल रूप से कोड दो या अधिक बार एक ही ब्लॉक को निष्पादित करना है।
यद्यपि वे सभी आधुनिक प्रोग्रामिंग भाषाओं द्वारा समर्थित हैं और समान बुनियादी कार्यक्षमता प्रदान करते हैं, उनके कार्यान्वयन और वाक्यविन्यास भिन्न हो सकते हैं।
अजगर पर पूर्ण प्रशिक्षण श्रृंखला आपको इस बारे में एक संक्षिप्त विचार देगा कि अजगर क्या है।
आप क्या सीखेंगे:
- पायथन लूप्स वीडियो ट्यूटोरियल
- क्या पायथन लूप हैं
- पायथन में लूप के लिए
- जबकि लूप
- अंतर प्रविष्ट पाश
- पायथन अनंत लूप्स
- निष्कर्ष
पायथन लूप्स वीडियो ट्यूटोरियल
क्या पायथन लूप हैं
पायथन में, कथनों को क्रमबद्ध तरीके से निष्पादित किया जाता है यानी यदि हमारा कोड कई लाइनों से बना होता है, तो निष्पादन पहली पंक्ति में शुरू होगा, उसके बाद दूसरा, और इसी तरह से।
हालांकि, ऐसे मामले होंगे जहां हम एक शर्त पूरी होने तक कई बार निष्पादित करने के लिए कोड का एक ब्लॉक चाहते हैं। लूप स्टेटमेंट के लिए धन्यवाद, हम ऐसा कर सकते हैं।
नीचे दिया गया एक फ़्लोचार्ट है जो दिखाता है कि लूप स्टेटमेंट कैसे काम करता है।
उपरोक्त आरेख के आधार पर, पायथन कार्यक्रम शुरू होगा शुरू (सर्कल), और निष्पादन स्थिति स्टेटमेंट (डायमंड) के लिए आगे बढ़ेगा, यदि स्थिति TRUE है, तो प्रोग्राम कोड ब्लॉक निष्पादित करेगा।
निष्पादन स्थिति की स्थिति पर फिर से आगे बढ़ेगा और जब भी स्थिति सही हो, तब भी यही प्रक्रिया जारी रहेगी। यह केवल लूप से बाहर निकलता है या कोड ब्लॉक को निष्पादित करना बंद कर देता है यदि स्थिति FALSE है, और इस मामले में, कार्यक्रम क्रमिक रूप से निष्पादन जारी रखेगा।
पायथन में दो प्रकार के लूप होते हैं।
| # | पाश प्रकार | विवरण |
|---|---|---|
| 1 | पाश के लिए | एक पुनरावृत्त आधारित लूप है, जो उस पुनरावृत्त वस्तु में वस्तुओं की संख्या के आधार पर कई बार सूचियों, टुपल्स, स्ट्रिंग जैसी पुनरावृत्त वस्तुओं की वस्तुओं के माध्यम से कदम रखता है और कई बार कोड का एक टुकड़ा निष्पादित करता है। |
| दो | घुमाव के दौरान | जब तक स्थिति TRUE न हो जाए तब तक बार-बार बयानों का एक खंड निष्पादित करें। |
इन दो प्रकार के छोरों का उपयोग एक दूसरे के अंदर उत्पन्न करने के लिए किया जा सकता है स्थिर फंदा (इस पर बाद में)।
पायथन लूप्स का सामान्य उपयोग
पायथन में, भयानक और जटिल समस्याओं को हल करने के लिए छोरों का उपयोग किया जा सकता है। आपको ऐसी समस्याओं का सामना करने की आवश्यकता होगी जो एक शर्त पूरी होने तक आपको एक कार्रवाई को दोहराने की आवश्यकता होगी (जबकि लूप यहां सबसे अच्छा काम करता है) या एक समस्या जो आपको वस्तुओं के एक समूह पर कार्रवाई करने की आवश्यकता होती है (लूप यहां सबसे अच्छा काम करता है)।
पायथन में लूप के लिए
पाश के लिए अच्छी तरह से iterable वस्तुओं के साथ काम करता है सूचियों , टुपल्स , स्ट्रिंग्स , आदि इस तरह, हम इन ऑब्जेक्ट्स के माध्यम से कदम उठा सकते हैं और हमारे लिंकिंग के आधार पर उनके मूल्यों में हेरफेर कर सकते हैं।
पाश के लिए शून्य-अनुक्रमित है और इसमें निम्नलिखित सिंटैक्स है।
for in n:में हालत पाश के लिए केवल TRUE ही रहता है, यदि यह सभी वस्तुओं के माध्यम से iterable ऑब्जेक्ट (n) में पुनरावृत्त नहीं हुआ है। बेहतर समझने के लिए पाश के लिए , हम कई उदाहरणों को संबोधित करेंगे और अंत में, हम एक व्यावहारिक उदाहरण पर काम करेंगे।
उदाहरण 1:प्रारंभ से अंत तक की संख्याएँ प्रिंट करें
इसे प्राप्त करने के लिए, हम पायथन का उपयोग करेंगे रेंज समारोह।
यह फ्लोचार्ट कैसा दिखेगा:
def range_from_start_to_end(start, end): for i in range(start, end+1): print(i) if __name__ == '__main__': start = int(input('Enter a start number: ')) end = int(input('Enter an end number: ')) # Call our function to print the ranges range_from_1_to_20(start, end) उत्पादन
उपरोक्त उदाहरण में, हमने पायथन रेंज का उपयोग किया, जो एक ऐसा फ़ंक्शन है जो संख्याओं का एक क्रम देता है, जो एक से शुरू होता है शुरू संख्या (डिफ़ॉल्ट रूप से 0), वेतन वृद्धि कदम (डिफ़ॉल्ट रूप से), और ए से पहले बंद हो जाता है समाप्त संख्या।
इस उदाहरण के लिए, हमारे पास निम्नलिखित हैं:
पायथन रेंज फ़ंक्शन के लिए पैरामीटर और मान
| मापदंडों | मूल्य |
|---|---|
| शुरू | 1 |
| समाप्त | बीस |
| कदम | 1 (डिफ़ॉल्ट मान) |
तो हमारा पाश के लिए 1 से 20 तक संख्याओं के अनुक्रम के माध्यम से पुनरावृत्ति करेगा, और प्रत्येक पुनरावृत्ति के लिए, यह संख्या को प्रिंट करेगा। अनुक्रम में सभी संख्याओं का दौरा किए जाने पर पुनरावृत्ति रुक जाती है।
उदाहरण 2:निर्धारित करें कि कोई संख्या एक अभाज्य संख्या है।
इस उदाहरण में, हम देखेंगे कि क्यों पाश के लिए इतना शक्तिशाली और उपयोगी है। यहां, हम संख्याओं के अनुक्रम के माध्यम से पुनरावृत्ति करेंगे, और प्रत्येक संख्या के लिए, हम यह निर्धारित करने के लिए कुछ गणना करेंगे कि क्या हालत TRUE या FALSE है।
यह एक संख्या के लिए शर्तों को जानने में मदद कर सकता है प्रधान होने के लिए।
- संख्या हमेशा सकारात्मक है, 1 से अधिक है।
- 1 और खुद के अलावा कोई सकारात्मक विभाजक नहीं है।
def isPrime(number): # rule 1: number should be positive, and greater than 1. if number > 1: # iterate over a range from 2 to half the number. for i in range(2, number//2): # rule 2: shouldn't have any positive divisor # order than 1 and itself. if(number % i) ==0: return False return True else: return False if __name__ == '__main__': number = int(input('Enter number to check if it's prime: ')) if isPrime(number): print('{} is a prime number'.format(number)) else: print('{} is not a prime number'.format(number)) इनपुट 13 होने पर आउटपुट
इनपुट 10 होने पर आउटपुट
ध्यान दें: यदि नहीं तो उपरोक्त उदाहरण में प्रयुक्त एक सशर्त कथन है और लूप नहीं है। लेकिन बस की तरह घुमाव के दौरान (जिसे हम जल्द ही कवर करेंगे), यह अपनी स्थिति के लिए तुलना ऑपरेटरों का उपयोग करता है।
उदाहरण - लूप के लिए एक पाठ में शब्द गणना खोजें
यह उदाहरण गिनती के बारे में है कि प्रत्येक शब्द एक पाठ में कितनी बार होता है। ऐसे कई तरीके हैं जिनसे इसे हासिल किया जा सकता है लेकिन इस उदाहरण के लिए, हम इसका उपयोग करेंगे पाश के लिए ।
हम नीचे दिए गए पाठ से शब्द गिन रहे होंगे।
नमस्कार, सॉफ्टवेयर टेस्टिंग हेल्प में आपका स्वागत है। इस लेख में: 'पायथन में लूप्स', आप व्यावहारिक उदाहरणों के साथ लूप के बारे में सीखेंगे। महान सही है? जैसा कि हम एक साथ सीखते हैं, उसका पालन करना सुनिश्चित करें।
हैप्पी कोडिंग!
पहली चीज जो हम करेंगे, वह है पंक्चुएशन, व्हॉट्सएप और सभी लोअरकेस लेटर्स को हटाना। हम अपने पाठ में कौन से विराम चिह्न मौजूद हैं, पहचान कर पारंपरिक तरीके से विराम चिह्न हटा देंगे, और फिर उपयोग करें पाश के लिए एक खाली स्ट्रिंग के साथ उन्हें बदलने के लिए।
जैसा कि पाठ ज्यादा नहीं है, हम देखते हैं कि विराम चिह्न हैं अल्पविराम के (,), अवधि (।), प्रश्न चिह्न (?), पेट (:), दोहरा उद्धरण चिह्न (') तथा apostrophe (() है।
नीचे दिया गया कोड उन्हें एक खाली स्ट्रिंग के साथ बदलने के लिए है। ध्यान दें कि हम एपोस्ट्रोफ की जगह नहीं लेंगे।
# replace punctuation(except apostrophe) and white spaces for punc in '.,
?!'': text = text.replace(punc, '') # lowercase all letters. text = text.lower() उत्पादन
इसके बाद, हम टेक्स्ट को व्हॉट्सएप द्वारा अलग किए गए शब्दों की सूची में विभाजित कर देंगे।
# Split text into list of words separated by whitespaces(tab, newline) text = text.split() उत्पादन
अंत में, हम गिनेंगे और देखेंगे कि प्रत्येक शब्द स्प्लिटेड टेक्स्ट में कितनी बार होता है।
# initialize a dictionary to hold words:count wordsCount = {} # if a word is already a key in our dictionary, increment it's value. # If not, initialize it's value to 1. for word in text: wordsCount(word) = wordsCount.get(word, 0) + 1 उत्पादन
हम स्पष्ट रूप से कुछ शब्दों को दो बार दिखाई दे सकते हैं, और कुछ केवल एक बार। चलिए इस शब्द को अवरोही क्रम में इसके मूल्य द्वारा क्रमबद्ध करते हैं ताकि हम स्पष्ट रूप से अंतर कर सकें। यहाँ, हमने पायथन का उपयोग किया है क्रमबद्ध कार्य , भेड़ का बच्चा अभिव्यक्ति , तथा शब्दकोश समझ ।
5 वर्षों के अनुभवी अनुभव के लिए एसक्यूएल सर्वर साक्षात्कार प्रश्न और उत्तर
# Sort dictionary by value, in descending order wordsCount = {w: c for w, c in sorted(wordsCount.items(), key=lambda item: item(1), reverse=True)} अंत में, हमने उपयोग किया है पाश के लिए हमारे पाठ में शब्दों को साफ़ करने, गिनने और छाँटने के लिए।
नीचे दिया गया पूरा कोड है।
def word_count(text): # initialize a dictionary to hold words:count wordsCount = {} # replace punctuation(except apostrophe) and white spaces for punc in '.,
?!'': text = text.replace(punc, '') # lowercase all letters. text = text.lower() # Split text into list of words separated by whitespaces(tab, newline) and apostrophe(') text = text.split() # if a word is already a key in our dictionary, increment it's value. # If not, initialize it's value to 1. for word in text: wordsCount(word) = wordsCount.get(word, 0) + 1 # Sort dictionary by value, in descending order wordsCount = {w: c for w, c in sorted(wordsCount.items(), key=lambda item: item(1), reverse=True)} print(wordsCount) if __name__ == '__main__': text = 'Hello, welcome to Software Testing Help. In this article: 'Loops in Python', you'll learn about loops with practical examples. Great right? Make sure to follow along as we learn together.
Happy coding!' word_count(text) अंतिम आउटपुट
जबकि लूप
अजगर घुमाव के दौरान जब तक हालत TRUE है तब तक बार-बार बयानों के ब्लॉक को निष्पादित करें। हम देखते हैं कि यह थोड़ा सा समान है अगर बयान । हालांकि, इसके विपरीत घुमाव के दौरान , यदि कथन केवल एक बार निष्पादित होता है यदि उसकी स्थिति TRUE है।
लूप में निम्न सिंटैक्स होता है:
While condition: expression(block of code) से भिन्न पाश के लिए , को घुमाव के दौरान किसी अनुक्रम पर पुनरावृति नहीं है यह अपनी स्थिति के लिए तुलना ऑपरेटरों और बूलियन का उपयोग करता है।
आइए इसे बेहतर तरीके से समझने के लिए कुछ उदाहरण देखें।
उदाहरण 1:प्रिंट 'हैलो वर्ल्ड!' समय की एक संख्या
घुमाव के दौरान स्थिति की जाँच करता है (गिनती
यह फ्लोचार्ट कैसा दिखेगा:
def print_count_times(n): # set count to 0 count = 0 while count आउटपुट:
उदाहरण 2:किसी संख्या का भाज्य ज्ञात कीजिए
एक संख्या के भाज्य को इस रूप में दर्शाया गया है n! और इसका सूत्र है
1*2*...*(n-1)कार्यक्रम जाँचता है कि संख्या 0 है और रिटर्न 1 (0 का भाज्य 1) है। फिर घुमाव के दौरान यह देखने के लिए कि क्या हमारी स्थिति 1 के बराबर या 1 से अधिक है, यह देखने के लिए स्थिति (n> = 1) की जाँच करें। हर बार जब यह स्थिति TRUE होती है, तो हमारा प्रोग्राम लूप ब्लॉक में सूत्र की गणना करता है
तथ्यात्मक समस्या को हल करने के लिए लूप का उपयोग करें
def factorial(n): if n == 0: # The factorial of 0 is 1. return 1 else: fac = 1 while n >= 1: # while this condition is TRUE # 1*2*3*...*(n-1) fac *= n # same as 'fac = fac * n' n -= 1 # same as 'n = n - 1' return fac if __name__ =='__main__': n = int(input('Find factorial of: ')) fac = factorial(n) print('Factorial of {} is {} '.format(n,fac)) उत्पादन
उदाहरण - जबकि लूप का उपयोग करते हुए एक फाइबोनैचि अनुक्रम उप-अवधि खोजें
एक फाइबोनैचि अनुक्रम का सूत्र है।
0,1,1,...((n-1)th + (n-2)th)पहले दो संख्याएँ 0 और 1 हैं, फिर अगली संख्याएँ दो पिछली संख्याओं (n-1) वें और (n-2) वें का योग हैं।
8 का फाइबोनैचि अनुक्रम 0,1,1,2,3,5,8,13 होगा
def fibonacci(n_term): n1 = 0 # (n-1)th if n_term == 1: # if n_term term is 1, print 0 print(n1) else: count = 0 n2 = 1 # (n-2)th # Loop while 'count उत्पादन
हमारा कार्यक्रम पहले पहले nth मान (n1 = 0) को परिभाषित करता है, फिर यह जांचता है कि क्या n_term तर्क के रूप में पारित हुआ है 1. यदि TRUE है, तो यह 0 पर वापस आता है।
और, यह दो चर को परिभाषित करता है:
- count = 0: इसमें इस्तेमाल किया जाएगा घुमाव के दौरान अगर n_term (गिनती) से कम है तो स्थिति की जांच करें
- n2 = 1: यह हमारा दूसरा nth मान है।
अब तक, हमारे अनुक्रम में 0,1 हैं (n1, n2)। जबकि हालत सही है:
- N2 का मान एक अस्थायी चर (अस्थायी = n2) को सौंपा गया है।
- पिछली दो संख्याओं का योग गणना और n2 (n2 = n1 + n2) को सौंपा गया है।
- हमारा अस्थायी मान (n2 पुराना मान) n1 (n1 = temp) को सौंपा गया है।
- हमारी गिनती बढ़ जाती है (गिनती + = 1), और स्थिति फिर से जाँच की जाती है।
पहली पुनरावृत्ति के अंत में, हमारे पास 0,1,1 हैं:
- n1 = 1 (पहले 1)
- n2 = 1 (दूसरा 1)
यह ऑपरेशन कंडीशन काउंट होने तक दोहराएगा अंतर प्रविष्ट पाश
पायथन लूप्स के बारे में अच्छी बात यह है कि वे नेस्टेड हो सकते हैं यानी हम एक या एक से अधिक लूप का उपयोग दूसरे लूप के अंदर कर सकते हैं। यह हमें और भी जटिल समस्याओं को हल करने में सक्षम बनाता है।
(1) लूप्स के लिए घोंसला बनाना
छोरों के लिए खुद के भीतर नेस्टेड किया जा सकता है। नीचे दिए गए सिंटैक्स में लूप के लिए 1-स्तरीय नेस्टेड दिखाया गया है।
for in n: # piece of code goes here for in n: # piece of code goes here उदाहरण 1:पैटर्न में संख्याओं को प्रिंट करने के लिए नेस्टेड का उपयोग करें
लूप के लिए नेस्टेड का उपयोग निम्न पैटर्न को प्रिंट करने के लिए करें:
1 2 2 3 3 3 4 4 4 4 5 5 5 5 5 प्रत्येक संख्या अपनी संख्या के अनुरूप ही कई बार मुद्रित होती है।
यह फ्लोचार्ट कैसा दिखेगा:
पाश के लिए एक घोंसले का फ़्लोचार्ट def print_numbers(): for i in range(1, 6): # outer loop for j in range(i): # 1st level inner loop print(i, end=' ') print('
') if __name__ == '__main__': print_numbers() उत्पादन
हमारा कार्यक्रम निम्नानुसार काम करता है:
- बाहरी लूप 1 से 6 तक की सीमा से गुजरता है और उस क्रम में प्रत्येक आइटम के लिए।
- यह आंतरिक लूप में प्रवेश करता है जहां यह उस आइटम की एक सीमा से अधिक पुनरावृत्ति करता है।
- उस आइटम के प्रत्येक पुनरावृत्ति के लिए, यह आइटम प्रिंट करता है।
- यह केवल आंतरिक लूप को छोड़ता है जब यह उस आइटम की एक सीमा के माध्यम से पूरी तरह से पुनरावृत्त हो जाता है।
- जब यह आंतरिक लूप छोड़ता है, तो यह बाहरी लूप में वापस चला जाता है और यह प्रक्रिया तब तक जारी रहती है जब तक कि यह पूरी तरह से इसके अनुक्रम पर पुनरावृत्त न हो जाए।
उदाहरण 2:लूप के लिए नेस्टेड का उपयोग करके एक नेस्टेड सूची की वस्तुओं को हेरफेर करें
पाइथन में हम एक ऐसी स्थिति की संभावना करेंगे जो एक नेस्टेड सूची के आइटम तक पहुंचना है।
उदाहरण के लिए, नीचे दी गई नेस्टेड सूची को लें।
>>> ((3,4.0,2,8.4,6),(0,2,0.2,4,6),(9,3.5,0.32,5,4)) इस उदाहरण के लिए, आइए एक ऐसा कार्यक्रम लिखें जो इस नेस्टेड सूची में पूर्णांकों की संख्या और फ़्लोट्स की गणना करेगा।
def float_and_int_count(nested_list): float_count = 0 # set our float count to zero int_count = 0 # set our integer count to zero for l in nested_list: # outer loop accesses each list in the nested list for item in l: # inter loop accesses each item in the list if isinstance(item, int): # if item is an instance of int int_count += 1 # increment integer count elif isinstance(item, float): # if item is an instance of float float_count += 1 # increment float count # return a tuple return float_count, int_count if __name__ == '__main__': nested_list = ((3,4.0,2,8.4,6),(0,2,0.2,4,6),(9,3.5,0.32,5,4)) float_n, int_n = float_and_int_count(nested_list) print('Float count: {}
Integer count: {}'.format(float_n, int_n)) उत्पादन
हमारा कार्यक्रम इस तरह काम करता है:
- बाहरी लूप हमारी नेस्टेड सूची में पहली आंतरिक सूची (3,4.0,2,8.4,6) तक पहुंचता है।
- आंतरिक लूप इस पहली आंतरिक सूची में प्रत्येक आइटम तक पहुँचता है। प्रत्येक आइटम के लिए, यह जाँचता है कि यह फ्लोट या पूर्णांक है या नहीं। यदि यह पूर्णांक है, तो यह पूर्णांक गणना (int_count) को बढ़ाता है। यदि यह एक फ्लोट है, तो यह फ्लोट काउंट (फ्लोट_काउंट) बढ़ाता है।
- एक बार जब यह इस पहली आंतरिक सूची के माध्यम से पुनरावृत्ति समाप्त कर लेता है, तो यह बाहरी लूप में वापस चला जाता है और दूसरी सूची (0,2,0.2,4,6) तक पहुंचता है और यह प्रक्रिया तब तक जारी रहती है जब तक कि यह सभी आंतरिक सूचियों तक नहीं पहुंच जाती।
# 2) लूपिंग करते समय घोंसला बनाना
जबकि छोरों को अपने भीतर घोंसला बनाया जा सकता है।
नीचे दिए गए सिंटैक्स में लूप करते समय 1-स्तरीय नेस्टेड दिखाया गया है।
while condition: # piece of code goes here while condition: # piece of code goes here उदाहरण 3:पैटर्न में सितारों (*) को मुद्रित करने के लिए लूप करते समय नेस्टेड का उपयोग करें
निम्न पैटर्न के निर्माण के लिए लूप करते समय नेस्टेड का उपयोग करें:
* * * * * * * * * * * * * * * def print_pattern(n): i = 0 # initialize to zero for outer loop j = 0 # initialize to zero for inner loop while i <= n: # outer loop runs n times while j < i: # inner loop runs i times print('*', end=' ') j += 1 # increment before checking inner loop condition j = 0 # re-initialize after leaving inner loop i += 1 # increment before checking outer loop condition print('') if __name__ == '__main__': n = 5 print_pattern(5) उत्पादन
हमारा कार्यक्रम निम्नानुसार काम करता है:
- चर प्रारंभिक हैं (i = 0, j = 0, n = 5)
- हमारा बाहरी लूप स्थिति की जाँच करता है (0)<= 5) which is obviously TRUE.
- हमारे आंतरिक लूप स्थिति की जांच करते हैं (0)<0) which is obviously FALSE, so our program breaks out of the inner loop.
- मैं बढ़ा हुआ हूँ और बाहरी लूप फिर से इसकी स्थिति की जाँच करता है (1)<= 5) which is TRUE.
- हमारे आंतरिक लूप स्थिति की जांच करते हैं (0)<1) which is TRUE. So a star( * ) मुद्रित किया जाता है और जम्मू को बढ़ाया जाता है और आंतरिक लूप की स्थिति (1) के साथ जांच की जाती है<1) which is FALSE, thus breaks out of the inner loop.
ऊपर की प्रक्रिया तब तक जारी रहती है जब तक बाहरी लूप स्थिति FALSE नहीं हो जाती।
उदाहरण - नंबर स्पेलिंग गेम
के साथ चक्कर लगाने के लिए अंतर प्रविष्ट पाश , हम संख्याओं को पहचानने और वर्तनी करने के लिए बच्चे की क्षमता का मूल्यांकन करने में मदद करने के लिए एक रोमांचक खेल का निर्माण करेंगे।
कार्यक्रम स्क्रीन पर यादृच्छिक संख्या प्रदर्शित करता है और उस नंबर की वर्तनी के लिए अनुरोध करता है। यह जांचता है कि इनपुट सही है या नहीं, तो यह दूसरी संख्या प्रदर्शित करता है। यदि इनपुट गलत है, तो यह एक त्रुटि संदेश भेजेगा और दूसरे उत्तर का अनुरोध करेगा।
import random # random contain 'shuffle' used to shuffle our list def word_spelling(): print('HELLO, WELCOME TO THE WORD SPELLING GAME.
') print('SPELL AS MUCH NUMBERS AS YOU CAN TO GET MARKS
') print('-----------------------------------------------
') correct_score = 0 # keep record of correct spellings wrong_score = 0 # keep record of wrong spellings exceeding number of trials max_trials = 3 # maximum number of trials # A dictionary of numbers as keys and spellings as values. This can be expanded to increase its level of difficulty. number_spell = {0:'zero',1:'one',2:'two',3:'three',4:'four',5:'five',6:'six', 7:'seven',8:'eight',9:'nine',10:'ten'} # get the list of keys from the dict and shuffle them so that random numbers are displayed on the screen. number_spell_keys = list(number_spell.keys()) random.shuffle(number_spell_keys) # Our game starts here for number in number_spell_keys: # outer loop is a for loop which iterate through the keys trial_count = 0 # keeps track of number of trials while trial_count उत्पादन
कैसे जावा में एक सरणी के एक तत्व को मुद्रित करने के लिए
हमारे लूप और जबकि-लूप की मुख्य विशेषताएं हैं:
- पाश के लिए उन संख्याओं की सूची के माध्यम से पुनरावृत्ति करता है जो उपयोगकर्ता को वर्तनी के लिए प्रस्तुत की जाती हैं।
- घुमाव के दौरान जाँच की जाती है कि परीक्षण की संख्या पार हो गई है या नहीं। इस तरह, एक उपयोगकर्ता को इसे प्राप्त करने के लिए अधिकतम संख्या में परीक्षण दिए जाते हैं।
हमने दो नई अवधारणाएं देखी हैं जबकि-और , टूटना (इस पर बाद में)। घुमाव के दौरान तथा पाश के लिए मूल रूप से एक है और बयान जो केवल एक बार निष्पादित होता है जब स्थिति FALSE होती है।
पायथन अनंत लूप्स
अगर हम इस बात से सावधान नहीं हैं कि हम अपने छोरों को कैसे लागू करते हैं, तो यह आगे बढ़ सकता है अपरिमित गांठ यानी प्रोग्राम तब तक हमेशा के लिए कोड के एक ब्लॉक को निष्पादित करेगा जब तक कि हमारा कंप्यूटर CPU मेमोरी जैसे संसाधनों से बाहर न चला जाए।
उदाहरण 1:लूप होते हुए भी अनंत
def infinit_loop_1(): numb = 0 while numb <5: print(numb) if __name__ == '__main__': infinit_loop_1() उत्पादन
ध्यान दें : इस प्रोग्राम को चलने से रोकने के लिए, Ctrl + z या Ctrl + का उपयोग करें सी जिस टर्मिनल पर आप कोड चलाते थे।
हमारा कोड ऊपर लागू करता है a लूप करते समय अनंत । हालाँकि, यह गलती से है क्योंकि हमारे घुमाव के दौरान हालत सुन्न जाँचता है<5, but there is nowhere in the code that actually increments the numb’s value. Hence the value of numb is always zero and the condition keeps returning TRUE.
तो, इसे ठीक करने का तरीका सुन्न मूल्य को बढ़ाने का साधन प्रदान करना है।
def infinit_loop_1(): numb = 0 while numb <5: print(numb) numb += 1 # fix by incrementing numb's value if __name__ == '__main__': infinit_loop_1() उत्पादन
एक सवाल उठ सकता है अनंत छोरों वास्तव में आवश्यक है? स्पॉयलर अलर्ट: हां वे हैं। क्लाइंट्स की जरूरतों को पूरा करते हुए एक सर्वर को लगातार चलाने के लिए प्रोग्राम किया जा सकता है। गेमिंग में, एक घटना तब तक चल सकती है जब तक उपयोगकर्ता लूप को छोड़ने या तोड़ने के लिए एक कार्रवाई का चयन नहीं करता है।
मानो या न मानो, हम वास्तव में एक का इस्तेमाल किया अपरिमित गांठ ऊपर अंतिम व्यावहारिक उदाहरण में। तो, हम कैसे निपटते हैं अनंत छोरों ?
पायथन ब्रेक एंड कंटीन्यू स्टेटमेंट्स
जैसा कि हमने ऊपर बताया, ऐसे मामले हैं जहां हमें जानबूझकर लिखना होगा अनंत छोरों । इन मामलों में, हम देखेंगे कि द टूटना तथा जारी रखें कीवर्ड की रीढ़ हैं अनंत छोरों ।
टूटना तथा जारी रखें कीवर्ड आमतौर पर एक पायथन के भीतर उपयोग किए जाते हैं अगर बयान जहाँ अगर स्टेटमेंट एक स्थिति की जाँच करता है और यदि यह TRUE है, तो हम या तो उस लूप से बाहर निकल जाते हैं जिसमें हमारा स्टेटमेंट कॉल किया गया था या उसके नीचे के सभी कोड को छोड़ कर जारी रहेगा और लूप की शुरुआत में वापस आ जाएगा।
उदाहरण - संख्या को तब तक संचित करें जब तक कि एक थ्रेसहोल्ड मीटर न हो
आइए एक प्रोग्राम पर विचार करें जो एक यादृच्छिक रूप से उत्पन्न स्रोत से संख्या प्राप्त करता है और एक सीमा तक पहुंचने तक संख्या जमा करता है।
इस उदाहरण के लिए अनंत लूप की आवश्यकता के कारण यह है कि हमें यह पता नहीं है कि हमारे कार्यक्रम को दहलीज तक पहुँचने के लिए संचित संख्या के लिए कितने पुनरावृत्तियों की आवश्यकता होगी।
हमारा एकमात्र उद्धारकर्ता पायथन है अगर बयान इसके साथ तोड़ बयान । हमारा विवरण यदि जाँचता है कि यदि सीमा समाप्त हो गई है, तो यह TRUE होने पर लूप से बाहर हो जाता है।
हमारे कार्यक्रम के लिए यह भी आवश्यक है कि कुछ प्रतिबंधित संख्याएँ जमा न हों। इसलिए, यदि हमारा प्रोग्राम इन नंबरों का सामना करता है, तो उसे सभी कोड छोड़ कर लूप की शुरुआत में लौटना चाहिए। इस के साथ प्राप्त करने योग्य है जारी रखें बयान ।
import random def acc_numbers(): acc_numb = 0 # initialize our accumulator threshold = 45 # define our threshold value Rejected_numbers = (4,0,1) # define our rejected numbers while True: # This is an uncontrolled condition. # our infinite while loop # return random integer number within 0 and 10. numb = random.randint(0, 10) # check if the number is in the list of rejected numbers if numb in Rejected_numbers: print('Not accepting ', numb) continue # skip all code blow it and return to the beginning of the while loop # add random number to our store acc_numb += numb # check if the accumulated number has reached threshold if acc_numb >= threshold: print('Threshold attended') break # break out of the loop. if __name__ == '__main__': acc_numbers() उत्पादन
बार बार पूछे जाने वाले प्रश्न
Q # 1) आप पायथन में एक लूप को कैसे नियंत्रित करते हैं?
उत्तर: पायथन में, आप निम्नलिखित नियंत्रण कथनों के साथ एक लूप को नियंत्रित कर सकते हैं:
- टूटना कीवर्ड एक लूप से बाहर निकलता है।
- जारी रखें कीवर्ड इसके नीचे के सभी कोड को छोड़ देता है और लूप की शुरुआत में लौट आता है।
ये कीवर्ड ज्यादातर एक में उपयोग किए जाते हैं अगर बयान यदि पहली शर्त यह है कि कोई शर्त TRUE या FALSE है।
Q # 2) लूप और लूप के बीच क्या अंतर है?
उत्तर: सेवा मेरे पाश के लिए है एक इटरेटर आधारित लूप , जो चलने योग्य वस्तुओं की वस्तुओं के माध्यम से जैसे कदम सूचियों , टुपल्स , आदि जबकि घुमाव के दौरान एक है हालत आधारित पाश , कि जब तक इसकी स्थिति TRUE है तब तक बार-बार कथनों के एक खंड को निष्पादित करता है।
Q # 3) क्या पायथन लूप तक समर्थन करता है?
उत्तर: दुर्भाग्य से, अजगर इसका समर्थन नहीं करता है करते-करते पाश ।
Q # 4) पायथन में दो प्रकार के लूप कौन से हैं?
उत्तर: अजगर आमतौर पर दो प्रकार के छोरों का समर्थन करता है: पाश के लिए तथा घुमाव के दौरान । हालांकि, एक तीसरा लूप ( अंतर प्रविष्ट पाश ) इन छोरों में से दो या अधिक घोंसले के द्वारा उत्पन्न किया जा सकता है।
पायथन लूप्स के बारे में अधिक
अजगर में लूपिंग स्टेटमेंट का उपयोग उपयोगकर्ता द्वारा निर्दिष्ट कई बार के लिए बार-बार स्टेटमेंट या कोड के ब्लॉक को निष्पादित करने के लिए किया जाता है।
पायथन हमें नीचे दिए गए अनुसार 2 प्रकार के लूप प्रदान करता है:
- घुमाव के दौरान
- पाश के लिए
# 1) जबकि लूप:
जबकि अजगर में लूप का उपयोग कई स्टेटमेंट या कोड को बार-बार निष्पादित करने के लिए किया जाता है जब तक कि दी गई स्थिति सही नहीं होती है।
जब हम पुनरावृति के लिए बार-बार नहीं जानते हैं तो हम थोड़ी देर के लूप का उपयोग करते हैं।
वाक्य - विन्यास:
while (expression): block of statements Increment or decrement operator जबकि लूप में, हम अभिव्यक्ति की जांच करते हैं, यदि अभिव्यक्ति सही हो जाती है, केवल तभी लूप के अंदर मौजूद बयानों के ब्लॉक को निष्पादित किया जाएगा। प्रत्येक पुनरावृत्ति के लिए, यह स्थिति की जांच करेगा और तब तक बयानों के ब्लॉक को निष्पादित करेगा जब तक कि स्थिति झूठी न हो जाए।
उदाहरण:
number = 5 sum = 0 i = 0 while (i आउटपुट:
१०
लोड परीक्षण बनाम प्रदर्शन परीक्षण बनाम तनाव परीक्षण
आउटपुट:
# 2) लूप के लिए:
जब तक दी गई स्थिति झूठी नहीं हो जाती, तब तक कई बार बयानों या कोड के ब्लॉक को निष्पादित करने के लिए अजगर में लूप का उपयोग किया जाता है।
हम लूप के लिए उपयोग करते हैं जब हम पुनरावृति की संख्या को जानते हैं।
वाक्य - विन्यास:
for var in sequence: Block of code यहां var अनुक्रम से मान लेगा और इसे तब तक निष्पादित करेगा जब तक कि अनुक्रम के सभी मान नहीं हो जाते।
उदाहरण:
language = (‘Python’, ‘Java’, ‘Ruby’) for lang in language: print(“Current language is: “, lang) आउटपुट:
वर्तमान भाषा है: पायथन
वर्तमान भाषा है: जावा
वर्तमान भाषा है: रूबी
आउटपुट:
सीमा () फ़ंक्शन का उपयोग करने वाले लूप के लिए:
रेंज () फ़ंक्शन का उपयोग संख्याओं के अनुक्रम को उत्पन्न करने के लिए किया जाता है।
उदाहरण के लिए, रेंज (5) 0 से 4 (5 नंबर) से नंबर जेनरेट करेगा।
उदाहरण:
language = (‘Python’, ‘Java’, ‘Ruby’) for lang in range(len(language)): print(“Current language is: “, language(lang)) आउटपुट:
वर्तमान भाषा है: पायथन
वर्तमान भाषा है: जावा
वर्तमान भाषा है: रूबी
आउटपुट:
निष्कर्ष
इस ट्यूटोरियल में, हमने लूप्स की परिभाषा, पायथन लूप्स के प्रकार, का उपयोग देखा पाश के लिए, तथा घुमाव के दौरान कुछ उदाहरणों के साथ।
हमने भी सीखा स्थिर फंदा उत्पन्न होते हैं और परिमित छोरों के रूप में अच्छी तरह से और हम कैसे उपयोग करने के लिए पता चला टूटना तथा जारी रखें कीवर्ड।
=> यहां सभी पायथन ट्यूटोरियल देखें
PREV ट्यूटोरियल | अगले ट्यूटोरियल
अनुशंसित पाठ
