పైథాన్‌లో లూప్ అయితే. ఇది ఎలా పనిచేస్తుంది, ఉపయోగం యొక్క ఉదాహరణలు

ఏదైనా భాష యొక్క ప్రధాన సాధనాల్లో లూప్‌లు ఒకటి. పైథాన్‌లో రెండు ప్రాథమిక లూప్‌లు ఉన్నాయి, వాటిలో ఒకటి అయితే. దానిని పరిగణించండి మరియు చిత్రాన్ని బాగా అర్థం చేసుకోవడానికి, మరొకటి. నిజమే, ఇలాంటి వాటితో పోల్చితే, ఏదైనా విషయాన్ని అర్థం చేసుకోవడం చాలా సులభం, కాదా?

ఒక చక్రం యొక్క భావన

ఒక నిర్దిష్ట చర్యను అనేకసార్లు చేయవలసి వచ్చినప్పుడు లూప్ అవసరం. ఇది చాలా సరళమైనది, ఎందుకంటే వాస్తవానికి చక్రాల కోసం అప్లికేషన్ల పరిధి చాలా విస్తృతంగా ఉంటుంది. పైథాన్‌లో రెండు ప్రధాన రకాల లూప్‌లు ఉన్నాయి: ఫర్ మరియు కాసేపు. అత్యంత ప్రజాదరణ కోసం ఉంది.

నిర్దిష్ట చర్యలతో పాటు, మీరు నిర్దిష్ట పాయింట్ వరకు వివిధ కోడ్ ముక్కలను లూప్ చేయవచ్చు. ఇది నిర్దిష్ట సంఖ్యలో సార్లు కావచ్చు లేదా నిర్దిష్ట షరతు నిజం అయినంత వరకు కావచ్చు.

మేము లూప్‌ల రకాలను అర్థం చేసుకోవడం ప్రారంభించే ముందు మరియు ప్రత్యేకించి, పునరావృతం అంటే ఏమిటో మనం ఇంకా అర్థం చేసుకోవాలి. ఇది ప్రస్తుత అప్లికేషన్ రన్‌లో ప్రస్తుత చక్రంలో ఒక చర్య లేదా చర్యల క్రమం యొక్క పునరావృతం.

కోసం సైకిల్

మా ఫర్ లూప్ అనేక ఇతర భాషలలో వలె కౌంటర్ కాదు. విలువల యొక్క నిర్దిష్ట క్రమాన్ని లెక్కించడం దీని పని. దీని అర్థం ఏమిటి? మన దగ్గర మూలకాల జాబితా ఉందని అనుకుందాం. మొదట, లూప్ మొదటి, రెండవ, మూడవ, మొదలైన వాటిని తీసుకుంటుంది.

పైథాన్‌లోని ఈ లూప్ యొక్క ప్రయోజనం ఏమిటంటే, లూప్ నుండి ఎప్పుడు నిష్క్రమించాలో తెలుసుకోవడానికి మీరు మూలకం యొక్క సూచికను గుర్తించాల్సిన అవసరం లేదు. అంతా ఆటోమేటిక్‌గా జరిగిపోతుంది.

>>> spisok = [10, 40, 20, 30]

>>> spisok లో మూలకం కోసం:

… ప్రింట్ (మూలకం + 2)

...

12

42

22

32

మా ఉదాహరణలో, మేము వేరియబుల్ ఉపయోగించాము మూలకం ఫర్ కమాండ్ తర్వాత. సాధారణంగా, పేరు ఏదైనా కావచ్చు. ఉదాహరణకు, ఒక ప్రముఖ హోదా i. మరియు ప్రతి పునరావృతంతో, ఈ వేరియబుల్ జాబితా నుండి ఒక నిర్దిష్ట వస్తువు కేటాయించబడుతుంది, దానిని మేము తగిన పదం అని పిలుస్తాము.

