పైథాన్ ప్రోగ్రామింగ్ లాంగ్వేజ్: ఉచ్చులు

పైథాన్ ప్రోగ్రామింగ్ భాషలో ("పైథాన్" లేదా "పైథాన్"), కొన్ని చర్యలను వెతికే అనేక మార్గాలు ఉన్నాయి. పైథాన్ లో ఒక పునరుక్తిని అమలు చేయుటకు ప్రధాన సాధనాలు సమయంలో మరియు ఉచ్చులు. అయితే లూప్ మరింత సార్వత్రికంగా ఉంటుంది, కనుక ఇది నెమ్మదిగా ఉంటుంది. అయితే, ఇది మంచిదని కాదు! లూప్ కోసం చాలా తరచుగా ఉపయోగిస్తారు, ఎందుకంటే దాని సహాయంతో బహుళ-స్థాయి మరియు బహుళ-షరతులతో కూడిన కార్యక్రమాలను రూపొందించడానికి అత్యంత క్లిష్టమైన పనులు అమలు చేయబడ్డాయి.

పైథాన్: పోస్ట్ కోన్డిషన్తో ఒక చక్రం

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

ప్రోగ్రామింగ్ లాంగ్వేజ్ పైథాన్లో, కింది వాక్యనిర్మాణాన్ని కలిగి ఉండగా పోస్ట్ కోన్డిషన్తో ఉచ్చులు:

ఈ వ్యక్తీకరణ ఒక బోధన లేదా అనేకమైనది కావచ్చు. ఒక పరిస్థితి ఎల్లప్పుడూ ఒక నిర్దిష్ట నిజమైన విలువ లేదా ఒక సున్నా విలువ. ఇచ్చిన పరిస్థితి నిజం అయినంతవరకు ఇటువంటి నిర్మాణం పనిచేస్తుంది.

ఉదాహరణకు పైథాన్లో లూప్ను ఉపయోగించి

మేము లూప్ వివరిస్తాము. పైథాన్ దాని నిద్రాణాలను నిర్మాణాత్మకంగా నిర్మించింది:

మేము వేరియబుల్ "a" ను ప్రకటించి దానిని సున్నాకు సెట్ చేసాము. అప్పుడు మనము "7" అయితే వేరియబుల్ "a" తక్కువగా ఉన్నప్పుడు, "<7" అనే స్థితిని సెట్ చేసాము, ఇది తప్పుడు అవుతుంది వరకు మా చక్రం అమలు అవుతుంది.

మరియు తప్పుడు (అనగా, ఇది లూప్ నుండి నిష్క్రమించబడుతుంది) ఇది వేరియబుల్ సంఖ్య "7" కన్నా ఎక్కువ అయినప్పుడు మారుతుంది. ఇది జరగడానికి, ప్రతిసారీ 1 ద్వారా పెరుగుతుంది, ఇది "a = a + 1" లైన్లో సూచిస్తుంది.

మీరు ఈ నిర్మాణాన్ని అమలు చేస్తే, "A" అక్షరం ఒక కాలమ్లో 7 సార్లు ప్రదర్శించబడుతుంది!

అనంతమైన లూప్ పైథాన్లో

పైథాన్లో అనంతమైన లూప్ను ఎలా తయారు చేయాలి? ఇది ఊహించటం కష్టం కాదు, ఎందుకనగా అది ఒక తప్పుడు విలువ వచ్చేంతవరకు చక్రం పని చేస్తుంది మరియు ఈ విలువ కేవలం ఉనికిలో లేకుంటే? ప్రశ్నకు సమాధానంగా అందరికి ఇప్పటికే స్పష్టంగా ఉంది. ఏ సందర్భంలో ఒక సమస్య పరిష్కరించడానికి అనంతమైన చక్రం అవసరం? ఈ ఉదాహరణ "గడియారం" వంటి ప్రోగ్రామ్ యొక్క అమలు. నిస్సందేహంగా, మీరు ఒక అనంతమైన లూప్ను ఉపయోగించాలి, ఇది శాశ్వతంగా నవీకరించబడుతుంది మరియు సమయం ప్రదర్శించబడుతుంది.

అనంతమైన లూప్ తరచుగా లూప్ పరిస్థితులకు మార్పులు జోడించడానికి మర్చిపోతే ఎవరు అనుభవం లేని ప్రోగ్రామర్లు కోసం తప్పు.

