పైథాన్లోని ఉచ్చులు బహుళ స్టేట్‌మెంట్‌లను అమలు చేయడానికి మీ కోడ్‌ను ఆప్టిమైజ్ చేయడానికి సమర్థవంతమైన పద్ధతి. ఒక నిర్దిష్ట కోడ్‌ను అనేకసార్లు అమలు చేయవలసి వస్తే, కావలసిన అవుట్పుట్ పొందడానికి బహుళ పునరావృత్తులు చేయడానికి వినియోగదారు దానిని లూప్‌లో ఉంచవచ్చు. ఇది చాలా ప్రయత్నాలను ఆదా చేస్తుంది మరియు కోడ్ యొక్క సంక్లిష్టతను కూడా తగ్గిస్తుంది. ఈ బ్లాగులో మనం లూప్ ఇన్ అనే భావన గురించి చర్చిస్తాము వివిధ ఉదాహరణలతో. ఈ బ్లాగులో చర్చించిన విషయాలు క్రిందివి:
- లూప్ అయితే ఏమిటి?
- నియంత్రణ ప్రవాహం
- పైథాన్ కంట్రోల్ స్టేట్మెంట్స్ ఎట్ లూప్
- షరతులతో కూడిన ప్రకటనలతో లూప్ అయితే
- లూప్ అయితే అనంతం
- లూప్ అయితే గూడు
లూప్ అయితే ఏమిటి?
పరీక్ష వ్యక్తీకరణ నిజం ఉన్నంతవరకు పైథాన్లోని కాసేపు లూప్ కోడ్ లేదా స్టేట్‌మెంట్‌ల బ్లాక్‌పై మళ్ళించడానికి ఉపయోగించబడుతుంది. కాసేపు లూప్ విషయంలో ఎన్ని పునరావృత్తులు జరుగుతాయో వినియోగదారుకు ముందే తెలియదు. పైథాన్‌లో ఉన్నప్పుడు లూప్ యొక్క వాక్యనిర్మాణాన్ని చూడండి.
అయితే (పరీక్ష వ్యక్తీకరణ): # బ్లాక్‌లో # స్టేట్‌మెంట్‌లు
నియంత్రణ ప్రవాహం
అమలు ప్రారంభమవుతుంది మరియు పరీక్ష వ్యక్తీకరణ నిజమా అని తనిఖీ చేస్తుంది, పరీక్ష వ్యక్తీకరణ నిజమైతే అది లూప్‌లోకి ప్రవేశిస్తుంది మరియు అయితే లూప్‌లోని స్టేట్‌మెంట్‌లను అమలు చేస్తుంది. పరీక్ష వ్యక్తీకరణ తప్పు అయిన వెంటనే, అమలు సమయంలో లూప్‌ను దాటవేసి ప్రోగ్రామ్‌లోని తదుపరి స్టేట్‌మెంట్‌లకు వెళుతుంది.
లూప్‌లోని ప్రవాహాన్ని నియంత్రించడానికి, బ్రేక్ మరియు కంటిన్యూ వంటి వివిధ నియంత్రణ స్టేట్‌మెంట్‌లను టైమ్ లూప్‌లో ఉపయోగించవచ్చు. కాసేపు లూప్‌లో ఈ నియంత్రణ స్టేట్‌మెంట్‌లను ఎలా ఉపయోగించవచ్చో చూద్దాం.
పైథాన్ కంట్రోల్ స్టేట్మెంట్స్ ఎట్ లూప్
బ్రేక్ స్టేట్మెంట్:
పైథాన్లోని బ్రేక్ స్టేట్మెంట్ అది ఎదుర్కొన్న బ్లాక్ యొక్క మొత్తం అమలును దాటవేయడానికి ఉపయోగించబడుతుంది. లూప్‌లో బ్రేక్ స్టేట్మెంట్ ఎదురైన వెంటనే, అమలు మిగిలిన పునరావృతాలను దాటవేసి లూప్ నుండి బయటకు వెళుతుంది.
ఫైల్ క్లాస్ యొక్క ఉదాహరణను సృష్టించడానికి కారణాలు ఏమిటి?
i = 1 అయితే నేను<= 5 : print(i) if i == 4: break i = i+1
అవుట్పుట్: 1 2 3 4
X యొక్క విలువ 4 అయిన వెంటనే, అమలు మిగిలిన పునరావృతాలను దాటవేస్తుంది. ఇది అమలును ఎలా ప్రభావితం చేస్తుందో అర్థం చేసుకోవడానికి నిరంతర ప్రకటనతో మరొక ఉదాహరణ తీసుకోండి.
ప్రకటన కొనసాగించండి
లూప్‌లోని ప్రస్తుత పునరుక్తిని దాటవేయడానికి కొనసాగించు ఉపయోగించబడుతుంది. కొనసాగింపు లూప్‌లో ఎదురైన వెంటనే, ప్రస్తుత పునరావృతం దాటవేయబడుతుంది, కాని మిగిలిన పునరావృత్తులు ఇప్పటికీ అమలు చేయబడతాయి.
i = 1 అయితే నేను<=5 : if i == 4: i = i+1 continue else: print(i) i = i+1
అవుట్పుట్: 1 2 3 5
లూప్‌లో కంటిన్యూ స్టేట్మెంట్ ఎదురైన వెంటనే ప్రస్తుత పునరావృతం దాటవేయబడింది మరియు లూప్ మిగిలిన పునరావృతాలను అమలు చేస్తుంది.
షరతులతో కూడిన ప్రకటనలతో లూప్ అయితే
పైథాన్‌లో నిర్ణయం తీసుకోవడానికి ఉపయోగించే పరీక్ష వ్యక్తీకరణగా షరతులతో కూడిన స్టేట్‌మెంట్‌లు కూడా తార్కిక పరిస్థితులను కలిగి ఉంటాయి. కాసేపు లూప్‌లో షరతులతో కూడిన స్టేట్‌మెంట్‌ల వాడకాన్ని అర్థం చేసుకోవడానికి ఒక ఉదాహరణ తీసుకుందాం.
పైథాన్‌లో శక్తిని ఎలా ఉపయోగించాలి
num = int (ఇన్పుట్ ('సంఖ్యను నమోదు చేయండి')) అయితే num> = 0: if num == 0: print ('సున్నాకి సమానం') elif num> 0: print ('సున్నా కంటే ఎక్కువ') else: print ( 'చెల్లుబాటు అయ్యే సంఖ్యను నమోదు చేయండి') విరామంఇది ఒక సాధారణ ఉదాహరణ, ఇక్కడ మేము ప్రోగ్రామ్‌లో షరతులతో కూడిన మరియు వేరే స్టేట్‌మెంట్‌లను ఉపయోగించాము. మరింత సంక్లిష్టమైన నిర్ణయం తీసుకునే సమస్యల కోసం మేము షరతులతో కూడిన స్టేట్‌మెంట్‌లను కాసేపు లూప్‌లో ఉపయోగించవచ్చు, ఇక్కడ పరీక్ష వ్యక్తీకరణ ప్రారంభంలో ప్రకటించబడుతుంది.
లూప్ అయితే అనంతం
అనంతమైన లూప్ అనంతమైన సమయాన్ని అమలు చేస్తుంది, అంటే సిద్ధాంతపరంగా అమలు ఎప్పుడూ ఆగదు. ఇది ఆశ్చర్యం కలిగించవచ్చు కాని దీనికి దాని స్వంత ప్రయోజనాలు మరియు అప్రయోజనాలు ఉన్నాయి.
ఉదాహరణకు, మేము ఇంక్రిమెంట్ పేర్కొనకపోతే ఆపరేటర్ పరీక్ష వ్యక్తీకరణలోని వేరియబుల్ కోసం, లూప్ ఎప్పటికీ ఆపదు అంటే అది అనంతమైన సమయాలను అమలు చేస్తుంది.
i = 4 అయితే i> 0: ప్రింట్ ('నేను అనంతం అయితే లూప్')మేము ctrl + c ని నొక్కితే లేదా లూప్‌లో కంట్రోల్ స్టేట్మెంట్ ఉంచకపోతే ఈ ప్రోగ్రామ్ అనంతమైన పునరావృతాలను అమలు చేస్తుంది.
లూప్ అయితే గూడు
కాసేపు లూప్ మరొకటి అయితే లూప్ కలిగి ఉంటే మనం దానిని లూప్ అయితే సమూహంగా పిలుస్తాము. గూడులో ఉన్న లూప్‌లో ఉచ్చుల సంఖ్యకు ప్రత్యేక పరిమితి లేదు. ఇది ప్రోగ్రామ్‌లో వినియోగదారుకు అవసరమయ్యే లేదా ప్రకటించినన్ని సార్లు కొనసాగవచ్చు.
దీన్ని అర్థం చేసుకోవడానికి ఒక ఉదాహరణను చూద్దాం:
i = 1 j = 5 అయితే నేను 0: ప్రింట్ (i, j) j = j -1 i = i + 1
అవుట్పుట్: 1 5 2 4 3 3 4 2 5 1
ఈ ఉదాహరణలో, మాకు రెండు ఉన్నాయి వేరియబుల్స్ i మరియు j వేర్వేరు పరీక్ష వ్యక్తీకరణలలో ఉపయోగించబడతాయి. ఇది సమూహ లూప్‌ను ఉపయోగించటానికి ఒక క్లాసిక్ ఉదాహరణ.
షరతులతో కూడిన మరియు నియంత్రణ స్టేట్‌మెంట్‌లను ఉపయోగించి మరొక ఉదాహరణ తీసుకుందాం.
i = 'edureka' j = 1 అయితే j> 0: i లో x కోసం: ప్రింట్ (j, x) j = j + 1 ఉంటే x == 'a': బ్రేక్
అవుట్పుట్: 1 ఇ 2 డి 3 యు 4 ఆర్ 5 ఇ 6 కె 7 ఎ
ఈ వ్యాసంలో పైథాన్‌లో అయితే లూప్ అనే భావనను వివిధ ఉదాహరణలతో చర్చించాము. మనకు పరీక్ష వ్యక్తీకరణ ఉన్నప్పుడు లూప్ ఒక ముఖ్యమైన పాత్ర పోషిస్తుంది, ఇది లూప్ ప్రారంభంలో పరీక్షించవచ్చు. ఉదాహరణకు- బ్యాంక్ డేటా కోసం కాసేపు లూప్‌ను ఉపయోగించడం, ఇక్కడ పరీక్ష వ్యక్తీకరణ సంతృప్తి చెందితే మాత్రమే మేము ముందుకు వెళ్తాము, ఈ సందర్భంలో ఏదైనా గణాంక విలువ కావచ్చు. పైథాన్ ప్రోగ్రామింగ్ భాష ప్రాప్యత సౌలభ్యం కోసం ప్రాథమిక భావనలతో పనిచేయడం సులభం చేస్తుంది. మీ నైపుణ్యాలను నేర్చుకోవటానికి ఎడురేకాలో నమోదు చేసుకోండి మరియు మీ అభ్యాసాన్ని కిక్‌స్టార్ట్ చేయండి.
ఏమైనా ప్రశ్నలు ఉన్నాయా? వ్యాఖ్యల విభాగంలో వాటిని పేర్కొనండి. మేము వీలైనంత త్వరగా మిమ్మల్ని సంప్రదిస్తాము.