Home-theater-designers
ఏ ఇతర ప్రోగ్రామింగ్ లాంగ్వేజ్ లాగా, పైథాన్‌లో లూపింగ్ చేయడం అనేది పునరావృత కోడ్ రాయడాన్ని నివారించడానికి ఒక గొప్ప మార్గం. అయితే, పైథాన్‌లా కాకుండా అయితే లూప్, ది కోసం లూప్ అనేది ఒక ఖచ్చితమైన నియంత్రణ ఫ్లో స్టేట్‌మెంట్, ఇది సిరీస్‌లోని ప్రతి అంశంపై మీకు మరింత అధికారాన్ని ఇస్తుంది.
మీరు పైథాన్ అనుభవశూన్యుడు అయినా లేదా దాని గురించి మీకు ఇప్పటికే కొంత అనుభవం ఉన్నా, దాని యొక్క గట్టి పట్టును కలిగి ఉండండి కోసం శ్రేణికి సంబంధించిన సమస్యలను పరిష్కరించడంలో లూప్ కీలకం. ఇక్కడ, పైథాన్ ఎలా ఉందో చూద్దాం కోసం లూప్ పనిచేస్తుంది మరియు కోడింగ్ సవాళ్లను పరిష్కరించడానికి మీరు దాన్ని ఎలా ఉపయోగించవచ్చో కొన్ని ఉదాహరణలు.
పైథాన్‌లో లూప్‌లు ఎలా పని చేస్తాయి
పైథాన్ కోసం లూప్ శ్రేణి యొక్క క్రమం ద్వారా పునరుక్తి చేయడం ద్వారా పనిచేస్తుంది. సారాంశంలో, స్ట్రింగ్స్, లిస్ట్‌లు, టుపుల్స్, డిక్షనరీలు లేదా సెట్‌లు వంటి సీక్వెన్స్‌లతో వ్యవహరించేటప్పుడు ఇది ఉపయోగపడుతుంది. ఒక లో కీవర్డ్ సాధారణంగా a ని అనుసరిస్తుంది కోసం పైథాన్‌లో లూప్.
కు కోసం లూప్ అన్ని ప్రోగ్రామింగ్ భాషలలో ఒకే విధమైన లక్షణాలను కలిగి ఉంది. ఉదాహరణకు, వాక్యనిర్మాణ వ్యత్యాసాలు ఉన్నప్పటికీ, లూప్ కోసం జావా యొక్క లక్షణం పైథాన్ ఫర్ లూప్ ఎలా పనిచేస్తుందో అదేవిధంగా ఉంటుంది.
పైథాన్ యొక్క సాధారణ వాక్యనిర్మాణం కోసం లూప్ ఇలా కనిపిస్తుంది:
for new_variable in parent_variable:
execute some statements
ముందుగా చెప్పినట్లుగా, a కి భిన్నంగా అయితే లూప్, ది కోసం లూప్ మరింత శక్తివంతమైనది, ఎందుకంటే ఇది ప్రవాహంలో మరింత నియంత్రణను అందిస్తుంది.
మెరుగైన అవగాహన కలిగి ఉండటానికి, a కోసం లూప్ సాధారణంగా ఈ ఉదాహరణ ప్రకటన వలె కనిపిస్తుంది: 'మీరు ఒక క్లాసులో కలిసే ప్రతి మగ విద్యార్థికి, ఒకదాన్ని వ్రాయండి, లేకుంటే, ఇది కేవలం ఒక తరగతికి చెందిన స్త్రీల వ్రాయండి.'
ఒక నిర్దిష్ట తరగతిలో మీరు ఎదుర్కొనే ప్రతి మగ విద్యార్థికి ఒకటి వ్రాస్తూనే ఉండాలని చెప్పే ఒక సాధారణ సూచన ఆ ప్రకటన. ఇది నిరంతర లూప్. అయితే, ప్రారంభించడానికి కోసం ఆ సందర్భంలో లూప్, మీరు తప్పనిసరిగా ఒక మగ విద్యార్థిని ఎదుర్కోవాలి. కాకపోతే, మీరు వేరే స్టేట్‌మెంట్‌ని వ్రాసుకోండి.
ఒకవేళ పైన పేర్కొన్న స్టేట్‌మెంట్‌లో ఒకటి లేకపోతే లేకపోతే పరిస్థితి, అప్పుడు మీరు ఏమీ వ్రాయరు. అంటే ఇది ఖాళీ శ్రేణి.
పైథాన్ లూప్ కోసం ఎలా ఉపయోగించాలి: ప్రాక్టికల్ ఉదాహరణలు
ఇప్పుడు a ని ఎలా ఉపయోగించాలో కొన్ని ఆచరణాత్మక ఉదాహరణలను చూద్దాం కోసం పైథాన్‌లో లూప్.
దిగువ కోడ్ స్నిప్పెట్ జాబితాలోని ప్రతి అంశాన్ని అందిస్తుంది:
items = ['shoe', 'bag', 'shirts', 'lamp']
for i in items:
print(i)
మీరు 'a' అక్షరాన్ని కలిగి ఉన్న ఏదైనా అంశాన్ని అవుట్‌పుట్ చేయడానికి పై కోడ్‌ని కూడా సవరించవచ్చు:
ఫైల్ ఉపయోగంలో ఉన్నందున తొలగించబడదు
items = ['shoe', 'bag', 'shirts', 'lamp']
for i in items:
if 'a' in i:
print(i)
కు కోసం పైథాన్‌లోని లూప్ కూడా నేరుగా తీసుకుంటుంది లేకపోతే ప్రకటన:
b=[2, 3, 5, 6]
for i in b:
print(i)
else:
print('Loop has ended')
మీరు a ని ఉపయోగించవచ్చు విరామం a యొక్క ప్రవాహాన్ని మార్చడానికి ప్రకటన కోసం లూప్ అలాగే:
నా ఫోన్‌లో వోల్టే అంటే ఏమిటి
b=[2, 3, 5, 6]
for i in b:
if i>3:
break
print(i)
మీరు కూడా ఉపయోగించవచ్చు కొనసాగించండి a తో కీవర్డ్ కోసం లూప్:
b=[2, 3, 5, 6]
for i in b:
if i>3:
continue
print(i)
పైథాన్‌లో జాబితా మరియు స్ట్రింగ్ సాహిత్యాలతో లూప్ కోసం ఉపయోగించడం
ఇప్పుడు 1 మరియు 100 మధ్య ఉన్న అన్ని పాజిటివ్ పూర్ణాంకాలను అవుట్‌పుట్ చేయడానికి దిగువ కోడ్‌ని చూడండి. దీన్ని చేయడానికి, మీరు మొదట పైథాన్ అంతర్నిర్మిత ఉపయోగించి 1 మరియు 100 మధ్య సంఖ్యల జాబితాను సృష్టించండి పరిధి ఫంక్షన్:
for x in range(1, 101):
print(x)
1 మరియు 100 మధ్య అన్ని బేసి సంఖ్యలను అవుట్‌పుట్ చేయడానికి షరతులతో కూడిన స్టేట్‌మెంట్‌ను ప్రవేశపెట్టడం ద్వారా మీరు ఆ కోడ్ బ్లాక్‌ను సవరించవచ్చు:
for x in range(1, 101):
if x%2==1:
print(x)
అయితే, మీరు పై కోడ్ యొక్క అవుట్‌పుట్ యొక్క '2 బై అవుట్‌పుట్' గుణకార పట్టికను కూడా సృష్టించవచ్చు. దీనిని సాధించడానికి, మీరు ఇలాంటి మరికొన్ని స్టేట్‌మెంట్‌లను మాత్రమే జోడించాలి:
for x in range(1, 101):
if x%2==1:
print(x, 'x', 2, '=', x * 2)
ఇప్పుడు మీరు చూసారు ఎలా a కోసం లూప్ పూర్ణాంకాల జాబితాతో పనిచేస్తుంది. మనం ఎలా ఉపయోగించవచ్చో చూద్దాం కోసం తీగలతో లూప్.
దిగువ కోడ్ ఒక వాక్యంలో ప్రతి స్ట్రింగ్ యొక్క క్రమాన్ని అందిస్తుంది:
a = 'How to use a for loop in Python'
for i in a:
print(i)
వేరియబుల్‌లోని స్ట్రింగ్‌ల సంఖ్య (ఖాళీలతో సహా) కూడా మనం లెక్కించవచ్చు కు ఒక ఉపయోగించి కోసం లూప్:
a = ['How to use a for loop in Python']
for i in a:
print(i.count(''))
Output: 32
అయితే, మీరు కూడా ఒక ఉంచవచ్చు కోసం ప్రత్యేక వేరియబుల్‌లో లూప్ చేయండి మరియు పైన ఉన్న కోడ్‌ను ఇలా వ్రాయడం ద్వారా ఇలాంటి ఫలితాన్ని పొందండి:
a=['How to use a for loop in Python']
c=[b.count('') for b in a]
print(c)
Output: [32]
గమనిక: అక్షర గణనను పొందడానికి, కుండలీకరణ మార్క్‌లలో కొటేషన్ మార్కుల మధ్య ఖాళీ లేదని నిర్ధారించుకోండి లెక్క కీవర్డ్.
ఒక ఉపయోగించి సాధారణ వర్డ్ కౌంటర్‌ని సృష్టించడానికి మీరు పైన ఉన్న చివరి రెండు కోడ్ స్నిప్పెట్‌లను కూడా సవరించవచ్చు కోసం లూప్. ఈ సందర్భంలో మీరు చేయాల్సిందల్లా కుండలీకరణంలోని ప్రతి ఉల్లేఖన గుర్తు మధ్య ఒకే ఖాళీని చొప్పించడం:
a=['How to use a for loop in Python']
for i in a:
print(i.count(' ') + 1)
Output: 8
అక్షరాల గణన కోసం మీరు చేసినట్లుగానే, పైన ఉంచిన వర్డ్ కౌంట్ కోడ్‌ను కూడా మీరు తిరిగి వ్రాయవచ్చు కోసం ఇలాంటి వేరియబుల్‌లో లూప్ చేయండి:
a = ['How to use a for loop in Python']
c=[b.count(' ') + 1 for b in a]
print(c)
Output: [8]
కుండలీకరణాల్లోని కోట్స్ మధ్య ఇప్పుడు ఉన్న ఒకే స్పేస్‌పై చాలా శ్రద్ధ వహించండి.
సంబంధిత: పైథాన్‌లో మీ స్వంత మాడ్యూల్‌ను ఎలా సృష్టించాలి మరియు మళ్లీ ఉపయోగించాలి
శ్రేణితో లూప్ కోసం పైథాన్‌ను ఉపయోగించడం
మీరు a ని కూడా ఉపయోగించవచ్చు కోసం శ్రేణి నుండి ఒక నిర్దిష్ట మూలకాన్ని పొందడానికి లూప్.
మీ వద్ద 'ఆరోగ్యకరమైన' జంతువులకు 'అవును' మరియు 'అనారోగ్య' గొర్రెలకు 'నో' విలువలు కలిగిన గొర్రెల శ్రేణి ఉందని అనుకోండి. ప్రతి గొర్రెకు ఒక ప్రత్యేకమైన పేరు ఉంటుంది మరియు మీరు జబ్బుపడిన వారందరినీ నిర్బంధించాలనుకుంటున్నారు.
ఆడియో ఫైల్‌ను చిన్నదిగా చేయడం ఎలా
మీరు a ని ఉపయోగించవచ్చు కోసం అన్ని అనారోగ్య గొర్రెలను ఉత్పత్తి చేయడానికి లూప్. ఎంత ఉపయోగకరంగా ఉందో చూడటానికి కోసం లూప్ ఆ సందర్భంలో ఉంది, దిగువ కోడ్ శ్రేణి నుండి అన్ని అనారోగ్య గొర్రెల పేరును అందిస్తుంది:
array = [{'name':'Sheep1', 'healthy':'Yes'},
{'name':'Sheep3', 'healthy':'No'},
{'name':'Sheep4', 'healthy':'Yes'},
{'name':'Sheep5', 'healthy':'Yes'},
{'name':'Sheep8', 'healthy':'No'},
{'name':'Sheep7', 'healthy':'No'},
{'name':'Sheep9', 'healthy':'No'}
]
for sheeps in array:
if sheeps['healthy']=='No':
print('Quarantine', sheeps['name'])
పైథాన్‌లో నెస్టెడ్ ఫర్ లూప్‌ను ఉపయోగించడం
ఒక గూడు కోసం మీరు ప్రతి మూలకాన్ని సంక్లిష్ట లేదా సమూహ శ్రేణిలో అవుట్‌పుట్ చేయాలనుకున్నప్పుడు లూప్ ఉపయోగపడుతుంది. ఇది మరొక లూప్ లోపల ఒక లూప్ ఉంచడం ద్వారా పనిచేస్తుంది. దిగువ ఉదాహరణ కోడ్ సమూహ జాబితాలోని ప్రతి అంశాన్ని అందిస్తుంది. అయితే, ఇది నిఘంటువు యొక్క కీలను మాత్రమే అందిస్తుంది:
nested_list = [[1, 2, 4, 5], {'name':'Python', 'method':'write'}]
for dict in nested_list:
for i in dict:
print(i)
కు పైథాన్ జాబితా మరియు శ్రేణుల గురించి మంచి అవగాహన గూడుతో వ్యవహరించేటప్పుడు ఉపయోగపడుతుంది కోసం లూప్.
ఉచ్చులు లేదా లూప్‌ల కోసం, ఏది మంచిది?
చేతిలో ఉన్న సమస్యను బట్టి, ప్రతి కోసం మరియు అయితే పైథాన్‌లో ఉచ్చులు దాని వినియోగ కేసును కలిగి ఉన్నాయి. ఒక అయినప్పటికీ కోసం లూప్ మరింత సాధారణం, అది మాస్టరింగ్ చేయదు అయితే తక్కువ ముఖ్యమైన లూప్.
కాగా a కోసం లూప్ ప్రోగ్రామింగ్ భాషలలో మరింత సాధారణ పరిష్కారాలను అందిస్తుంది, దానిని పైన ఉంచుతుంది అయితే లూప్ తప్పు. ఒకదానిని మరొకటి కంటే ఎక్కువ ఉపయోగకరంగా ఉంటుందని నమ్మడం కంటే, నిర్దిష్ట సమస్యలను పరిష్కరించడం కోసం వాటిలో దేనినైనా పరిగణనలోకి తీసుకోవడం ఎల్లప్పుడూ మంచిది. అంతేకాకుండా, పైథాన్ ప్రోగ్రామర్‌గా, మీరు వారిద్దరూ లేకుండా చేయలేరు.
షేర్ చేయండి షేర్ చేయండి ట్వీట్ ఇమెయిల్ పైథాన్‌లో కొంతకాలం లూప్‌ను ఎలా ఉపయోగించాలిలూప్లు కోడింగ్‌లో ప్రాథమిక భాగం అయితే, వాటిని ఇక్కడ ఉత్తమంగా ఎలా ఉపయోగించాలో తెలుసుకోండి.
తదుపరి చదవండి సంబంధిత అంశాలు- ప్రోగ్రామింగ్
- పైథాన్
ఇడోవు ఏదైనా స్మార్ట్ టెక్ మరియు ఉత్పాదకతపై మక్కువ చూపుతుంది. తన ఖాళీ సమయంలో, అతను కోడింగ్‌తో ఆడుతాడు మరియు అతను విసుగు చెందినప్పుడు చెస్‌బోర్డ్‌కి మారుతాడు, కానీ అతను ఒక్కోసారి రొటీన్ నుండి దూరంగా ఉండడాన్ని కూడా ఇష్టపడతాడు. ఆధునిక సాంకేతిక పరిజ్ఞానాన్ని ప్రజలకు చూపించాలనే అతని అభిరుచి అతన్ని మరింత రాయడానికి ప్రేరేపిస్తుంది.
ఇడోవు ఒమిసోలా నుండి మరిన్నిమా వార్తాలేఖకు సభ్యత్వాన్ని పొందండి
టెక్ చిట్కాలు, సమీక్షలు, ఉచిత ఈబుక్‌లు మరియు ప్రత్యేకమైన డీల్స్ కోసం మా వార్తాలేఖలో చేరండి!
సభ్యత్వం పొందడానికి ఇక్కడ క్లిక్ చేయండి