మా విషయంలో, జాబితా 10,40,20,30 సంఖ్యల క్రమం. ప్రతి పునరావృతం వద్ద, సంబంధిత విలువ వేరియబుల్‌లో కనిపిస్తుంది. ఉదాహరణకు, లూప్ ప్రారంభమైన వెంటనే, వేరియబుల్ మూలకం విలువ 10 కేటాయించబడింది. తదుపరి పునరావృతంలో, పది సంఖ్య 40గా మారుతుంది, మూడవసారి అది సంఖ్య 20గా మారుతుంది మరియు చివరకు, లూప్ యొక్క చివరి పునరావృతంలో, అది 30గా మారుతుంది.

చక్రం ముగింపుకు సంకేతం జాబితాలోని మూలకాల ముగింపు.

ఇతర ప్రోగ్రామింగ్ భాషలలో వలె, విలువల యొక్క క్లాసిక్ గణనను నిర్వహించడానికి మీకు లూప్ అవసరమైతే, మీరు మనకు అవసరమైన విలువ వరకు సహజ సంఖ్యల శ్రేణితో జాబితాను సృష్టించాలి.

>>> spisok = [1,2,3,4,5]

లేదా ఫంక్షన్ ఉపయోగించండి లెన్(), జాబితా పొడవును నిర్ణయించడానికి. కానీ ఈ సందర్భంలో లూప్ ఉపయోగించడం మంచిది అయితే, ఎందుకంటే వేరియబుల్ ఉపయోగించాల్సిన అవసరం లేదు.

మీరు జాబితాలోని విలువల క్రమాన్ని మార్చవలసి వస్తే, లూప్ చేయండి కోసం మరియు ఇక్కడ రెస్క్యూ వస్తుంది. దీన్ని చేయడానికి, ప్రతి పునరావృతం వద్ద, జాబితా యొక్క ప్రతి మూలకం తప్పనిసరిగా తగిన విలువను కేటాయించాలి.

లూప్ అయితే

చక్రంలా కాకుండా కోసం, ఇది సీక్వెన్స్, లూప్ యొక్క విలువలపై మళ్ళిస్తుంది అయితే మరిన్ని ఉపయోగాలు ఉన్నాయి. ఈ రకమైన చక్రాల పేరు "ఇంకా" అని అనువదించబడింది. అంటే, "వరకు".

ఇది అన్ని ప్రోగ్రామింగ్ భాషలలో కనిపించే యూనివర్సల్ లూప్. మరియు కొన్ని మార్గాల్లో ఇది షరతులతో కూడిన ఆపరేటర్‌ను పోలి ఉంటుంది అవును, ఇది ఒక నిర్దిష్ట షరతు నెరవేరిందో లేదో తనిఖీ చేస్తుంది. షరతులతో కూడిన ఆపరేటర్‌కు విరుద్ధంగా మాత్రమే, అయితే ఒక్కసారి మాత్రమే కాకుండా ప్రతి పునరావృతం వద్ద తనిఖీని నిర్వహిస్తుంది. మరియు షరతు తప్పు అయితే, లూప్ ముగుస్తుంది మరియు దానిని అనుసరించే ఆదేశం అమలు చేయబడుతుంది. సరళంగా చెప్పాలంటే, అతను పనిచేసే పరిస్థితి ఇకపై చెల్లదు.

మేము ఒక చక్రం గీస్తే అయితే సరళంగా, ఇది అటువంటి పథకాన్ని ఉపయోగించి చేయబడుతుంది.

ప్రోగ్రామ్ యొక్క ప్రధాన శాఖ (ఇది లూప్ వెలుపల నడుస్తుంది) నీలం దీర్ఘచతురస్రాలతో ఈ చిత్రంలో చిత్రీకరించబడింది. టర్కోయిస్ చక్రం యొక్క శరీరాన్ని సూచిస్తుంది. ప్రతిగా, రాంబస్ అనేది ప్రతి పునరావృతం వద్ద తనిఖీ చేయబడే పరిస్థితి.

చక్రం అయితే రెండు మినహాయింపులకు దారితీయవచ్చు:

