విషయ సూచిక[దాచు][చూపండి]
చివరి ట్యుటోరియల్లో, అయితే లూప్లు మరియు కోడ్ బ్లాక్ను అనేకసార్లు ఎలా అమలు చేయాలి అనే దాని గురించి మేము నేర్చుకున్నాము.
పైథాన్లో, మనకు “ఫర్ లూప్” మరియు “నెస్టెడ్ లూప్” వంటి ఇతర రకాల లూప్లు ఉన్నాయి. వాటిని ఎలా ఉపయోగించాలో చూద్దాం.
ఉచ్చులు కోసం
మేము స్ట్రింగ్ వంటి సేకరణలోని వస్తువులపై మళ్ళించడానికి "లూప్ కోసం" ఉపయోగిస్తాము. స్ట్రింగ్ అనేది అక్షరాల శ్రేణి అయినందున, ఇది ఒక సేకరణ వలె కనిపిస్తుంది. కాబట్టి, స్ట్రింగ్లోని ప్రతి క్యారెక్టర్పై మళ్ళించడానికి మనం లూప్ని ఉపయోగించవచ్చు మరియు దానితో ఏదైనా చేయవచ్చు.
ఇక్కడ ఒక ఉదాహరణ ఉంది.
మేము వేరియబుల్ తర్వాత “for” అని టైప్ చేసి ఆపై స్ట్రింగ్ చేస్తాము.
for item in 'Python':
ఇక్కడ "ఐటెమ్" అంటే పైథాన్ అనే పదం యొక్క అక్షరాలు. లూప్ యొక్క మొదటి పునరావృతంలో “ఐటెమ్” అంటే 'P', రెండవ పునరావృతం అంటే 'y' మరియు మొదలైనవి. దీన్ని అమలు చేద్దాం
ఈ స్ట్రింగ్లోని ప్రతి అక్షరం కొత్త లైన్లో ముద్రించబడిందని మీరు చూడవచ్చు.
మరొక ఉదాహరణ చూద్దాం. పైథాన్లో, మేము స్క్వేర్ బ్రాకెట్లను ఉపయోగించి జాబితాలను నిర్వచించవచ్చు. కాబట్టి చదరపు బ్రాకెట్లను ఉపయోగించి జాబితాను నిర్వచించనివ్వండి.
for item in ['Shahbaz', 'Aayush', 'Jay']:
print(item)
ఇప్పుడు అది మూడు పేర్లను వేర్వేరు లైన్లలో జాబితా చేస్తుంది.
ఈ సెట్టింగ్లో మనం సంఖ్యల జాబితాను కూడా ఉపయోగించవచ్చు. 0 నుండి 9 వరకు ఉన్న అన్ని సంఖ్యలను టైప్ చేయడానికి బదులుగా, నేను విషయాలను సరళీకృతం చేయడానికి "రేంజ్" ఫంక్షన్ని ఉపయోగించబోతున్నాను. అది ఎలా జరుగుతుందో చూద్దాం.
for item in range(10):
print(item)
మనం దీన్ని 0తో కాకుండా ప్రారంభించేలా ప్రోగ్రామ్ చేయవచ్చు.
for item in range(5, 10):
ఇది టెర్మినల్లో 5 నుండి 9 సంఖ్యలను ముద్రిస్తుంది.
"రేంజ్" ఫంక్షన్ కూడా దశలను ఇన్పుట్గా తీసుకోవచ్చు. కాబట్టి మనం ఇలా వ్రాస్తే:
for item in range(5, 10, 2):
ఇది 5, 7 మరియు 9ని ముద్రిస్తుంది, అంటే ప్రతి పునరావృతం తర్వాత ఇది రెండు అడుగులు ముందుకు వెళుతుంది.
వ్యాయామం
ఇప్పుడు ఇక్కడ మీ కోసం ఒక వ్యాయామం ఉంది. షాపింగ్ కార్ట్లోని అన్ని వస్తువుల మొత్తం ధరను లెక్కించడానికి మీరు ప్రోగ్రామ్ను వ్రాయాలని నేను కోరుకుంటున్నాను. కాబట్టి మేము 10, 20 మరియు 30 వంటి ధరల జాబితాను కలిగి ఉన్నామని చెప్పండి, మా ఊహాత్మక షాపింగ్ కార్ట్లోని అన్ని వస్తువుల మొత్తం ధరను లెక్కించడానికి మీరు ఫర్ లూప్ని ఉపయోగించాలని నేను కోరుకుంటున్నాను.
మీ మెదడును పనిలో పెట్టుకోండి మరియు మీరు దీన్ని చేయగలరో లేదో చూడండి. మోసం లేదు.
సొల్యూషన్
మీరు ధరలను ఇలా జాబితా చేయడం ద్వారా ప్రారంభించవచ్చు.
prices = [10, 20, 30]
ఇప్పుడు మొదటి పునరావృతం కోసం 0 నుండి ప్రారంభమయ్యే మొత్తం ధర కోసం వేరియబుల్ని జోడించండి.
total = 0
ఇక్కడ మా లూప్ ఉంది.
for price in prices:
total = total + price
// దీన్ని ఇలా సరళీకరించవచ్చు total += price
print(f"Total: {total}")
నెస్టెడ్ లూప్స్
పైథాన్లో, నెస్టెడ్ లూప్ని ఉపయోగించడం అంటే ప్రాథమికంగా మరొక లూప్ లోపల ఒక లూప్ని జోడించడం, మరియు ఈ టెక్నిక్తో మనం కొన్ని అద్భుతమైన పనులు చేయవచ్చు. ఉదాహరణకు, మేము కోఆర్డినేట్ల జాబితాను సులభంగా రూపొందించవచ్చు.
కోఆర్డినేట్, మీకు తెలిసినట్లుగా 'x' మరియు 'y' విలువల కలయిక. 0 మరియు 0 అనుకుందాం. ఇప్పుడు మీరు ఇలాంటి కోఆర్డినేట్ల జాబితాను రూపొందించాలనుకుంటున్నారని అనుకుందాం. మనకు 0 మరియు 0 ఉన్నాయి, అప్పుడు మనకు 0 మరియు 1, ఆపై 0 మరియు 2 ఉంటాయి.
తర్వాత, మనం 'x'ని మార్చబోతున్నాం. మేము 'x' కోసం 1ని ఉపయోగించబోతున్నాము మరియు మరోసారి 'y' కోఆర్డినేట్ల కోసం ఈ 3 విలువలను ఉపయోగించబోతున్నాము.
నెస్టెడ్ లూప్లను ఉపయోగించి మనం ఈ కోఆర్డినేట్లను సులభంగా రూపొందించవచ్చు.
నన్ను చూపించనివ్వు.
for x in range(4):
for y in range(3):
print(f'({x}, {y}')
అవుట్పుట్ని తనిఖీ చేద్దాం:
కాబట్టి ఈ ప్రోగ్రామ్ ఎలా అమలు చేయబడుతుందో నాకు వివరిస్తాను. మన ఔటర్ లూప్ యొక్క మొదటి పునరావృతంలో, 'x' అనేది 0. ఇప్పుడు మనం లైన్ 2లో ఉన్నాము, ఇక్కడ మనకు కొత్త లూప్ ఉంది, దానిని మనం ఇన్నర్ లూప్ అని పిలుస్తాము. ఈ ఇన్నర్ లూప్లో, మొదటి పునరావృతంలో, 'y' 0 అవుతుంది, కాబట్టి టెర్మినల్లో 0 మరియు 0 ముద్రించబడతాయి.
ఇప్పుడు నియంత్రణ పంక్తి 2కి లేదా మన లోపలి లూప్కి తిరిగి వెళుతుంది. ఈ రెండవ పునరావృతంలో, 'y' 1కి సెట్ చేయబడుతుంది, కానీ మేము ఇప్పటికీ మా బాహ్య లూప్ యొక్క మొదటి పునరావృతంలోనే ఉన్నాము. కాబట్టి 'x' ఇప్పటికీ 0, కానీ ఇప్పుడు 'y' 1కి పెరిగింది.
అందుకే టెర్మినల్లో 0 మరియు 1 లను చూస్తాము. ఇది మా అంతర్గత లూప్ అమలు చేయబడే వరకు కొనసాగుతుంది, ఆపై ఇంటర్ప్రెటర్ మళ్లీ బాహ్య లూప్కి వెళ్తాడు మరియు బాహ్య లూప్ పూర్తయ్యే వరకు ఈ ప్రక్రియ కొనసాగుతుంది.
ఛాలెంజ్
ఇక్కడ మీ కోసం ఒక వ్యాయామం ఉంది, అయితే ఇది మీరు ఇప్పటివరకు చేసిన వ్యాయామాల కంటే కొంచెం ఎక్కువ సవాలుతో కూడుకున్నది.
సమూహ లూప్లను ఉపయోగించి, ఈ 'F' ఆకారాన్ని గీయడానికి కోడ్ను వ్రాయండి:
సొల్యూషన్
numbers = [5, 2, 5, 2, 2]
for x_count in numbers:
output = ''
//మేము అవుట్పుట్ వేరియబుల్ని ఖాళీ స్ట్రింగ్కి రీసెట్ చేయబోతున్నాం.
for count in range(x_count):
output += 'x'
print(output)
నెస్టెడ్ లూప్లను ఉపయోగించకుండా దీన్ని అమలు చేయడానికి చాలా సులభమైన మార్గం ఉంది. నేను దానిని గుర్తించడానికి మీకు వదిలివేస్తున్నాను.
సర్ప్ అప్ చేయండి
ప్రతి ఉపన్యాసంతో మీరు కూడా వేడిని అనుభవిస్తున్నారా?
నాకు ఖచ్చితంగా అలా అనిపిస్తుంది. మీకు అర్థమయ్యేలా నేను చాలా సులభతరం చేసాను.
మన తదుపరి ఉపన్యాసంతో విషయాలను తెలియజేస్తాము.
సమాధానం ఇవ్వూ