పైథాన్‌లో లూప్ కోసం. సింటాక్స్, జాబితా పునరావృతం, విరామం, కొనసాగింపు మరియు ఇతర లక్షణాలు

Цపైథాన్ i కోసం ikl చక్రం అయితే - ప్రకటనలు సాఫ్ట్వేర్ భాష, అవి: పునరావృత ఆపరేటర్లు, వీలుING పునరావృత కోడ్ ఇచ్చిన సంఖ్య సమయం.

Цఉదాహరణకు - сఇంటాక్సిస్

ఇప్పటికే వివరించినట్లుగా, సిపైథాన్‌లో ఆధారితమైనది ఇటరేటర్й ప్రతి చక్రానికిగుర్తింపు. వాడేనా చర్యలు టుపుల్ మూలకాల ద్వారా и జాబితా పదజాలం కీలు మరియు ఇతర పునరావృత వస్తువులు.

పైథాన్‌లోని లూప్ ఫర్ కీవర్డ్‌తో ప్రారంభమవుతుంది, దాని తర్వాత ఇచ్చిన క్రమంలో తదుపరి వస్తువు యొక్క విలువను నిల్వ చేసే ఏకపక్ష వేరియబుల్ పేరు. పైథాన్‌లో… కోసం సాధారణ వాక్యనిర్మాణం ఇలా కనిపిస్తుంది:

కోసం: else:      

భాగాలు "క్రమాలు" జాబితా చేయబడ్డాయి ఒకదాని తరువాత ఒకటి చక్రం వేరియబుల్. అది కాకపోతే, వేరియబుల్ పాయింట్లు ఇటువంటి అంశాలు. ప్రతిఒక్కరికీ వారిది "చర్య" నిర్వహిస్తారు.

ఒక నిర్దిష్ట ఉదాహరణతో పైథాన్‌లో లూప్ కోసం సరళమైనది:

>>> భాషలు = ["C", "C++", "Perl", "Python"] >>> భాషలలో x కోసం: ... print(x) ... C C++ Perl Python >>>

మిగతా బ్లాక్ ప్రత్యేకంవ. ఒకవేళ ఎ ప్రోగ్రామర్ыపని с పెర్ల్ సుపరిచితుడుы అతనితో, ఆ ఇంటరాక్ట్ అయ్యే వారికి с C మరియు C++ — ఇది ఒక ఆవిష్కరణ. అర్థపరంగా అది విధులు тఒకేలా లూప్ అయితే.

బ్రేక్ స్టేట్‌మెంట్ ద్వారా లూప్ "ఆపివేయబడనప్పుడు" మాత్రమే అమలు చేయబడుతుంది. అంటే, అన్ని మూలకాలు పేర్కొన్న క్రమాన్ని దాటిన తర్వాత మాత్రమే ఇది అమలు చేయబడుతుంది.

పైథాన్‌లో బ్రేక్ ఆపరేటర్ - బ్రేక్

ప్రోగ్రామ్‌లో లూప్ ఉంటే అవసరం అంతరాయంది విరామం ప్రకటన, he పూర్తిఅది వెళుతుందిమరియు కార్యక్రమం ప్రవాహం రెడీ సంప్రఉండాలి క్రియాశీలతను వేరే నుండి.

చాలా తరచుగా పైథాన్‌లోని పదబంధాలను విచ్ఛిన్నం చేయండిuyutsya షరతులతో కూడిన ప్రకటనలతో.

edibles = ["chops", "dumplings","egs","nuts"] edibles in food: if food == "dumplings": print("నేను dumplings తినను!") బ్రేక్ ప్రింట్("గ్రేట్, రుచికరమైన " + ఆహారం) else: print("కుడుములు లేకపోవటం మంచిది!") ప్రింట్("డిన్నర్ ముగిసింది.")

మీరు ఈ కోడ్‌ని అమలు చేస్తే, మీరు ఈ క్రింది ఫలితాన్ని పొందుతారు:

గొప్ప, రుచికరమైన చాప్స్. నేను కుడుములు తినను! డిన్నర్ అయిపోయింది.

మేము ఇప్పటికే ఉన్న డేటా జాబితా నుండి "డంప్లింగ్స్"ని తీసివేసి, పొందుతాము:

అద్భుతమైన, రుచికరమైన చాప్స్ అద్భుతమైన, రుచికరమైన గుడ్లు అద్భుతమైన, రుచికరమైన గింజలు మంచి విషయం కుడుములు లేవు! డిన్నర్ అయిపోయింది.

python skip operator – continue