1. లూప్ ప్రారంభంలో లాజికల్ ఎక్స్‌ప్రెషన్ నిజమని తిరిగి రాకపోతే, అది అమలుకు ముందు పూర్తి చేసిన తర్వాత ప్రారంభించబడదు. సాధారణంగా, ఈ పరిస్థితి సాధారణమైనది, ఎందుకంటే కొన్ని పరిస్థితులలో, అప్లికేషన్ లూప్ బాడీలో వ్యక్తీకరణల ఉనికిని అందించకపోవచ్చు.
2. వ్యక్తీకరణ ఎల్లప్పుడూ నిజం అయితే, ఇది లూప్‌కు దారి తీస్తుంది. అంటే, చక్రం యొక్క అంతులేని స్క్రోలింగ్‌కు. అందువల్ల, అటువంటి ప్రోగ్రామ్‌లలో, ఎల్లప్పుడూ లూప్ లేదా ప్రోగ్రామ్ నుండి నిష్క్రమణ ప్రకటన ఉండాలి. అయినప్పటికీ, ప్రోగ్రామ్ ఒక నిర్దిష్ట పరిస్థితి యొక్క నిజం లేదా అబద్ధాన్ని గుర్తించగలిగితే ఈ పరిస్థితి తలెత్తుతుంది. ఆమె దీన్ని చేయడంలో విఫలమైతే, ప్రోగ్రామ్ యొక్క ముగింపుతో లోపం తిరిగి వస్తుంది. లేదా మీరు లోపాన్ని నిర్వహించవచ్చు, ఆపై, అది సంభవించినట్లయితే, నిర్దిష్ట కోడ్ అమలు చేయబడుతుంది.

లోపాన్ని ఎలా నిర్వహించాలనే దాని కోసం భారీ సంఖ్యలో ఎంపికలు ఉండవచ్చు. ఉదాహరణకు, డేటాను సరిగ్గా నమోదు చేయమని ప్రోగ్రామ్ వినియోగదారుని అడగవచ్చు. కాబట్టి, ఒక వ్యక్తి ప్రతికూల సంఖ్యను సూచించినట్లయితే, అది సానుకూలంగా మాత్రమే ఉంటుంది లేదా సంఖ్యలు మాత్రమే ఉండవలసిన అక్షరాలను నమోదు చేస్తే, ప్రోగ్రామ్ దాని గురించి చెప్పగలదు.

లూప్ ఉదాహరణలు అయితే

ఈ సందర్భంలో లోపాన్ని నిర్వహించే కోడ్ యొక్క ఉదాహరణ ఇక్కడ ఉంది.

n = ఇన్‌పుట్ (“పూర్ణాంకాన్ని నమోదు చేయండి:“) 

అయితే రకం(n) != int:

    ప్రయత్నించండి:

        n = int(n)

    విలువ లోపం తప్ప:

        ప్రింట్ (“తప్పు ఎంట్రీ!”)

        n = ఇన్‌పుట్ (“పూర్ణాంకాన్ని నమోదు చేయండి:“) 

n % 2 == 0 అయితే:

    ప్రింట్ ("సరి")

లేకపోతే:

    ప్రింట్ ("బేసి")

సంక్లిష్ట కోడ్ నిర్మాణాలను ప్రకటించడానికి పైథాన్ కోలన్‌లను ఉపయోగిస్తుందని గుర్తుంచుకోండి.

ఎగువ కోడ్‌లో, మేము సంఖ్య పూర్ణాంకం కాదా అని తనిఖీ చేయవలసిన షరతుగా నిర్వచించాము. అవును అయితే, తప్పు తిరిగి ఇవ్వబడుతుంది. కాకపోతే, అది నిజం.

కోడ్ యొక్క రెండవ భాగంలో, ఆపరేటర్ ఉపయోగించబడుతుంది if, విభజన ఆపరేషన్ తర్వాత మిగిలిన భాగాన్ని కనుగొనడానికి మేము % ఆపరేటర్‌ని ఉపయోగించాము. తదుపరి దశ సంఖ్య సమానంగా ఉందో లేదో తనిఖీ చేయడం. కాకపోతే, ఈ సందర్భంలో మిగిలినది ఒకటి. దీని ప్రకారం, సంఖ్య బేసి. 

