பொருளடக்கம்[மறை][காட்டு]
பைத்தானில் ஒரு சுவாரஸ்யமான யூக விளையாட்டை உருவாக்குவதன் மூலம் லூப்களைப் புரிந்துகொண்டு முன்னேறுவோம்.
முந்தைய அனைத்து கருத்துக்களும் செயல்பாட்டுக்கு வரும், எனவே மேலும் நகரும் முன் முந்தைய விரிவுரைகளை மறுபரிசீலனை செய்ய பரிந்துரைக்கிறேன்.
அதில் முழுக்குவோம்.
சுழல்கள் போது
பைத்தானில் லூப்களை எவ்வாறு பயன்படுத்துவது என்பதை நாம் கற்றுக் கொள்ளப் போகிறோம். குறியீட்டின் தொகுதியை பலமுறை இயக்குவதற்கு லூப்களைப் பயன்படுத்துகிறோம், மேலும் அவை ஊடாடும் திட்டங்கள் மற்றும் கேம்களை உருவாக்குவதற்குப் பயனுள்ளதாக இருக்கும்.
எனவே, அடிப்படைகளுடன் தொடங்குவோம். சிறிது நேர வளையத்தை எழுத, "while" செயல்பாட்டிற்குப் பிறகு ஒரு நிபந்தனையை எழுதுகிறோம்.
ஒரு மாறி “i” ஐ அறிமுகப்படுத்தி அதை 1 ஆக அமைப்போம்
i = 1
while i <= 5:
print(i)
இப்போது, "i" இன் மதிப்பு மாற்றப்படாவிட்டால், மேலே உள்ள லூப் ஒரு எல்லையற்ற வளையமாக இருக்கும் என்பதால், "i" 1 ஆல் அதிகரிக்கப்படும்.
i = i + 1
மேலே உள்ள நிபந்தனை உண்மையாகும் வரை இந்த நிரல் "i" இன் மதிப்பை அச்சிடும். "i" இன் மதிப்பு 5 ஐ விட அதிகமாக மாறியவுடன், வளையம் உடைந்து விடும்.
இது எவ்வாறு செயல்படுகிறது என்பதைப் புரிந்து கொள்ள, உள்தள்ளல் இல்லாத மற்றொரு அறிக்கையைச் சேர்க்கிறேன்.
print("done")
உள்தள்ளப்படாததால், while loop மூலம் இது செயல்படுத்தப்படாது.
இது எவ்வாறு செயல்படும் என்பது இங்கே:
சற்று நேரத்தில் லூப்புடன் விளையாடுவோம்.
நான் "i" உடன் பெருக்கும் "நட்சத்திரம்" உடன் while loop இல் மற்றொரு சரத்தைச் சேர்க்கிறேன். இது எங்கள் திட்டத்தை எவ்வாறு பாதிக்கும் என்பதைப் பார்ப்போம்.
i = 1
while i <= 5:
print('*' * i)
இப்போது, நட்சத்திரக் குறியீடுகளின் எண்ணிக்கை 5ஐத் தாண்டும் வரை அது நட்சத்திரக் குறியீடுகளை அச்சிடும்.
இப்போது, நாம் while loop ஐ பயன்படுத்துகிறோம். யூகிக்கும் விளையாட்டை உருவாக்குவோம்.
லூப்களைப் பயன்படுத்தி கேமை யூகித்தல்
நிரல் அதன் நினைவகத்தில் ஒரு ரகசிய எண்ணைச் சேமித்து, அதை யூகிக்கச் சொல்கிறது என்பது கருத்து. அந்த எண்ணை யூகிக்க 3 முயற்சிகள் உள்ளன. நீங்கள் எண்ணை யூகித்தால், நீங்கள் வாழ்த்தப்படுவீர்கள். நம் தலைகளை ஒன்றாக இணைப்போம்.
எங்கள் ரகசிய எண்ணுக்கு ஒரு மாறியை அறிமுகப்படுத்துகிறோம்.
secret_number = 6
இப்போது, எண்ணை யூகிக்குமாறு பயனரிடம் திரும்பத் திரும்பக் கேட்க, நாம் சிறிது நேர வளையத்தை எழுத வேண்டும். அதற்கு முன், அனுமதிக்கப்பட்ட முயற்சிகளின் எண்ணிக்கையை அமைக்க மற்றொரு மாறியை அறிமுகப்படுத்த வேண்டும்.
guess_count = 0
while guess_count < 3:
guess = int(input('guess: '))
guess_count +=1
if guess == secret_number
print("Congratulations! You won")
இந்த நிரல் பயனரிடமிருந்து முழு எண் உள்ளீட்டை எடுத்து, அதை "யூகிப்பில்" சேமிக்கும். அதை பயன்படுத்தி ரகசிய_எண்ணுடன் ஒப்பிடும் ஒப்பீட்டு ஆபரேட்டர் மற்றும் இரண்டும் சமமாக இருந்தால், அது திரும்பும் “வாழ்த்துக்கள்!
நீ வென்றாய்". ஆனால் இந்த திட்டத்தில் சில குறைபாடுகள் உள்ளன. முதல் முயற்சியில் எண்ணை நீங்கள் யூகித்தால், அது உங்களை வாழ்த்திய பிறகு இன்னும் இரண்டு முறை யூகிக்கச் சொல்லும். லூப்பை உடைக்க "பிரேக்" ஸ்டேட்மென்ட்டைப் பயன்படுத்துவதன் மூலம் இந்த சிக்கலை தீர்க்க முடியும்.
பாருங்கள்!
இப்போது, நாங்கள் ஒரு "வேறு" அறிக்கையைச் சேர்க்கப் போகிறோம், அது மூன்று முயற்சிகளிலும் எண்ணை யூகிக்க முடியாவிட்டால் அதைச் செயல்படுத்தும்.
இப்போது, இந்த வழக்கில், if அறிக்கையுடன் லூப் உடைக்கப்படாமல் இருந்தால், while loop இல் இருந்து வேறு ஒரு அறிக்கையைச் சேர்ப்போம்.
இது உங்களுக்கு ஒரு வேடிக்கையான செயலாக இருக்கும் என்று நம்புகிறேன். பைத்தானில் நிபுணத்துவம் பெற நீங்கள் இதே போன்ற செயல்களில் ஈடுபடலாம்.
மடக்கு
இது இந்த விரிவுரையின் முடிவு. இதுவரை நீங்கள் ரசித்தீர்கள் என்று நம்புகிறேன். அடுத்த பதிவில் சந்திப்போம். அதுவரை தொடர்ந்து பயிற்சி செய்யுங்கள்.
ஒரு பதில் விடவும்