పైథాన్, కామాతో వేరు చేయబడిన స్ట్రింగ్‌ను విభజించడానికి విభజించబడింది, వైట్‌స్పేస్‌ను తీసివేసి, జాబితాకు మార్చండి

కామాతో వేరు చేయబడిన స్ట్రింగ్‌ను పైథాన్‌లో జాబితాగా విభజించేటప్పుడు, మధ్యలో ఖాళీలు లేకుంటే, స్ప్లిట్() మాత్రమే పని చేస్తుంది. ఖాళీలు ఉన్నట్లయితే, అదనపు ఖాళీలను తీసివేయడానికి దానిని స్ట్రిప్()తో కలపడం ఉపయోగకరంగా ఉంటుంది. అదనంగా, లిస్ట్ కాంప్రహెన్షన్ సంజ్ఞామానాన్ని ఉపయోగించడం అనేది వ్రాయడానికి ఒక తెలివైన మార్గం.

ఈ విభాగంలో, మేము మొదట ఈ క్రింది వాటిని వివరిస్తాము.

• పేర్కొన్న డీలిమిటర్‌తో స్ట్రింగ్‌ను విభజించి, దానిని జాబితాగా తిరిగి ఇవ్వండిsplit()
• స్ట్రింగ్ ప్రారంభం మరియు ముగింపు నుండి అదనపు అక్షరాలను తీసివేయండి.strip()
• ఎలిమెంట్‌లను జాబితా చేయడానికి విధులు మరియు పద్ధతులను వర్తింపజేయడానికి లిస్ట్ కాంప్రహెన్షన్ సంజ్ఞామానం.

దిగువ చూపిన విధంగా ఖాళీలను తీసివేయడం ద్వారా ఖాళీలు మరియు కామాలతో వేరు చేయబడిన స్ట్రింగ్‌ల జాబితాను ఎలా తయారు చేయాలో కూడా ఇది చూపుతుంది.
one, two, three'

అదనంగా, మేము ఈ క్రింది వాటిని చర్చిస్తాము

• సంఖ్యల జాబితాగా దీన్ని ఎలా పొందాలి
• జాబితాలో చేరడానికి మరియు దాన్ని మళ్లీ స్ట్రింగ్‌గా చేయడానికి join()ని ఎలా ఉపయోగించాలి

split():పేర్కొన్న డీలిమిటర్‌తో స్ట్రింగ్‌ను విభజించి, దానిని జాబితాగా తిరిగి ఇవ్వండి

స్ట్రింగ్స్ కోసం స్ప్లిట్() పద్ధతిని ఉపయోగించి, మీరు పేర్కొన్న డీలిమిటర్‌తో స్ట్రింగ్‌ను విభజించి, దానిని జాబితా (అరే)గా పొందవచ్చు. పేర్కొన్న డీలిమిటర్‌ను కింది వాదన ద్వారా పేర్కొనవచ్చు.sep

• str.split() — Built-in Types — Python 3.10.1 Documentation

ఆర్గ్యుమెంట్ సెప్ విస్మరించబడితే మరియు డీలిమిటర్ పేర్కొనబడకపోతే, అది స్ట్రింగ్‌ను ఖాళీల ద్వారా విభజించి జాబితాను అందిస్తుంది. వరుస ఖాళీలు మరియు ట్యాబ్‌లు కూడా జాబితాను విభజిస్తాయి, కాబట్టి మీరు ట్యాబ్-డిలిమిటెడ్ స్ట్రింగ్‌ల జాబితాను తయారు చేయాలనుకుంటే, మీరు వాదన లేకుండా స్ప్లిట్()ని ఉపయోగించవచ్చు.

s = 'one two three'
l = s.split()
print(l)
# ['one', 'two', 'three']

s = 'one two        three'
l = s.split()
print(l)
# ['one', 'two', 'three']

s = 'one\ttwo\tthree'
l = s.split()
print(l)
# ['one', 'two', 'three']

సెప్ ఆర్గ్యుమెంట్‌లో డీలిమిటర్ పేర్కొనబడితే, అది జాబితాను ఆ స్ట్రింగ్ ద్వారా విభజించి జాబితాను అందిస్తుంది.