సరళంగా చెప్పాలంటే, పైన పేర్కొన్న కోడ్ ముందుగా వినియోగదారు నమోదు చేసిన స్ట్రింగ్ సంఖ్య కాదా అని తనిఖీ చేస్తుంది. అవును అయితే, రెండు ద్వారా విభజన మిగిలి ఉందో లేదో చూడటానికి రెండవ చెక్ చేయబడుతుంది. కానీ వినియోగదారు నమోదు చేసిన విలువ సంఖ్యగా ఉండే వరకు రెండవ బ్లాక్ అమలు చేయబడదు.

అంటే, పరిస్థితి ఏర్పడే వరకు లూప్ క్రమం తప్పకుండా అమలు చేయబడుతుంది. ఈ పరిస్థితిలో, ఇది ఇలా పనిచేస్తుంది. 

అంటే, మీరు వ్యతిరేకం నుండి వెళ్ళవచ్చు: ఈవెంట్ తప్పుగా మారే వరకు నిర్దిష్ట చర్యను లూప్ చేయండి.

కోడ్ పార్సింగ్

ఇప్పుడు ఈ కోడ్ ఎలా పనిచేస్తుందో మరింత వివరంగా చూద్దాం. దీన్ని చేయడానికి, మేము దానిని దశలవారీగా విశ్లేషిస్తాము.

1. మొదట, వినియోగదారు స్ట్రింగ్‌లోకి ప్రవేశిస్తారు, ఇది వేరియబుల్ n ద్వారా ఆమోదించబడుతుంది. 
2. ఒక లూప్ ఉపయోగించి అయితే ఈ వేరియబుల్ రకం తనిఖీ చేయబడింది. మొదటి ఎంట్రీలో, ఇది సమానంగా లేదు పూర్ణాంకానికి. అందువల్ల, పరీక్ష ఫలితంగా, ఈ పరిస్థితి నిజమని కనుగొనబడింది. అందువలన, లూప్ శరీరం నమోదు చేయబడింది.
3. ఆపరేటర్ సహాయంతో ప్రయత్నించండి మేము స్ట్రింగ్‌ను సంఖ్యగా మార్చడానికి ప్రయత్నిస్తున్నాము. ఇది జరిగితే, ఏ లోపం సంభవించదు. దీని ప్రకారం, దీన్ని ప్రాసెస్ చేయవలసిన అవసరం లేదు. అందువల్ల, వ్యాఖ్యాత లూప్ ప్రారంభానికి తిరిగి వస్తాడు మరియు చెక్ ఫలితాల ప్రకారం, అది పూర్ణాంకంగా మారిందని తేలింది. కాబట్టి 7వ దశకు వెళ్దాం
4. మార్పిడి విఫలమైతే, అప్పుడు ValueError విసిరివేయబడుతుంది. ఈ సందర్భంలో, ప్రోగ్రామ్ ప్రవాహం తప్ప హ్యాండ్లర్‌కు పంపబడుతుంది.
5. వినియోగదారు కొత్త విలువను నమోదు చేస్తారు, ఇది వేరియబుల్ nకి కేటాయించబడుతుంది.
6. వ్యాఖ్యాత దశ 2కి తిరిగి వచ్చి మళ్లీ తనిఖీ చేస్తాడు. ఇది పూర్ణాంకం విలువ అయితే, దశ 7కి వెళ్లండి. లేకపోతే, దశ 3 ప్రకారం మార్పిడి మళ్లీ ప్రయత్నించబడుతుంది.
7. ఆపరేటర్ సహాయంతో if సంఖ్యను 2తో భాగించిన తర్వాత శేషం ఉందో లేదో నిర్ణయిస్తుంది. 
8. లేకపోతే, "సరి" అనే వచనం తిరిగి ఇవ్వబడుతుంది.
9. లేకపోతే, "బేసి" అనే వచనం తిరిగి వస్తుంది.

అటువంటి ఉదాహరణను ఇప్పుడు పరిగణించండి. ఈ చక్రం ఎన్నిసార్లు వెళుతుందో నిర్ణయించడానికి ప్రయత్నించండి?

మొత్తం = 100 

i = 0

