ఉచ్చులు మరియు పరిధి కోసం

పైథాన్‌లోని for లూప్ ఐటెమ్‌ల క్రమంపై పునరావృతం చేయడానికి ఉపయోగించబడుతుంది: ఒక జాబితా, ఒక స్ట్రింగ్, ఒక పరిధి, ఒక డిక్ట్... "పునరావృతమైనది" ఏదైనా.

parole = ["ciao", "mondo", "!"]
for p in parole:
    print(p)
# ciao
# mondo
# !

నమూనా ఎల్లప్పుడూ ఒకే విధంగా ఉంటుంది: for <variable> in <iterable>: తర్వాత ప్రతి అంశానికి ఒకసారి అమలు చేయబడే ఇండెంట్ బ్లాక్.

range(...): పూర్ణాంక విరామాలను సృష్టిస్తోంది

range పూర్ణాంకాల సోమరి క్రమాన్ని ఉత్పత్తి చేస్తుంది. మూడు రూపాలు:

range(5)         # 0, 1, 2, 3, 4
range(2, 6)      # 2, 3, 4, 5
range(0, 10, 2)  # 0, 2, 4, 6, 8     (step)
range(5, 0, -1)  # 5, 4, 3, 2, 1     (negative step)

range slice వంటి కుడి చివర ప్రత్యేకమైనది. ఇది ఒక సోమరి వస్తువు: ఇది అన్ని సంఖ్యలకు మెమరీని కేటాయించదు, ఇది వాటిని ఒక సమయంలో ఉత్పత్తి చేస్తుంది.

totale = 0
for i in range(1, 11):
    totale = totale + i
totale  # 55  (1+2+...+10)

సూచికతో పునరావృతం: enumerate

మీకు అంశం మరియు దాని సూచిక కలిసి అవసరమైనప్పుడు, enumerateని ఉపయోగించండి:

parole = ["ciao", "mondo", "!"]
for i, p in enumerate(parole):
    print(i, p)
# 0 ciao
# 1 mondo
# 2 !

enumerate మేము నేరుగా ఇద్దరికి కేటాయించే (index, value) జతలను ఉత్పత్తి చేస్తుంది ** టుపుల్ అన్‌ప్యాకింగ్** ద్వారా వేరియబుల్స్ (మేము దీన్ని అంకితమైన మాడ్యూల్‌లో చూస్తాము డేటా నిర్మాణాలు).

రెండు సీక్వెన్స్‌లను సమాంతరంగా పునరావృతం చేయడం: zip

nomi = ["Ada", "Linus", "Grace"]
anni = [36, 54, 79]
for n, a in zip(nomi, anni):
    print(f"{n} ha {a} anni")

zip అతి తక్కువ సీక్వెన్స్‌లో ఆగుతుంది.

పరిధి() మరియు పైథాన్ యొక్క సోమరితనం

పైథాన్‌లో, range() ఫంక్షన్ మెమరీలో అసలు జాబితాను కేటాయించదు: ఇది లేజీ జెనరేటర్ని తిరిగి అందిస్తుంది, ఇది అభ్యర్థించిన విధంగా ఒక్కోసారి సంఖ్యలను అందిస్తుంది (ఉదాహరణకు, for లూప్‌లో). ఇది RAMని ఉబ్బిపోకుండా మిలియన్ల కొద్దీ పూర్ణాంకాలను పునరావృతం చేయడానికి అనుమతిస్తుంది. పరిధి విలువలను జాబితాగా పరిశీలించడానికి, మీరు దీన్ని list(range(5))తో స్పష్టంగా ప్రసారం చేయవచ్చు.

మీరే ప్రయత్నించండి

వ్యాయామం సమీక్షించండి

అదనపు సవాలు