ఇప్పటికే ఉన్న జాబితా (శ్రేణి)లోని కొన్ని షరతులకు అనుగుణంగా ఉన్న ఎలిమెంట్‌లను మాత్రమే సంగ్రహించడం లేదా తొలగించడం ద్వారా పైథాన్‌లో కొత్త జాబితాను రూపొందించడానికి లేదా రీప్లేస్‌మెంట్‌లు లేదా మార్పిడులు చేయడం ద్వారా, లిస్ట్ కాంప్రెహెన్షన్‌లను ఉపయోగించండి.
నమూనా కోడ్‌తో పాటు క్రిందివి ఇక్కడ వివరించబడ్డాయి.
- జాబితా కాంప్రహెన్షన్ సంజ్ఞామానం యొక్క ప్రాథమిక రూపం
- జాబితాలోని అన్ని అంశాలకు ప్రక్రియను వర్తింపజేయండి
- జాబితా నుండి ప్రమాణాలకు అనుగుణంగా ఉండే అంశాలను సంగ్రహించి, తొలగించండి
- జాబితా యొక్క షరతులను సంతృప్తిపరిచే మూలకాలను భర్తీ చేయండి లేదా మార్చండి
స్ట్రింగ్‌ల జాబితాల నిర్దిష్ట ఉదాహరణల కోసం క్రింది కథనాన్ని చూడండి.
ప్రమాణాలకు అనుగుణంగా లేని అంశాలను యాదృచ్ఛికంగా సంగ్రహించడం కూడా సాధ్యమే.
జాబితాలు వివిధ రకాల డేటాను నిల్వ చేయగలవని మరియు శ్రేణుల నుండి ఖచ్చితంగా భిన్నంగా ఉంటాయని గమనించండి. మీరు మెమరీ పరిమాణం మరియు మెమరీ చిరునామాలు లేదా పెద్ద డేటా యొక్క సంఖ్యాపరమైన ప్రాసెసింగ్ అవసరమయ్యే ప్రక్రియలలో శ్రేణులను నిర్వహించాలనుకుంటే, శ్రేణి (ప్రామాణిక లైబ్రరీ) లేదా NumPyని ఉపయోగించండి.
కింది జాబితా ఒక ఉదాహరణ
l = list(range(-5, 6))
print(l)
# [-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5]
జాబితా కాంప్రహెన్షన్ సంజ్ఞామానం యొక్క ప్రాథమిక రూపం
జాబితా నుండి కొత్త జాబితాను రూపొందిస్తున్నప్పుడు, లూప్‌ల కంటే జాబితా కాంప్రహెన్షన్‌లు వ్రాయడం సులభం.
[expression for any variable name in iterable object if conditional expression]
పునరావృతమయ్యే వస్తువు (జాబితా లేదా టుపుల్ వంటివి) యొక్క షరతులతో కూడిన వ్యక్తీకరణను సంతృప్తిపరిచే మూలకానికి వ్యక్తీకరణ వర్తించబడుతుంది మరియు కొత్త జాబితా యొక్క మూలకం అవుతుంది. “షరతులతో కూడిన వ్యక్తీకరణ ఉంటే” విస్మరించబడవచ్చు, ఈ సందర్భంలో వ్యక్తీకరణ అన్ని మూలకాలకు వర్తించబడుతుంది.
నెస్టెడ్ లిస్ట్ కాంప్రహెన్షన్ నోటేషన్‌తో సహా మరిన్ని వివరాల కోసం క్రింది కథనాన్ని చూడండి.
జాబితాలోని అన్ని అంశాలకు ప్రక్రియను వర్తింపజేయండి
ఉదాహరణకు, మీరు జాబితాలోని అన్ని మూలకాలకు కొంత ప్రాసెసింగ్‌ని వర్తింపజేయాలనుకుంటే, పైన ఉన్న జాబితా కాంప్రహెన్షన్ ఎక్స్‌ప్రెషన్‌లో కావలసిన ప్రాసెసింగ్‌ను వివరించండి.
l_square = [i**2 for i in l]
print(l_square)
# [25, 16, 9, 4, 1, 0, 1, 4, 9, 16, 25]
l_str = [str(i) for i in l]
print(l_str)
# ['-5', '-4', '-3', '-2', '-1', '0', '1', '2', '3', '4', '5']
ఇది సంఖ్యల జాబితాలు మరియు స్ట్రింగ్‌ల జాబితాల మధ్య మార్చడానికి ఉపయోగించవచ్చు.
జాబితా నుండి ప్రమాణాలకు అనుగుణంగా ఉండే అంశాలను సంగ్రహించి, తొలగించండి
మూలకం షరతులతో కూడిన వ్యక్తీకరణ ద్వారా మాత్రమే ఎంచుకోబడితే, అది వ్యక్తీకరణ ద్వారా ప్రాసెస్ చేయబడదు, కనుక ఇది క్రింది రూపాన్ని తీసుకుంటుంది
[variable name for variable name in original list if conditional expression]
ఒక కొత్త జాబితా రూపొందించబడింది, దీని నుండి షరతును సంతృప్తిపరిచే అంశాలు మాత్రమే (షరతులతో కూడిన వ్యక్తీకరణ నిజమయ్యే అంశాలు) సంగ్రహించబడతాయి.
l_even = [i for i in l if i % 2 == 0]
print(l_even)
# [-4, -2, 0, 2, 4]
l_minus = [i for i in l if i < 0]
print(l_minus)
# [-5, -4, -3, -2, -1]
“షరతులతో కూడిన వ్యక్తీకరణ” “నియత వ్యక్తీకరణ కాకపోతే” అని సెట్ చేయబడితే, అది నిరాకరణ అవుతుంది మరియు షరతును సంతృప్తిపరచని మూలకాలు (షరతులతో కూడిన వ్యక్తీకరణ తప్పుగా ఉన్న అంశాలు) మాత్రమే ఎంచుకోబడతాయి మరియు సంగ్రహించబడతాయి. మరో మాటలో చెప్పాలంటే, షరతును సంతృప్తిపరిచే అంశాలు తీసివేయబడిన కొత్త జాబితా రూపొందించబడింది.
l_odd = [i for i in l if not i % 2 == 0]
print(l_odd)
# [-5, -3, -1, 1, 3, 5]
l_plus = [i for i in l if not i < 0]
print(l_plus)
# [0, 1, 2, 3, 4, 5]
వాస్తవానికి, కాదు అని ఉపయోగించకుండా సమానమైన షరతులతో కూడిన వ్యక్తీకరణను పేర్కొనడం ద్వారా అదే ఫలితం పొందబడుతుంది.
l_odd = [i for i in l if i % 2 != 0]
print(l_odd)
# [-5, -3, -1, 1, 3, 5]
l_plus = [i for i in l if i >= 0]
print(l_plus)
# [0, 1, 2, 3, 4, 5]
షరతులతో కూడిన వ్యక్తీకరణ భాగం బహుళ పరిస్థితులు కావచ్చు. ప్రతికూల నోట్లు కూడా ఉపయోగించవచ్చు.
l_minus_or_even = [i for i in l if (i < 0) or (i % 2 == 0)]
print(l_minus_or_even)
# [-5, -4, -3, -2, -1, 0, 2, 4]
l_minus_and_odd = [i for i in l if (i < 0) and not (i % 2 == 0)]
print(l_minus_and_odd)
# [-5, -3, -1]
జాబితా యొక్క షరతులను సంతృప్తిపరిచే మూలకాలను భర్తీ చేయండి లేదా మార్చండి
ఎగువ మూలకం వెలికితీత ఉదాహరణలో, షరతులను సంతృప్తిపరచని అంశాలు తీసివేయబడ్డాయి.
మీరు షరతులను సంతృప్తిపరిచే మూలకాలపై మాత్రమే ప్రత్యామ్నాయాలు, మార్పిడులు మొదలైనవాటిని చేయాలనుకుంటే, జాబితా గ్రహణ సంజ్ఞామానం యొక్క వ్యక్తీకరణ భాగానికి టెర్నరీ ఆపరేటర్‌ని వర్తింపజేయండి.
పైథాన్‌లో, టెర్నరీ ఆపరేటర్‌ని ఈ క్రింది విధంగా వ్రాయవచ్చు
True Value if Conditional Expression else False Value
a = 80
x = 100 if a > 50 else 0
print(x)
# 100
b = 30
y = 100 if b > 50 else 0
print(y)
# 0
ఇది కొంచెం క్లిష్టంగా ఉంటుంది, కానీ జాబితా కాంప్రహెన్షన్ సంజ్ఞామానం మరియు టెర్నరీ ఆపరేటర్ల కలయిక క్రింది విధంగా ఉంటుంది.
[True Value if Conditional Expression else False Value for any variable name in original list]
కుండలీకరణాల్లో జతచేయబడిన భాగం టెర్నరీ ఆపరేటర్ (అసలు కోడ్‌లో కుండలీకరణాలు అవసరం లేదు).
[(True Value if Conditional Expression else False Value) for any variable name in original list]
ఏదైనా వేరియబుల్ పేరు నిజమైన లేదా తప్పుడు విలువల కోసం వ్రాసినట్లయితే, అసలు మూలకం యొక్క విలువ అలాగే ఉపయోగించబడుతుంది. ఒక వ్యక్తీకరణ వ్రాసినట్లయితే, ఆ వ్యక్తీకరణ యొక్క ప్రాసెసింగ్ వర్తించబడుతుంది.
l_replace = [100 if i > 0 else i for i in l]
print(l_replace)
# [-5, -4, -3, -2, -1, 0, 100, 100, 100, 100, 100]
l_replace2 = [100 if i > 0 else 0 for i in l]
print(l_replace2)
# [0, 0, 0, 0, 0, 0, 100, 100, 100, 100, 100]
l_convert = [i * 10 if i % 2 == 0 else i for i in l]
print(l_convert)
# [-5, -40, -3, -20, -1, 0, 1, 20, 3, 40, 5]
l_convert2 = [i * 10 if i % 2 == 0 else i / 10 for i in l]
print(l_convert2)
# [-0.5, -40, -0.3, -20, -0.1, 0, 0.1, 20, 0.3, 40, 0.5]