s = 'one::two::three'
l = s.split('::')
print(l)
# ['one', 'two', 'three']

కామాతో వేరు చేయబడిన స్ట్రింగ్ విషయంలో, అదనపు ఖాళీ స్థలం లేకుంటే, సమస్య లేదు, కానీ మీరు కామా + వైట్ స్పేస్‌తో వేరు చేయబడిన స్ట్రింగ్‌కు డీలిమిటర్‌గా కామాతో స్ప్లిట్()ని అమలు చేస్తే, మీరు ముగుస్తుంది ప్రారంభంలో వైట్ స్పేస్ మిగిలి ఉన్న స్ట్రింగ్‌ల జాబితాతో.

s = 'one,two,three'
l = s.split(',')
print(l)
# ['one', 'two', 'three']

s = 'one, two, three'
l = s.split(',')
print(l)
# ['one', ' two', ' three']

మీరు ఈ క్రింది విధంగా డీలిమిటర్‌గా కామా + స్పేస్‌ని ఉపయోగించవచ్చు, అయితే అసలు స్ట్రింగ్‌లోని ఖాళీల సంఖ్య భిన్నంగా ఉంటే అది పని చేయదు., '

s = 'one, two, three'
l = s.split(', ')
print(l)
# ['one', 'two', 'three']

s = 'one, two,  three'
l = s.split(', ')
print(l)
# ['one', 'two', ' three']

స్ట్రింగ్ మెథడ్ స్ట్రిప్(), ఇది తదుపరి వివరించబడుతుంది, రెండు ఖాళీలతో వ్యవహరించడానికి ఉపయోగించవచ్చు.

strip():స్ట్రింగ్ ప్రారంభం మరియు ముగింపు నుండి అదనపు అక్షరాలను తీసివేయండి.

స్ట్రిప్() అనేది స్ట్రింగ్ ప్రారంభం మరియు ముగింపు నుండి అదనపు అక్షరాలను తొలగించే పద్ధతి.

• str.strip() — Built-in Types — Python 3.10.1 Documentation

ఆర్గ్యుమెంట్ విస్మరించబడితే, వైట్‌స్పేస్ అక్షరాలు తీసివేయబడి కొత్త స్ట్రింగ్ అందించబడుతుంది. అసలు స్ట్రింగ్‌నే మార్చలేదు.

s = '  one  '
print(s.strip())
# one

print(s)
#   one  

స్ట్రింగ్ ఆర్గ్యుమెంట్‌గా పేర్కొనబడితే, స్ట్రింగ్‌లో ఉన్న అక్షరాలు తీసివేయబడతాయి.

s = '-+-one-+-'
print(s.strip('-+'))
# one

ఈ సందర్భంలో, ఖాళీలు తీసివేయబడవు. కాబట్టి, మీరు వైట్‌స్పేస్‌ను కూడా తీసివేయాలనుకుంటే, దిగువ చూపిన విధంగా స్పేస్‌లతో సహా స్ట్రింగ్‌ను ఆర్గ్యుమెంట్‌గా పాస్ చేయండి.-+ '

s = '-+- one -+-'
print(s.strip('-+'))
#  one 

s = '-+- one -+-'
print(s.strip('-+ '))
# one

స్ట్రిప్() రెండు చివరలను నిర్వహిస్తుంది, కానీ క్రింది విధులు కూడా అందుబాటులో ఉన్నాయి.

• lstrip():ప్రారంభాన్ని మాత్రమే ప్రాసెస్ చేయండి
• rstrip():లైన్ ముగింపును మాత్రమే ప్రాసెస్ చేయండి.

జాబితా కాంప్రహెన్షన్ సంజ్ఞామానం: ఎలిమెంట్‌లను జాబితా చేయడానికి విధులు మరియు పద్ధతులను వర్తింపజేయండి

మీరు జాబితా యొక్క మూలకాలకు ఒక ఫంక్షన్ లేదా పద్ధతిని వర్తింపజేయాలనుకుంటే, మీరు చివరికి జాబితాను పొందాలనుకుంటే for loopకి బదులుగా జాబితా కాంప్రహెన్షన్ సంజ్ఞామానాన్ని ఉపయోగించడం మంచిది.

