మాడ్యూల్ పాఠాలు (2/4)
అయితే ఉచ్చులు
while లూప్ షరతు నిజం అయినంత వరకు బ్లాక్‌ను పునరావృతం చేస్తుంది. ఉపయోగించండి
while మీకు ఎన్ని పునరావృత్తులు అవసరమో మీకు తెలియనప్పుడు:
రౌండ్ల సంఖ్య లూప్ లోపల మారే వాటిపై ఆధారపడి ఉంటుంది.
వాక్యనిర్మాణం
n = 1
while n < 1000:
n = n * 2
n # 1024ఇండెంట్ బ్లాక్ పదేపదే అమలు చేయబడుతుంది. ప్రతి పునరావృతం పైథాన్ ముందు పరిస్థితిని అంచనా వేస్తుంది: అది తప్పుగా మారిన వెంటనే, లూప్ ముగుస్తుంది మరియు బ్లాక్ తర్వాత అమలు కొనసాగుతుంది.
సాధారణ నమూనాలు
మాన్యువల్ కౌంటర్ — ఇతర భాషలలో క్లాసిక్ forకి సమానం:
i = 0
while i < 5:
print(i)
i = i + 1అనంతమైన లూప్ + అంతర్గత నిష్క్రమణ పరిస్థితి — పరిస్థితి ఉన్నప్పుడు ఉపయోగకరంగా ఉంటుంది ఏదైనా చేసిన తర్వాత మూల్యాంకనం చేయబడింది:
acc = 0
while True:
acc = acc + 1
if acc * acc > 100:
break
acc # 11 (11*11 = 121 is the first square > 100)break లోపలి లూప్ నుండి వెంటనే నిష్క్రమిస్తుంది (మేము దానిని తర్వాతి కాలంలో చూస్తాము
పాఠం).
క్లాసిక్ తప్పు: అనంతమైన లూప్
లూప్ లోపల కండిషన్‌లోని వేరియబుల్ ** మారకపోతే**, ది
కార్యక్రమం ఎప్పటికీ ముగియదు. ఇది whileతో నంబర్ వన్ బగ్:
n = 0
while n < 10:
print(n) # n is never modified → infinite loop!మా వ్యాయామాలలో అమలు సమయం ముగిసింది, కాబట్టి అనంతమైన లూప్ విఫలమవుతుంది బ్రౌజర్‌ను స్తంభింపజేయడానికి బదులుగా స్పష్టమైన సందేశంతో. కానీ ఉత్పత్తిలో ఒక అనంతమైన లూప్ ఒక తీవ్రమైన బగ్.
అనంతమైన లూప్‌ల ప్రమాదం మరియు ముగింపు పరిస్థితులు
ఒక while లూప్ దాని పరిస్థితిని ఒప్పు అని అంచనా వేసినంత వరకు అమలు చేయబడుతుంది. మీరు పరిస్థితిని ప్రభావితం చేసే వేరియబుల్స్‌ని అప్‌డేట్ చేయడం మర్చిపోతే, మీ లూప్ అనంతంగా రన్ అవుతుంది, రన్‌టైమ్‌ను స్తంభింపజేస్తుంది. లూప్ బాడీ ఎగ్జిట్ కండిషన్ వైపు పురోగమిస్తున్నట్లు ఎల్లప్పుడూ నిర్ధారించుకోండి.
మీరే ప్రయత్నించండి
చిన్న పూర్ణాంకం `n >= 1`ని కనుగొనండి అంటే 2**n ఒక మిలియన్ కంటే ఎక్కువ. దాన్ని `ఫలితం`కి కేటాయించి, మూల్యాంకనం చేయండి (ఇది 20 అయి ఉండాలి).
సూచనను చూపించు
2**20 = 1,048,576 అనేది 1,000,000 కంటే మొదటిది.
3 ప్రయత్నాల తర్వాత పరిష్కారం లభిస్తుంది
వ్యాయామం సమీక్షించండి
`n = 1000` నుండి ప్రారంభించి, పూర్ణాంకాల విభజనతో (n // 2) 0 అయ్యే వరకు nని సగానికి తగ్గించండి. ఇది `స్టెప్స్`లో ఎన్ని పునరావృత్తులు తీసుకుంటుందో లెక్కించండి. `దశలను` మూల్యాంకనం చేయండి.
సూచనను చూపించు
1000 → 500 → 250 → 125 → 62 → 31 → 15 → 7 → 3 → 1 → 0: పది దశలు.
3 ప్రయత్నాల తర్వాత పరిష్కారం లభిస్తుంది
అదనపు సవాలు
Given the variable `n = 32`, write a `while` loop to count how many times you can divide `n` by 2 (using floor division `//`) before `n` becomes less than or equal to 1. Store the count in `divisions` and evaluate it.
సూచనను చూపించు
The while condition is n > 1. Inside the loop, divide n by 2 and increment divisions by 1.
3 ప్రయత్నాల తర్వాత పరిష్కారం లభిస్తుంది