అటువంటి ఉత్పత్తుల పట్ల వినియోగదారు యొక్క వ్యతిరేకత వారి వినియోగాన్ని పూర్తిగా వదిలివేయడం అంత గొప్పది కాదని చెప్పండి. ఫలితంగా, లూప్ ఆపరేటర్‌తో కొనసాగుతుంది continue. కింది స్క్రిప్ట్ ప్రకటనను ఉపయోగిస్తుంది continue, "డంప్లింగ్ కాంటాక్ట్"లో జాబితా ద్వారా పునరావృతం చేయడం కొనసాగించడానికి.

తినదగినవి = ["చాప్స్", "డంప్లింగ్స్","గుడ్లు","నట్స్"] తినదగిన వాటిలో ఆహారం కోసం: ఆహారం == "కుడుములు": ప్రింట్("నేను కుడుములు తినను!") ముద్రణను కొనసాగించు("గొప్ప, రుచికరమైన " + ఆహారం) # ఇది ఆహారాన్ని ఆస్వాదించడానికి కోడ్ కావచ్చు :-) else: print("నేను కుడుములు ద్వేషిస్తాను!") ప్రింట్("డిన్నర్ ముగిసింది.")

బాటమ్ లైన్:

గొప్ప, రుచికరమైన చాప్స్. నేను కుడుములు తినను! గొప్ప, రుచికరమైన గుడ్లు గొప్ప, రుచికరమైన గింజలు నేను కుడుములు ద్వేషిస్తాను! డిన్నర్ అయిపోయింది.

శ్రేణి() ఫంక్షన్‌తో జాబితాలపై మళ్ళించడం

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

fibonacci = [0,1,1,2,3,5,8,13,21] i కోసం పరిధిలో (len(fibonacci)): print(i,fibonacci[i])

పొందండి:

0 0 1 1 2 1 3 2 4 3 5 5 6 8 7 13 8

శ్రద్ధ! దరఖాస్తు చేసినప్పుడు len() к list or tuple, ఇచ్చిన క్రమం యొక్క మూలకాల యొక్క సంబంధిత సంఖ్య పొందబడుతుంది.

జాబితాలపై పునరావృతం చేయడంలో ఇబ్బందులు

జాబితాపై మళ్ళించేటప్పుడు, లూప్ బాడీలో జాబితా డైనమిక్‌లను నివారించాలని సిఫార్సు చేయబడింది. స్పష్టత కోసం, మేము ఈ క్రింది ఎంపికను అందిస్తాము:

రంగులలో i కోసం రంగులు = ["ఎరుపు"]: i == "ఎరుపు" అయితే: రంగులు += ["నలుపు"] అయితే == "నలుపు": రంగులు += ["తెలుపు"] ప్రింట్ (రంగులు)

దరఖాస్తు చేసినప్పుడు ఏమి జరుగుతుంది print(colours)?

['ఎరుపు', 'నలుపు', 'తెలుపు']

దీన్ని నివారించడానికి, దిగువ ఉదాహరణలో వలె స్లైస్‌లను ఉపయోగించి కాపీతో పరస్పర చర్య చేయాలని సిఫార్సు చేయబడింది:

రంగులు = ["ఎరుపు"] కోసం నేను రంగులలో[:]: i == "ఎరుపు" అయితే: రంగులు += ["నలుపు"] అయితే నేను == "నలుపు": రంగులు += ["తెలుపు"] ప్రింట్(రంగులు )

ఫలితం:

['ఎరుపు నలుపు']

జాబితా మార్చబడింది colours, కానీ ఈ చర్య లూప్‌ను ప్రభావితం చేయలేదు. లూప్ అమలు సమయంలో పునరావృతం చేయవలసిన డేటా మారదు.

పైథాన్ 3లో లెక్కించండి

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

కౌంటర్ కోసం, ఎన్యుమరేట్‌లో విలువ(కొన్ని_జాబితా): ప్రింట్(కౌంటర్, విలువ)

ఫంక్షన్ enumerate ఐచ్ఛిక వాదనను కూడా తీసుకుంటుంది (మూలం యొక్క విలువ, డిఫాల్ట్‌గా తీసుకోబడింది 0) ఇది మరింత సమర్థవంతంగా చేస్తుంది.

my_list = సి కోసం ['యాపిల్', 'అరటి', 'చెర్రీ', 'పీచ్'], ఎన్యుమరేట్‌లో విలువ(నా_జాబితా, 1): ప్రింట్(సి, విలువ) # ఫలితం: # 1 ఆపిల్ # 2 అరటిపండు # 3 చెర్రీ # 4 పీచు