కొన్ని షరతులను సంతృప్తిపరిచే స్ట్రింగ్‌ల మూలకాలను మాత్రమే సంగ్రహించడం ద్వారా లేదా ప్రత్యామ్నాయాలు, మార్పిడులు మొదలైన వాటిని చేయడం ద్వారా మూలకాలు స్ట్రింగ్‌లుగా ఉన్న జాబితా (శ్రేణి) నుండి కొత్త జాబితాను రూపొందించడానికి, జాబితా కాంప్రహెన్షన్‌లను ఉపయోగించండి.
జాబితా గ్రహణాల యొక్క క్లుప్త వివరణ తర్వాత, క్రింది విషయాలు నమూనా కోడ్‌తో వివరించబడ్డాయి.
- నిర్దిష్ట స్ట్రింగ్ చేర్చబడిందా లేదా అనే దాని ఆధారంగా సంగ్రహణ (పాక్షిక సరిపోలిక)
- నిర్దిష్ట స్ట్రింగ్‌ను భర్తీ చేయండి
- నిర్దిష్ట స్ట్రింగ్‌తో ప్రారంభించడం లేదా ప్రారంభించకపోవడం ద్వారా సంగ్రహించండి
- నిర్దిష్ట స్ట్రింగ్‌తో ముగించడం లేదా ముగించకపోవడం ద్వారా సంగ్రహించండి
- కేసు ద్వారా తీర్పు ఇవ్వబడింది మరియు సంగ్రహించబడింది
- పెద్ద అక్షరం మరియు చిన్న అక్షరాలను మార్చండి
- అక్షరమా లేదా సంఖ్యా అక్షరాలు ఉపయోగించబడతాయో లేదో నిర్ణయిస్తుంది మరియు వాటిని సంగ్రహిస్తుంది
- బహుళ పరిస్థితులు
- (కంప్యూటర్) సాధారణ వ్యక్తీకరణ
జాబితాలు వివిధ రకాల డేటాను నిల్వ చేయగలవని మరియు శ్రేణుల నుండి ఖచ్చితంగా భిన్నంగా ఉంటాయని గమనించండి. మీరు మెమరీ పరిమాణం మరియు మెమరీ చిరునామాలు లేదా పెద్ద డేటా యొక్క సంఖ్యాపరమైన ప్రాసెసింగ్ అవసరమయ్యే ప్రక్రియలలో శ్రేణులను నిర్వహించాలనుకుంటే, శ్రేణి (ప్రామాణిక లైబ్రరీ) లేదా NumPyని ఉపయోగించండి.
- జాబితా చేరిక సంజ్ఞామానం
- నిర్దిష్ట స్ట్రింగ్ (పాక్షిక సరిపోలిక) కలిగి ఉంది \ కలిగి ఉండదు:in
- నిర్దిష్ట స్ట్రింగ్‌ను భర్తీ చేయండి
- నిర్దిష్ట స్ట్రింగ్‌తో ప్రారంభమవుతుంది \ ప్రారంభం కాదు:startswith()
- నిర్దిష్ట అక్షర స్ట్రింగ్‌తో ముగుస్తుంది \ ముగింపు కాదు:endswith()
- కేసు ద్వారా తీర్పు ఇవ్వబడింది మరియు సంగ్రహించబడింది
- పెద్ద అక్షరం మరియు చిన్న అక్షరాలను మార్చండి
- అక్షరమా లేదా సంఖ్యా అక్షరాలు ఉపయోగించబడతాయో లేదో నిర్ణయిస్తుంది మరియు వాటిని సంగ్రహిస్తుంది
- బహుళ పరిస్థితులు
- (కంప్యూటర్) సాధారణ వ్యక్తీకరణ
జాబితా చేరిక సంజ్ఞామానం
జాబితా నుండి కొత్త జాబితాను రూపొందిస్తున్నప్పుడు, లూప్‌ల కంటే జాబితా కాంప్రహెన్షన్‌లు వ్రాయడం సులభం.
[expression for any variable name in iterable object if conditional expression]
మూలకం షరతులతో కూడిన వ్యక్తీకరణ ద్వారా మాత్రమే ఎంచుకోబడితే, అది వ్యక్తీకరణ ద్వారా ప్రాసెస్ చేయబడదు, కనుక ఇది క్రింది రూపాన్ని తీసుకుంటుంది
[variable name for variable name in original list if conditional expression]
ఒకవేళ షరతులతో కూడిన వ్యక్తీకరణను షరతులతో కూడిన వ్యక్తీకరణగా మార్చినట్లయితే, అది నిరాకరణ అవుతుంది మరియు షరతులతో కూడిన వ్యక్తీకరణను సంతృప్తిపరచని మూలకాలను సంగ్రహించవచ్చు.
నిర్దిష్ట స్ట్రింగ్ (పాక్షిక సరిపోలిక) కలిగి ఉంది \ కలిగి ఉండదు:in
“ఒరిజినల్ స్ట్రింగ్‌లో నిర్దిష్ట స్ట్రింగ్”లో, ఒరిజినల్ స్ట్రింగ్ నిర్దిష్ట స్ట్రింగ్‌ని కలిగి ఉంటే ఒప్పు అని అందిస్తుంది. ఇది షరతులతో కూడిన వ్యక్తీకరణ.
ఇన్ యొక్క ప్రతికూలత నాట్ ఇన్‌తో చేయబడుతుంది.
l = ['oneXXXaaa', 'twoXXXbbb', 'three999aaa', '000111222']
l_in = [s for s in l if 'XXX' in s]
print(l_in)
# ['oneXXXaaa', 'twoXXXbbb']
l_in_not = [s for s in l if 'XXX' not in s]
print(l_in_not)
# ['three999aaa', '000111222']
నిర్దిష్ట స్ట్రింగ్‌ను భర్తీ చేయండి
మీరు జాబితా మూలకాల స్ట్రింగ్‌ను భర్తీ చేయాలనుకుంటే, జాబితా కాంప్రహెన్షన్ నొటేషన్‌లోని ప్రతి మూలకం కోసం స్ట్రింగ్ మెథడ్ రీప్లేస్()ని ఉపయోగించండి.
రీప్లేస్ చేయడానికి స్ట్రింగ్ లేకుంటే, if షరతులతో కూడిన వ్యక్తీకరణలో మూలకాన్ని ఎంచుకోవలసిన అవసరం లేదు ఎందుకంటే ఇది భర్తీ()ని వర్తింపజేయడం ద్వారా మార్చబడదు.
l_replace = [s.replace('XXX', 'ZZZ') for s in l]
print(l_replace)
# ['oneZZZaaa', 'twoZZZbbb', 'three999aaa', '000111222']
మీరు నిర్దిష్ట స్ట్రింగ్‌ను కలిగి ఉన్న మొత్తం మూలకాన్ని భర్తీ చేయాలనుకుంటే, దాన్ని ఇన్‌తో సంగ్రహించి, టెర్నరీ ఆపరేటర్‌తో ప్రాసెస్ చేయండి. టెర్నరీ ఆపరేటర్ క్రింది రూపంలో వ్రాయబడింది.True Value if Conditional Expression else False Value
లిస్ట్ కాంప్రహెన్షన్ సంజ్ఞామానం యొక్క వ్యక్తీకరణ భాగం తృతీయ ఆపరేటర్ అయితే సరే.
l_replace_all = ['ZZZ' if 'XXX' in s else s for s in l]
print(l_replace_all)
# ['ZZZ', 'ZZZ', 'three999aaa', '000111222']
క్రింది ఫలితాల సారాంశం, కుండలీకరణాల్లో చేర్చబడింది. మీరు కుండలీకరణాలను ఉపయోగించడం అలవాటు చేసుకోకపోతే, తప్పులను అర్థం చేసుకోవడం మరియు నివారించడం సులభం కావచ్చు. వ్యాకరణపరంగా కుండలీకరణాలు రాసినా సమస్య లేదు.
[('ZZZ' if ('XXX' in s) else s) for s in l]
in షరతుగా ఉపయోగించడం అనేది జాబితా కాంప్రహెన్షన్ నొటేషన్‌తో గందరగోళంగా ఉంది, అయితే మీరు జాబితా కాంప్రహెన్షన్ సంజ్ఞామానం మరియు టెర్నరీ ఆపరేటర్‌ల యొక్క వాక్యనిర్మాణ రూపం గురించి తెలుసుకుంటే అది కష్టం కాదు.
నిర్దిష్ట స్ట్రింగ్‌తో ప్రారంభమవుతుంది \ ప్రారంభం కాదు:startswith()
ఆర్గ్యుమెంట్‌లో పేర్కొన్న స్ట్రింగ్‌తో స్ట్రింగ్ ప్రారంభమైతే స్ట్రింగ్ మెథడ్ స్టార్ట్‌స్‌విత్() నిజం అని తిరిగి వస్తుంది.
l_start = [s for s in l if s.startswith('t')]
print(l_start)
# ['twoXXXbbb', 'three999aaa']
l_start_not = [s for s in l if not s.startswith('t')]
print(l_start_not)
# ['oneXXXaaa', '000111222']
నిర్దిష్ట అక్షర స్ట్రింగ్‌తో ముగుస్తుంది \ ముగింపు కాదు:endswith()
ఆర్గ్యుమెంట్‌లో పేర్కొన్న స్ట్రింగ్‌తో స్ట్రింగ్ ముగిస్తే స్ట్రింగ్ మెథడ్ ఎండ్స్‌విత్() ఒప్పు అని తిరిగి వస్తుంది.
l_end = [s for s in l if s.endswith('aaa')]
print(l_end)
# ['oneXXXaaa', 'three999aaa']
l_end_not = [s for s in l if not s.endswith('aaa')]
print(l_end_not)
# ['twoXXXbbb', '000111222']
కేసు ద్వారా తీర్పు ఇవ్వబడింది మరియు సంగ్రహించబడింది
స్ట్రింగ్ మెథడ్స్ isupper(),islower() అనేది ఒక స్ట్రింగ్ మొత్తం అప్పర్ లేదా మొత్తం లోయర్ కేస్ అని నిర్ధారించడానికి ఉపయోగించవచ్చు.
l_lower = [s for s in l if s.islower()]
print(l_lower)
# ['three999aaa']
పెద్ద అక్షరం మరియు చిన్న అక్షరాలను మార్చండి
మీరు అన్ని అక్షరాలను అప్పర్ లేదా లోయర్ కేస్‌కి మార్చాలనుకుంటే, ఎగువ() మరియు దిగువ() స్ట్రింగ్ పద్ధతులను ఉపయోగించండి. ఇతర పద్ధతులలో క్యాపిటలైజ్(), ఇది మొదటి అక్షరాన్ని మాత్రమే క్యాపిటలైజ్ చేస్తుంది మరియు అప్పర్ మరియు లోయర్ కేస్ అక్షరాలను మార్చుకునే స్వాప్‌కేస్().
ఎగువ ప్రత్యామ్నాయ ఉదాహరణలో వలె, మీరు షరతును సంతృప్తిపరిచే అంశాలను మాత్రమే ప్రాసెస్ చేయాలనుకుంటే టెర్నరీ ఆపరేటర్‌ని ఉపయోగించండి.
l_upper_all = [s.upper() for s in l]
print(l_upper_all)
# ['ONEXXXAAA', 'TWOXXXBBB', 'THREE999AAA', '000111222']
l_lower_to_upper = [s.upper() if s.islower() else s for s in l]
print(l_lower_to_upper)
# ['oneXXXaaa', 'twoXXXbbb', 'THREE999AAA', '000111222']
అక్షరమా లేదా సంఖ్యా అక్షరాలు ఉపయోగించబడతాయో లేదో నిర్ణయిస్తుంది మరియు వాటిని సంగ్రహిస్తుంది
స్ట్రింగ్ మెథడ్స్ isalpha() మరియు isnumeric() అనేది స్ట్రింగ్ మొత్తం అక్షరమా, సంఖ్యా, మొదలైనవా అని నిర్ధారించడానికి ఉపయోగించవచ్చు.
l_isalpha = [s for s in l if s.isalpha()]
print(l_isalpha)
# ['oneXXXaaa', 'twoXXXbbb']
l_isnumeric = [s for s in l if s.isnumeric()]
print(l_isnumeric)
# ['000111222']
బహుళ పరిస్థితులు
జాబితా గ్రహణాల యొక్క షరతులతో కూడిన వ్యక్తీకరణ భాగం బహుళ షరతులు కావచ్చు. ప్రతికూల “కాదు” పరిస్థితులు కూడా ఉపయోగించవచ్చు.
మూడు లేదా అంతకంటే ఎక్కువ షరతులతో కూడిన వ్యక్తీకరణలను ఉపయోగిస్తున్నప్పుడు, ప్రతి సమూహాన్ని కుండలీకరణాల్లో చేర్చడం సురక్షితం () ఎందుకంటే ఫలితం క్రమాన్ని బట్టి మారుతుంది.
l_multi = [s for s in l if s.isalpha() and not s.startswith('t')]
print(l_multi)
# ['oneXXXaaa']
l_multi_or = [s for s in l if (s.isalpha() and not s.startswith('t')) or ('bbb' in s)]
print(l_multi_or)
# ['oneXXXaaa', 'twoXXXbbb']
(కంప్యూటర్) సాధారణ వ్యక్తీకరణ
సాధారణ వ్యక్తీకరణలు అత్యంత సౌకర్యవంతమైన ప్రాసెసింగ్‌ను అనుమతిస్తాయి.
సరిపోలినప్పుడు re.match() ద్వారా అందించబడిన మ్యాచ్ ఆబ్జెక్ట్ షరతులతో కూడిన వ్యక్తీకరణతో మూల్యాంకనం చేయబడినప్పుడు ఎల్లప్పుడూ నిజమని నిర్ణయించబడుతుంది. ఇది సరిపోలకపోతే, అది షరతులతో కూడిన వ్యక్తీకరణలో తప్పు అయిన ఏదీ లేదు. కాబట్టి, మీరు సాధారణ వ్యక్తీకరణకు సరిపోలే మూలకాలను మాత్రమే సంగ్రహించాలనుకుంటే, మునుపటిలాగా జాబితా కాంప్రహెన్షన్ వ్యక్తీకరణ యొక్క షరతులతో కూడిన వ్యక్తీకరణ భాగానికి re.match()ని వర్తింపజేయండి.
import re
l = ['oneXXXaaa', 'twoXXXbbb', 'three999aaa', '000111222']
l_re_match = [s for s in l if re.match('.*XXX.*', s)]
print(l_re_match)
# ['oneXXXaaa', 'twoXXXbbb']
సాధారణ వ్యక్తీకరణ యొక్క సరిపోలిన భాగాన్ని భర్తీ చేసే re.sub(), కూడా ఉపయోగకరంగా ఉంటుంది. సరిపోలిన మూలకాలను మాత్రమే సంగ్రహించడానికి మరియు భర్తీ చేయడానికి, కేవలం “షరతులతో కూడిన వ్యక్తీకరణ ఉంటే” జోడించండి.
l_re_sub_all = [re.sub('(.*)XXX(.*)', r'\2---\1', s) for s in l]
print(l_re_sub_all)
# ['aaa---one', 'bbb---two', 'three999aaa', '000111222']
l_re_sub = [re.sub('(.*)XXX(.*)', r'\2---\1', s) for s in l if re.match('.*XXX.*', s)]
print(l_re_sub)
# ['aaa---one', 'bbb---two']