పైథాన్ కోడ్ యొక్క క్రింది భాగాన్ని పరిశీలించండి. ఈ సందర్భంలో సైకిలు అనంతంగా తిరిగి పనిచేస్తాయి (గుర్తు తర్వాత "#" ఉంది):

అలాంటి కార్యక్రమం కంపైల్ చేయడానికి ఆతురుతలో ఉండకూడదు, ఎందుకంటే ఇది నిరవధికంగా అమలు చేయబడుతుంది. అటువంటి పరిస్థితులను మేము ఎప్పటికీ ఎన్నడూ చెల్లని విలువను కలిగి ఉండము: ఈ సందర్భంలో "సంఖ్య <10" స్థితి అదృశ్యమైనది మరియు నిజం, కాబట్టి పునరావృతం కొనసాగుతుంది, "హలో" సందేశాల N- వ సంఖ్యను ప్రదర్శిస్తుంది. శాశ్వత సంకలన ప్రక్రియను ఆపడానికి, మీరు షెల్ లో Ctrl + C ను నొక్కాలి.

పైథాన్: సింటాక్స్. సమయం మరియు ఉచ్చులు కోసం

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

లూప్ ముందు పనులు ఏమిటి? నిస్సందేహంగా, అదే సమయంలో - ఏ ప్రక్రియలు iterate. పైథాన్లో అమలు చేయబడిన కార్యక్రమాలలో, లూప్ విస్తృతంగా ఉపయోగించబడుతుంది, ఇది ఇచ్చిన సమితి యొక్క బైపాస్ను అమలు చేయగలదు మరియు దాని శరీరంలోని వివిధ పునరుత్పాదకాలను నిర్వహిస్తుంది. స్ట్రింగ్స్ లేదా జాబితాలు ఏ ఇతర మళ్ళించబడిన వస్తువు వలె అదే విధంగా ప్రాసెస్ చేసేటప్పుడు ఈ నిర్మాణం యొక్క అవకాశాలను అన్వయించవచ్చు.

పైథాన్లో లూప్ కోసం ఉదాహరణ

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

ఒక చిన్న ఉదాహరణ చూద్దాం, మనము సంబంధిత చర్యలను చేస్తాము (గుర్తు తర్వాత "#" వ్యాఖ్యానించబడుతుంది):

పై నిర్మాణ ఫలితం ఉంటుంది:

మా ఉదాహరణలో, ఒక వేరియబుల్ గణన ఉంది, ఇది శ్రేణిలో మారుతున్న విలువలను గుర్తుంచుకోవాల్సిన అవసరం ఉంది "spisok_chisel". వేరియబుల్ గణనం ప్రతి మూలకం యొక్క సూచిక విలువలను శ్రేణిలో (ప్రతి సంఖ్యలో జాబితాలో) నమోదు చేస్తుంది. వేరియబుల్ "ఎలిమెంట్స్" జాబితాలో ఫలిత విలువలు అనుబంధిస్తుంది. లూప్ కోసం, జాబితాలో ప్రతి సంఖ్యా వస్తువు ప్రాసెసింగ్ ఎలా అమలు చేయబడుతుందో గమనిస్తాము. లూప్ లోపల, "గణన" సూచికతో ప్రతి సంఖ్యా వస్తువు ప్రస్తుత ఐరేరేటెడ్ మూలకం మరియు త్రిపాది మొత్తానికి అనుబంధంగా ఉంటుంది. అప్పుడు మా ఇండెక్స్ "కౌంట్" ఒకటి ద్వారా పెరుగుతుంది, మరియు ప్రోగ్రామ్ అమలు యొక్క ప్రవాహం ప్రకటన యొక్క ప్రారంభంలోకి తిరిగి వస్తుంది. ఈ విధంగా, లూప్ అది పనిచేసే వరకు ప్రతి మూలకాన్ని ప్రాసెస్ చేసే వరకు పని చేస్తుంది. ఏ మూలకం లేదు, కానీ పరిస్థితి ద్వారా తెలుపబడితే, చక్రం ప్రక్రియ పూర్తవుతుంది. యొక్క మరింత స్వల్పభేదాన్ని శ్రద్ద లెట్: మీరు శ్రేణి వస్తువులు విజయవంతంగా ప్రాసెస్ వాస్తవం ఉన్నప్పటికీ, లైన్ "లెక్కింపు = లెక్కింపు + 1" రాయడానికి లేకపోతే, ఫలితంగా సున్నా సూచిక మొదటి సంఖ్య వస్తువు చేర్చబడుతుంది.

