విషయ సూచిక[దాచు][చూపండి]
మేము లూప్లను అర్థం చేసుకోవడం ద్వారా ప్రారంభిస్తాము మరియు పైథాన్లో ఆసక్తికరమైన అంచనా గేమ్ను రూపొందించడం ద్వారా ముందుకు వెళ్తాము.
అన్ని మునుపటి కాన్సెప్ట్లు అమలులోకి వస్తాయి కాబట్టి మరింత ముందుకు వెళ్లే ముందు మునుపటి ఉపన్యాసాలను సవరించమని నేను మీకు సిఫార్సు చేస్తాను.
దానిలోకి ప్రవేశిద్దాం.
లూప్స్ అయితే
పైథాన్లో లూప్లను ఎలా ఉపయోగించాలో మనం నేర్చుకోబోతున్నాం. మేము అనేక సార్లు కోడ్ బ్లాక్ని అమలు చేయడానికి లూప్లను ఉపయోగిస్తాము మరియు అవి ఇంటరాక్టివ్ ప్రోగ్రామ్లు మరియు గేమ్లను రూపొందించడంలో తరచుగా ఉపయోగపడతాయి.
కాబట్టి, ప్రాథమిక అంశాలతో ప్రారంభిద్దాం. కాసేపు లూప్ వ్రాయడానికి, "వేళ" ఫంక్షన్ తర్వాత మేము ఒక షరతును వ్రాస్తాము.
వేరియబుల్ “i”ని పరిచయం చేసి, దానిని 1కి సెట్ చేద్దాం
i = 1
while i <= 5:
print(i)
ఇప్పుడు, “i” విలువను మార్చకపోతే పై లూప్ అనంతమైన లూప్ అవుతుంది కాబట్టి “i” 1 ద్వారా పెంచబడుతుంది.
i = i + 1
పై షరతు నిజం అయ్యే వరకు ఈ ప్రోగ్రామ్ “i” విలువను ముద్రిస్తుంది. "i" విలువ 5 కంటే ఎక్కువ అయిన వెంటనే, లూప్ విచ్ఛిన్నమవుతుంది.
ఇది ఎలా పని చేస్తుందో అర్థం చేసుకోవడానికి, ఇండెంట్ లేకుండా మరొక స్టేట్మెంట్ని జోడించనివ్వండి.
print("done")
ఇది ఇండెంట్ చేయబడనందున, ఇది while లూప్తో అమలు చేయబడదు.
ఇది ఎలా పని చేస్తుందో ఇక్కడ ఉంది:
కొంచెం లూప్తో ఆడుకుందాం.
నేను "i"తో గుణించే "నక్షత్రం"తో while లూప్లో మరొక స్ట్రింగ్ని జోడిస్తున్నాను. ఇది మన ప్రోగ్రామ్ను ఎలా ప్రభావితం చేస్తుందో చూద్దాం.
i = 1
while i <= 5:
print('*' * i)
ఇప్పుడు, ఇది ఆస్టరిస్క్ల సంఖ్య 5ని మించే వరకు ఆస్టరిస్క్లను ప్రింట్ చేస్తుంది.
ఇప్పుడు, మేము while లూప్ని ఉపయోగించడానికి ఉంచుతున్నాము. ఊహించే గేమ్ని తయారు చేద్దాం.
లూప్స్ని ఉపయోగించి గేమ్ను ఊహించడం
కాన్సెప్ట్ ఏమిటంటే, ప్రోగ్రామ్ తన మెమరీలో రహస్య సంఖ్యను సేవ్ చేస్తుంది మరియు దానిని అంచనా వేయమని అడుగుతుంది. ఆ సంఖ్యను అంచనా వేయడానికి మాకు 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")
ఈ ప్రోగ్రామ్ వినియోగదారు నుండి పూర్ణాంక ఇన్పుట్ని తీసుకుంటుంది మరియు దానిని "ఊహించు"లో సేవ్ చేస్తుంది. ఇది ఆ తర్వాత దాన్ని ఉపయోగించి రహస్య_సంఖ్యతో సరిపోల్చుతుంది పోలిక ఆపరేటర్ మరియు రెండూ సమానంగా ఉంటే, అది తిరిగి వస్తుంది “అభినందనలు!
నువ్వు గెలిచావు". కానీ ఈ కార్యక్రమంలో కొన్ని లోపాలు ఉన్నాయి. మీరు మొదటి ప్రయత్నంలోనే నంబర్ను ఊహించినట్లయితే, అది మిమ్మల్ని అభినందించిన తర్వాత మరో రెండు సార్లు ఊహించమని అడుగుతుంది. లూప్ను విచ్ఛిన్నం చేయడానికి "బ్రేక్" స్టేట్మెంట్ను ఉపయోగించడం ద్వారా ఈ సమస్యను పరిష్కరించవచ్చు.
ఒకసారి చూడు!
ఇప్పుడు, మీరు మూడు ప్రయత్నాలలో సంఖ్యను అంచనా వేయలేకపోతే అమలు చేసే “else” స్టేట్మెంట్ను మేము జోడించబోతున్నాము.
ఇప్పుడు, ఈ సందర్భంలో, if స్టేట్మెంట్తో లూప్ విచ్ఛిన్నం కాకపోతే అమలు చేయబడే while లూప్ నుండి వేరే స్టేట్మెంట్ను జోడిస్తాము.
ఇది మీకు వినోదభరితమైన కార్యకలాపమని నేను ఆశిస్తున్నాను. పైథాన్లో ప్రావీణ్యం పొందడానికి మీరు ఇలాంటి కార్యకలాపాలలో మునిగిపోవచ్చు.
సర్ప్ అప్ చేయండి
ఇది ఈ ఉపన్యాసం ముగింపు. మీరు ఇప్పటివరకు ఆనందించారని నేను ఆశిస్తున్నాను. తదుపరి దానిలో మిమ్మల్ని కలుస్తాను. అప్పటి వరకు సాధన చేస్తూ ఉండండి.
సమాధానం ఇవ్వూ