పైథాన్‌లో లూప్ కోసం

పైథాన్‌లోని ఫర్ లూప్ ఇతర ప్రోగ్రామింగ్ భాషల కంటే కొన్ని విభిన్న లక్షణాలను కలిగి ఉంది. ఎక్కువగా ఉపయోగించిన లూప్‌లలో ఒకదాని నుండి ఎక్కువ ప్రయోజనం పొందడానికి నేను నేర్చుకుంటున్న వాటిని మీకు వదిలివేస్తున్నాను.

పైథాన్‌లో ఇది జాబితా, ఆబ్జెక్ట్ లేదా మరొక మూలకం కావచ్చు, మళ్ళించదగిన వస్తువు ద్వారా పునరావృతం చేయడానికి ఉద్దేశించబడింది.

కింది నిర్మాణం ఉంది

h2=[ 'Valencia', 'Castellón', 'Alicante']

for j in h2:
   instructions

ఇక్కడ h2 అనేది పునరావృత మూలకం ఉదాహరణకు జాబితా h2=[ 'Valencia', 'Castellón', 'Alicante']. లూప్‌లో 3 పునరావృత్తులు ఉంటాయి, మొదటి j=Valenciaలో రెండవది j=Castellón వేరియబుల్.

మరియు దీనితో మనకు కావలసిన సూచనలను నిర్వచించవచ్చు, ఎల్లప్పుడూ ఇండెంటేషన్‌ను గుర్తుంచుకోవాలి, పైథాన్‌లో ముఖ్యమైనది మరియు చాలా మంది వ్యక్తులు విస్మరించడం, కోడ్‌లో దోషాలను పొందడం.

లూప్ కోసం ఖచ్చితమైన సార్లు పునరావృతం చేయండి.

C++లో మనం చేయగలిగిన విధంగా ఇది నిర్దిష్ట సంఖ్యలో పునరావృతం కావాలంటే మనం పరిధి()ని ఉపయోగించాలి. 10 సార్లు పునరావృతం చేయడానికి మేము a ని ఉపయోగిస్తాము

for element in Range(9):
    instructions

మేము 9ని ఉంచాము మరియు 10 కాదు, ఎందుకంటే పరిధి 0 నుండి ప్రారంభమవుతుంది, కాబట్టి 0 నుండి 9 వరకు లూప్ యొక్క 10 పునరావృత్తులు లేదా మలుపులు ఉన్నాయి.

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

var = 10
for element in Range(var):
    instructions

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

ఫర్ లూప్ యొక్క ప్రవాహాన్ని నియంత్రించడానికి చాలా ఎక్కువ చేయవచ్చు.

స్టేట్‌మెంట్‌లను బ్రేక్ చేసి కొనసాగించండి

2 చాలా ఉపయోగకరమైన ఫీచర్‌లు ఉన్నాయి, ఇవి లూప్‌ని చాలా ఫంక్షనల్‌గా చేయడానికి, బ్రేక్ మరియు కంటిన్యూ చేయడానికి మాకు అనుమతిస్తాయి. అవి సాధారణంగా షరతులతో ఉపయోగించబడతాయి, అయితే, ఏదైనా నిజమో కాదో తనిఖీ చేస్తుంది.

అవి ఇతర లూప్‌లలో పని చేస్తాయి మరియు పాస్ అనే మరొక ఆసక్తికరమైన స్టేట్‌మెంట్ ఉంది, ఇది అమలు చేయబడినది కానీ ఏమీ చేయదు మరియు కమాండ్‌లు అవసరమయ్యే నిర్మాణాన్ని మేము నిర్వచించాలనుకున్నప్పుడు అనువైనది కాని మేము వాటిని తర్వాత ఉంచాలనుకుంటున్నాము (వ్యాఖ్యలు దీనికి ఉపయోగపడదు)

బ్రేక్