ఇప్పుడు మేము లూప్ యొక్క సూత్రాలను గుర్తుంచుకోవాలి మరియు వైవిధ్యతను తెలుసుకోవచ్చు (పైథాన్లో, లూప్ నుండి నిష్క్రమణ తార్కిక ప్రమాణాల ఆధారంగా నిర్వహిస్తారు - నిజమైన (లూప్ పని కొనసాగుతుంది) లేదా తప్పుడు (లూప్ స్టాప్లు)).

నిర్మాణానికి పైథాన్లో స్ట్రింగ్ విలువను ఎలా నిర్వహించాలి?

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

ఒక వేరియబుల్ కోసం

వేరియబుల్ చక్రం ఫలితంగా నిల్వ చేస్తుంది

వేరియబుల్ లో

లూప్తో పనిచేసేటప్పుడు కీవర్డ్ "ఇన్" ఒక తప్పనిసరి పరిస్థితి. వేరియబుల్ నుండి మనము విలువను విస్తరింపచేస్తాము, ఇది మనము ఐటిరేట్ చేస్తాము. స్పష్టత మరియు స్పష్టత కోసం, పైథాన్లోని పంక్తులు ఎలా పనిచేయాలి మరియు స్ట్రోక్ చేయడానికి ఎలా ఒక చిన్న ఉదాహరణ చూద్దాం:

స్క్రిప్ట్ యొక్క ఫలితం:

కొనసాగింపు ప్రకటన

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

ఒక ఉదాహరణను పరిశీలి 0 చ 0 డి:

ఫలితంగా ఈ క్రింది విధంగా ఉంది:

"ఓ" మినహాయించి ప్రతి లేఖను రిపీట్ చేసినట్లయితే, "కార్యనిర్వాహకుడు" లేఖలో "ఓ" ను కనుగొన్నప్పుడు, కార్యనిర్వాహక అమలుకు వెంటనే '' కొనసాగు '' అనే పదం తర్వాత దారికి వెనక్కి తీసుకోబడింది, అక్కడ ప్రతి అక్షరం నకిలీగా పేర్కొనబడింది.

బ్రేక్ స్టేట్మెంట్

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

బ్రేక్ స్టేట్మెంట్ యొక్క చిన్న ఉదాహరణను పరిశీలిద్దాం:

ఫలితంగా ఈ క్రింది విధంగా ఉంది:

హ్యాండ్లర్ లేఖలో "ఓ" ను కనుగొన్నప్పుడు, 'o తప్ప, ప్రతి అక్షరం పునరావృతం అవుతుంది', తరువాత కార్యక్రమం యొక్క అమలు చక్రం కోసం కొన్ని షరతులను కలిగి ఉన్నప్పటికీ, వెంటనే అమలు చేయబడుతుంది.

మేజిక్ పదం వేరే

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

ఒక చిన్న ఉదాహరణను పరిశీలి 0 చ 0 డి:

స్క్రిప్ట్ యొక్క ఫలితం:

పైథాన్ ప్రోగ్రామింగ్ భాషలో రివర్స్-ఆర్డర్ లూప్ల ఉదాహరణలు

పైథాన్లో రివర్స్ లూప్ ఎలా అమలు చేయబడుతుంది? మనము ఒక ప్రోగ్రామ్ స్ట్రింగ్ ను గుర్తించి దానిని రివర్స్ ఆర్డర్లో ప్రింట్ చేద్దాం అని ఊహిద్దాం. దీన్ని ఎలా అమలు చేయాలి?

క్రింద ఉన్న ఉదాహరణను పరిశీలించండి:

స్క్రిప్ట్ యొక్క ఫలితం:

Nested ఉచ్చులు

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

సమూహ ఉచ్చులు ఉపయోగించినట్లయితే, పైథాన్ కింది సింటాక్స్ను అందిస్తుంది:

సమూహ ఉచ్చులు యొక్క విశేషములు ఏ విధమైన రకము అయినా ఏ విధమైన చక్రం లోపలనైనా ఉపయోగించగలవు! దీనర్థం (లేదా కోసం) లూప్లో, లూప్ కోసం ఒక సమూహంగా లేదా, మళ్లీ, మరియు వైస్ వెర్సా చేయవచ్చు.