• సంబంధిత కథనాలు:పైథాన్ జాబితా కాంప్రహెన్షన్స్ సంజ్ఞామానాన్ని ఉపయోగించడం

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

s = 'one, two, three'
l = [x.strip() for x in s.split(',')]
print(l)
# ['one', 'two', 'three']

ఇది ఖాళీ స్ట్రింగ్‌కి వర్తింపజేసినప్పుడు, ఒక ఎలిమెంట్‌గా ఒకే ఖాళీ స్ట్రింగ్‌తో జాబితాను పొందవచ్చు.

s = ''
l = [x.strip() for x in s.split(',')]
print(l)
print(len(l))
# ['']
# 1

మీరు ఖాళీ స్ట్రింగ్ కోసం ఖాళీ జాబితాను పొందాలనుకుంటే, మీరు జాబితా కాంప్రహెన్షన్ నొటేషన్‌లో షరతులతో కూడిన శాఖను సెటప్ చేయవచ్చు.

s = ''
l = [x.strip() for x in s.split(',') if not s == '']
print(l)
print(len(l))
# []
# 0

one, , three'
అలాగే, పైన వివరించిన విధంగా కామాతో వేరు చేయబడిన మూలకం తప్పిపోయినట్లయితే, మొదటి పద్ధతి దానిని ఖాళీ స్ట్రింగ్ మూలకం వలె జాబితా చేస్తుంది.

s = 'one, , three'
l = [x.strip() for x in s.split(',')]
print(l)
print(len(l))
# ['one', '', 'three']
# 3

మీరు తప్పిపోయిన భాగాలను విస్మరించాలనుకుంటే, మీరు జాబితా గ్రహణ సంజ్ఞామానంలో షరతులతో కూడిన శాఖను సెటప్ చేయవచ్చు.

s = 'one, ,three'
l = [x.strip() for x in s.split(',') if not x.strip() == '']
print(l)
print(len(l))
# ['one', 'three']
# 2

సంఖ్యల జాబితాగా పొందండి

మీరు స్ట్రింగ్‌కు బదులుగా సంఖ్యల జాబితాగా కామాతో వేరు చేయబడిన సంఖ్యల స్ట్రింగ్‌ను పొందాలనుకుంటే, జాబితా కాంప్రహెన్షన్ సంజ్ఞామానంలో స్ట్రింగ్‌ను సంఖ్యగా మార్చడానికి int() లేదా float()ని వర్తింపజేయండి.

s = '1, 2, 3, 4'
l = [x.strip() for x in s.split(',')]
print(l)
print(type(l[0]))
# ['1', '2', '3', '4']
# <class 'str'>

s = '1, 2, 3, 4'
l = [int(x.strip()) for x in s.split(',')]
print(l)
print(type(l[0]))
# [1, 2, 3, 4]
# <class 'int'>

join():జాబితాను విలీనం చేసి, దానిని స్ట్రింగ్‌గా పొందండి

వ్యతిరేక నమూనాలో, మీరు జాబితాలో చేరి, నిర్దిష్ట డీలిమిటర్ ద్వారా స్ట్రింగ్‌లను వేరు చేయాలనుకుంటే, join() పద్ధతిని ఉపయోగించండి.

• str.join() — Built-in Types — Python 3.10.1 Documentation

పొరపాటు చేయడం చాలా సులభం, కానీ జాయిన్() అనేది స్ట్రింగ్ పద్ధతి, జాబితా పద్ధతి కాదు. జాబితా వాదనగా పేర్కొనబడింది.

s = 'one, two,  three'
l = [x.strip() for x in s.split(',')]
print(l)
# ['one', 'two', 'three']

print(','.join(l))
# one,two,three

print('::'.join(l))
# one::two::three

మీరు దానిని ఒక లైన్‌లో ఈ క్రింది విధంగా వ్రాయవచ్చు.

s = 'one, two,  three'
s_new = '-'.join([x.strip() for x in s.split(',')])
print(s_new)
# one-two-three

మీరు స్థిరమైన డీలిమిటర్‌ని మార్చాలనుకుంటే, దాన్ని భర్తీ() పద్ధతితో భర్తీ చేయడం సులభం.

s = 'one,two,three'
s_new = s.replace(',', '+')
print(s_new)
# one+two+three