విరామంతో మనం ఎప్పుడైనా లూప్ నుండి నిష్క్రమించవచ్చు. మీరు ఊహించిన విధంగా చాలా ఉపయోగకరంగా ఉంటుంది. అయితే, ఇతర నిర్మాణాలు ఉన్నాయన్నది నిజం.

numeros = [1, 2, 4, 3, 5, 8, 6]
for n in numeros:
    if n == 3:
        break
else:
    print('No se encontró el número 3')

కొనసాగించు

ఇది లూప్‌లోని తదుపరి మూలకానికి వెళ్లేలా చేస్తుంది.

numeros = [1, 2, 4, 3, 5, 8, 6]
for n in numeros:
    if n == 3:
        continue
else:
    print('No se encontró el número 3')

https://j2logo.com/bucle-for-en-python/

… వేరే కోసం

For నుండి తీసుకోబడిన నిర్మాణం ఉంది, అది … else

datos = [1, 2, 3, 4, 5]
for n in datos:
    if n == 2:
        break
else:
    print('No hay 2')

ఇది అవసరమని మరియు దీనిని సాధించడానికి చాలా మంది ప్రజలు ప్రత్యామ్నాయ మార్గాలను ఉపయోగిస్తున్నారని వారు చూసిన తర్వాత ఈ నిర్మాణం ఉద్భవించింది. అందువలన, వారు ప్రజలకు సహాయం చేస్తారు మరియు మరింత చదవగలిగే కోడ్‌ను పొందుతారు

_ కోసం

నేను దీన్ని ఎప్పుడూ ఉపయోగించనప్పటికీ కొన్ని ప్రోగ్రామ్‌లలో చూశాను.

మేము ఒక వస్తువు, జాబితా, నిఘంటువు మొదలైనవాటిని పునరావృతం చేస్తున్నప్పుడు, కానీ ఆ మూలకాల యొక్క కంటెంట్ మనకు ఆసక్తిని కలిగించనప్పుడు, మేము దానిని _తో సూచించవచ్చు

ఒక ఉదాహరణ:

మేము జాబితా యొక్క మూలకాలను లెక్కించాలనుకుంటున్నాము, కానీ దానిలో ఏమి ఉందో మేము పట్టించుకోము, మాకు దాని పొడవు మాత్రమే కావాలి.

h2=[ 'Valencia', 'Castellón', 'Alicante']
count = 0
for _ in h2:
    cont += 1

చాలా సైట్‌లలో వారు ఈ అభ్యాసాన్ని దుర్వినియోగం చేయవద్దని సిఫార్సు చేస్తున్నారు. ఇది అందించే ప్రయోజనాల గురించి నాకు నిజంగా తెలియదు, ఇది వేగంగా ఉందా?

వెనుకకు లూప్ చేయడం

లూప్ కోసం వెనుకకు. చివరి నుండి ప్రారంభం వరకు పునరావృతం చేయడానికి

ఇది పైథాన్ 3లో ప్రవేశపెట్టబడిన రివర్స్డ్() ఫంక్షన్‌ని ఉపయోగిస్తుంది

h2=[ 'Valencia', 'Castellón', 'Alicante']

for j in reversed(h2):
    print (j)

రెండు సూచికలతో లూపింగ్, మళ్ళించదగిన విలువ మరియు సూచిక

ఎన్యూమరేట్()తో మనం సేకరణ యొక్క సూచికలతో పని చేయవచ్చు. ఎందుకంటే చాలా సార్లు, పునరావృత వస్తువు యొక్క విలువతో పాటు, మేము దాని సూచికపై ఆసక్తి కలిగి ఉంటాము.

h2=[ 'Valencia', 'Castellón', 'Alicante']

for j, h in enumerate(h2):
    print j, '-->', h2[i] 

2 జాబితాలకు పైగా పునరావృతం