నేను <5:

    n = int(ఇన్‌పుట్())

    total = మొత్తం - n

    నేను = నేను + 1 

ప్రింట్ ("మిగిలినవి", మొత్తం)

సరైన సమాధానం 5. ప్రారంభంలో, వేరియబుల్ విలువ i - సున్నా. వ్యాఖ్యాత వేరియబుల్ సమానంగా ఉందో లేదో తనిఖీ చేస్తుంది i 4 లేదా అంతకంటే తక్కువ. అవును అయితే, విలువ తిరిగి ఇవ్వబడుతుంది. నిజమైన, మరియు లూప్ తదనుగుణంగా అమలు చేయబడుతుంది. విలువ ఒకటి పెరిగింది.

మొదటి పునరావృతం తర్వాత, వేరియబుల్ యొక్క విలువ 1 అవుతుంది. ఒక చెక్ నిర్వహించబడుతుంది మరియు ఈ సంఖ్య మళ్లీ 5 కంటే తక్కువగా ఉందని ప్రోగ్రామ్ అర్థం చేసుకుంటుంది. దీని ప్రకారం, లూప్ బాడీ రెండవ సారి అమలు చేయబడుతుంది. దశలు సారూప్యంగా ఉన్నందున, విలువ కూడా ఒకటి పెరిగింది మరియు వేరియబుల్ ఇప్పుడు 2కి సమానం.

ఈ విలువ కూడా ఐదు కంటే తక్కువ. అప్పుడు లూప్ మూడవసారి అమలు చేయబడుతుంది, వేరియబుల్కు జోడించబడుతుంది i 1 మరియు దానికి విలువ 3 కేటాయించబడింది. ఇది మళ్లీ ఐదు కంటే తక్కువ. కాబట్టి ఇది లూప్ యొక్క ఆరవ పునరావృతానికి వస్తుంది, దీనిలో వేరియబుల్ విలువ i 5కి సమానం (అన్నింటికంటే, ఇది మనకు గుర్తున్నంతవరకు వాస్తవానికి సున్నా). దీని ప్రకారం, ఈ పరిస్థితి పరీక్షలో ఉత్తీర్ణత సాధించదు మరియు లూప్ స్వయంచాలకంగా ముగించబడుతుంది మరియు దాని వెలుపల ఉన్న తదుపరి దశకు పరివర్తన (లేదా ప్రోగ్రామ్ ముగింపు, క్రింది దశలు అందించబడకపోతే) నిర్వహించబడుతుంది.

చక్రం వ్యతిరేక దిశలో కూడా సంభవించవచ్చు. కోడ్ యొక్క ఉదాహరణ ఇక్కడ ఉంది, ప్రతి తదుపరి పునరావృతంతో, వేరియబుల్ యొక్క ప్రస్తుత విలువ నుండి ఒకటి తీసివేయబడుతుంది. 

మొత్తం = 100 

మొత్తం > 0:

    n = int(ఇన్‌పుట్())

    total = మొత్తం - n 

ప్రింట్ (“వనరు అయిపోయింది”)

ఈ ప్రోగ్రామ్ ఏమి చేస్తుందో ఊహించడానికి ప్రయత్నించండి! దానిని వేరియబుల్‌లో ఊహించుకోండి మొత్తం ప్రోగ్రామ్ వనరు గురించి సమాచారం నిల్వ చేయబడుతుంది. ప్రతిసారీ అనువాదకుడు వనరు ఉందో లేదో తనిఖీ చేస్తాడు. కాకపోతే, "రిసోర్స్ అయిపోయింది" అనే వచనం ప్రదర్శించబడుతుంది మరియు ప్రోగ్రామ్ మూసివేయబడుతుంది. మరియు లూప్ యొక్క ప్రతి పునరావృతంతో, వినియోగదారు పేర్కొన్న సంఖ్య ద్వారా వనరు తగ్గుతుంది.

మరియు ఇప్పుడు హోంవర్క్. పై కోడ్‌ని మార్చడానికి ప్రయత్నించండి, తద్వారా వేరియబుల్ భౌతికంగా ప్రతికూలంగా మారదు.