మరొక ఆసక్తికరమైన ఎంపిక జిప్() ఇది మా పనిని సులభతరం చేస్తుంది మరియు మా కోడ్‌ను సరళంగా మరియు మరింత చదవగలిగేలా చేస్తుంది.

h2=[ 'Valencia', 'Castellón', 'Alicante']
cod=[100, 200, 300]

for j, h in zip(h2, cod):
    print h2, '-->', cod 

పైథాన్ 2.x izip()లో ఈ ఫంక్షన్‌ని మెరుగుపరచడానికి ఉపయోగించబడింది, కానీ పైథాన్ 3లో izip అనేది zip()

క్రమబద్ధీకరించబడిన క్రమంలో లూపింగ్

ఆబ్జెక్ట్ ఇండెక్స్ ద్వారా కాకుండా దాని విలువ ద్వారా క్రమంలో మళ్ళించండి. sorted() ఉపయోగించబడుతుంది

colors = ['rojo', 'amarillo', 'verde']

for color in sorted(colors):
    print color

మరియు మేము దానిని వెనుకకు చేయాలనుకుంటే

colors = ['rojo', 'amarillo', 'verde']

for color in sorted(colors, reverse=True):
    print color

అనుకూల క్రమబద్ధీకరణ క్రమం

colors = ['rojo', 'amarillo', 'verde']

for color in sorted(colors, key=len):
    print color

లూప్ కోసం సెంటినల్ విలువ

సెంటినెల్ విలువ అనేది లూప్ ముగింపుకు కారణమయ్యే విలువ. ఇది సాధారణంగా కాసేపు లూప్‌లో ప్రదర్శించబడుతుంది, కానీ రేమండ్ హెట్టింగర్ దీన్ని ఫార్‌తో ఎలా ఉపయోగించాలో చూపిస్తుంది, ఇది వేగంగా ఉంటుంది

blocks = []
for block in iter(partial(f.read, 32), ''):
    blocks.append(block)
    print (block)

కోసం నిఘంటువులను తిరగండి

నిఘంటువులు సంబంధాలను వ్యక్తీకరించడానికి మరియు సమూహాలను రూపొందించడానికి అవసరమైన సాధనాలు.

మీరు కోసం సంప్రదాయ పద్ధతిలో నిఘంటువు ద్వారా వెళ్ళవచ్చు, కానీ అది మొత్తం సమాచారాన్ని తిరిగి ఇవ్వదు, మేము కౌంటర్లు మరియు ఇతర వాటిని జోడించడం ప్రారంభించకపోతే, మేము అలాంటి విలువలు మరియు సూచికలతో పని చేయలేము అంశాలు.

d = {'casa': 'azul', 'coche': 'rojo', 'hombre': 'verde'}

for k in d.keys():
    if k.startswith('r'):
        del d[k]

ఈ విధంగా, మూలకాలను చూడటమే కాకుండా, మూలకాలను మార్చడం లేదా వాటిని తొలగించడం ద్వారా నిఘంటువును సవరించవచ్చు, అదే సమయంలో for loop పునరావృతమవుతుంది.

d.keys() ఆర్గ్యుమెంట్‌లను పిలుస్తుంది మరియు అది మనం సవరించగలిగే జాబితాలో నిల్వ చేసే కాపీని చేస్తుంది.

సాంప్రదాయకమైన వాటికి బదులుగా ఇండెక్స్‌లు మరియు విలువలను పొందడం మరియు ప్రోగ్రామింగ్ ప్రారంభించే మనలో ఇది మొదటి విషయం.

for k in d:
    print k, '-->', d[k]

మేము దీన్ని చాలా వేగవంతమైన ఎంపికను ఉపయోగిస్తాము

for k, v in d.items():
    print k, '-->', v

ఐటెమ్‌లు() కంటే ఐటెమ్‌లు()

రేమండ్ హెట్టింగర్ ద్వారా పైథాన్‌లో లూప్స్ గురించి మాట్లాడండి

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

ఒక వ్యాఖ్యను