పైథాన్‌లో స్ట్రింగ్ స్ట్రింగ్‌ను ఎలా కలపాలి మరియు చేరాలి అనే దాని గురించి క్రింది వివరణ ఉంది.
- బహుళ స్ట్రింగ్‌లను కలపడం మరియు విలీనం చేయడం:
+,+=ఆపరేటర్ - సంఖ్యలు మరియు స్ట్రింగ్‌లను కలపండి మరియు కలపండి:
+,+=ఆపరేటర్,str(),format(),f-స్ట్రింగ్ - స్ట్రింగ్‌ల జాబితాలను (శ్రేణులు) ఒకే స్ట్రింగ్‌లో కలపండి మరియు కలపండి:
join() - సంఖ్యల జాబితాలను (శ్రేణులు) ఒకే స్ట్రింగ్‌లో కలపండి మరియు కలపండి:
join(),str()
బహుళ స్ట్రింగ్‌లను కలపడం మరియు విలీనం చేయడం:+,+=ఆపరేటర్
కనెక్షన్:+ఆపరేటర్
కింది స్ట్రింగ్ లిటరల్స్ మరియు స్ట్రింగ్ వేరియబుల్స్‌ను కలపడానికి ++ ఆపరేటర్‌ని ఉపయోగించవచ్చు
- …’
- “…”
s = 'aaa' + 'bbb' + 'ccc'
print(s)
# aaabbbccc
s1 = 'aaa'
s2 = 'bbb'
s3 = 'ccc'
s = s1 + s2 + s3
print(s)
# aaabbbccc
s = s1 + s2 + s3 + 'ddd'
print(s)
# aaabbbcccddd
కనెక్షన్:+=ఆపరేటర్
+= ఆపరేటర్, సంచిత అసైన్‌మెంట్ ఆపరేటర్‌ని కూడా ఉపయోగించవచ్చు. ఎడమ వైపున ఉన్న స్ట్రింగ్ వేరియబుల్ కుడి వైపున ఉన్న స్ట్రింగ్‌తో జతచేయబడుతుంది మరియు కేటాయించబడుతుంది మరియు నవీకరించబడుతుంది.
s1 += s2
print(s1)
# aaabbb
మీరు స్ట్రింగ్ వేరియబుల్ చివర స్ట్రింగ్‌ను జోడించాలనుకుంటే, += ఆపరేటర్‌తో స్ట్రింగ్ వేరియబుల్ మరియు ఏదైనా స్ట్రింగ్ లిటరల్ (లేదా మరొక స్ట్రింగ్ వేరియబుల్)ని ప్రాసెస్ చేయండి.
s = 'aaa'
s += 'xxx'
print(s)
# aaaxxx
స్ట్రింగ్ లిటరల్స్ యొక్క వరుస కలయిక
మీరు స్ట్రింగ్ లిటరల్స్‌ను పక్కపక్కనే వ్రాస్తే, స్ట్రింగ్ లిటరల్స్‌లు కలుస్తాయి.
s = 'aaa''bbb''ccc'
print(s)
# aaabbbccc
రెండు పంక్తుల మధ్య ఖాళీ లేదా బ్యాక్‌స్లాష్ లైన్ బ్రేక్ (కొనసాగింపుగా పరిగణించబడుతుంది) కలిగి ఉండటం ఆమోదయోగ్యమైనది.
s = 'aaa' 'bbb' 'ccc'
print(s)
# aaabbbccc
s = 'aaa'\
'bbb'\
'ccc'
print(s)
# aaabbbccc
కోడ్‌లోని బహుళ పంక్తులపై పొడవైన తీగలను వ్రాయడానికి దీన్ని ఉపయోగించే సాంకేతికత ఉంది.
- సంబంధిత కథనాలు:పైథాన్‌లో బహుళ పంక్తులపై పొడవైన తీగలను వ్రాయడం
స్ట్రింగ్ వేరియబుల్స్ కోసం ఈ రైటింగ్ పద్ధతి సాధ్యం కాదు.
# s = s1 s2 s3
# SyntaxError: invalid syntax
సంఖ్యా మరియు స్ట్రింగ్ సంయోగం/సంయోగం:+,+=ఆపరేటర్,str(),format(),f-స్ట్రింగ్
వేరే రకం యొక్క A + ఆపరేషన్ లోపం ఏర్పడుతుంది.
s1 = 'aaa'
s2 = 'bbb'
i = 100
f = 0.25
# s = s1 + i
# TypeError: must be str, not int
మీరు స్ట్రింగ్‌తో సంఖ్యా విలువను (ఉదా, పూర్ణాంకం రకం int లేదా ఫ్లోటింగ్-పాయింట్ టైప్ ఫ్లోట్) కలపాలనుకుంటే, సంఖ్యా విలువను str()తో స్ట్రింగ్ రకానికి మార్చండి, ఆపై వాటిని + ఆపరేటర్ (లేదా += ఆపరేటర్‌తో కలపండి. )
s = s1 + '_' + str(i) + '_' + s2 + '_' + str(f)
print(s)
# aaa_100_bbb_0.25
మీరు సున్నా-ఫిల్లింగ్ లేదా దశాంశ స్థానాలు వంటి సంఖ్య యొక్క ఆకృతిని మార్చాలనుకుంటే, ఫార్మాట్() ఫంక్షన్ లేదా స్ట్రింగ్ మెథడ్ ఫార్మాట్()ని ఉపయోగించండి.
s = s1 + '_' + format(i, '05') + '_' + s2 + '_' + format(f, '.5f')
print(s)
# aaa_00100_bbb_0.25000
s = '{}_{:05}_{}_{:.5f}'.format(s1, i, s2, f)
print(s)
# aaa_00100_bbb_0.25000
వాస్తవానికి, ఫార్మాటింగ్ లేకుండా నేరుగా స్ట్రింగ్‌లో వేరియబుల్ విలువను పొందుపరచడం కూడా సాధ్యమే. ఇది + ఆపరేటర్‌ని ఉపయోగించడం కంటే వ్రాయడం సులభం.
s = '{}_{}_{}_{}'.format(s1, i, s2, f)
print(s)
# aaa_100_bbb_0.25
ఆకృతిని ఎలా పేర్కొనాలి అనే వివరాల కోసం క్రింది కథనాన్ని చూడండి.
- సంబంధిత కథనాలు:పైథాన్‌లో ఫార్మాట్ మార్పిడి, ఫార్మాట్ (0-ఫిల్లింగ్, ఎక్స్‌పోనెన్షియల్ సంజ్ఞామానం, హెక్సాడెసిమల్, మొదలైనవి)
పైథాన్ 3.6 నుండి, f-strings (f-string) అని పిలువబడే ఒక మెకానిజం కూడా ప్రవేశపెట్టబడింది, ఇది ఫార్మాట్() కంటే వ్రాయడం చాలా సులభం.
s = f'{s1}_{i:05}_{s2}_{f:.5f}'
print(s)
# aaa_00100_bbb_0.25000
s = f'{s1}_{i}_{s2}_{f}'
print(s)
# aaa_100_bbb_0.25
స్ట్రింగ్‌ల జాబితాలను (శ్రేణులు) కలపండి మరియు చేరండి:join()
స్ట్రింగ్ మెథడ్ జాయిన్()ని స్ట్రింగ్‌ల జాబితాను ఒకే స్ట్రింగ్‌గా కలపడానికి ఉపయోగించవచ్చు.
దీన్ని ఎలా వ్రాయాలో ఈ క్రింది విధంగా ఉంది.
'String to be inserted between'.join([List of strings to be concatenated])
మధ్యలో చొప్పించడానికి స్ట్రింగ్’తో జాయిన్() పద్ధతిని కాల్ చేసి, ఆర్గ్యుమెంట్‌గా [కన్కాటేట్ చేయడానికి స్ట్రింగ్‌ల జాబితా] పాస్ చేయండి.
ఖాళీ స్ట్రింగ్‌ని ఉపయోగించినట్లయితే, [సంయోగం చేయవలసిన స్ట్రింగ్‌ల జాబితా] సరళంగా సంగ్రహించబడుతుంది, కామాను ఉపయోగిస్తే, స్ట్రింగ్‌లు కామాతో వేరు చేయబడతాయి మరియు కొత్త లైన్ అక్షరాన్ని ఉపయోగిస్తే, ప్రతి స్ట్రింగ్ మూలకం కొత్తగా లైన్ చేయబడుతుంది.
l = ['aaa', 'bbb', 'ccc']
s = ''.join(l)
print(s)
# aaabbbccc
s = ','.join(l)
print(s)
# aaa,bbb,ccc
s = '-'.join(l)
print(s)
# aaa-bbb-ccc
s = '\n'.join(l)
print(s)
# aaa
# bbb
# ccc
జాబితా యొక్క ఉదాహరణ మాత్రమే ఇక్కడ ఇవ్వబడినప్పటికీ, టుపుల్స్ వంటి ఇతర పునరావృత వస్తువులను చేరడానికి ఆర్గ్యుమెంట్‌లుగా పేర్కొనవచ్చు() కూడా.
చేరడానికి విరుద్ధంగా (), స్ప్లిట్ () అనేది నిర్దిష్ట డీలిమిటర్ ద్వారా వేరు చేయబడిన స్ట్రింగ్‌ను విభజించి దానిని జాబితాగా పొందేందుకు ఉపయోగించబడుతుంది.
సంఖ్యల జాబితాలను (శ్రేణులు) స్ట్రింగ్‌లుగా కలపండి మరియు కలపండి:join(),str()
చేరడానికి ఆర్గ్యుమెంట్() అనేది స్ట్రింగ్‌లు లేని ఎలిమెంట్‌ల జాబితా అయితే లోపం ఏర్పడుతుంది.
l = [0, 1, 2]
# s = '-'.join(l)
# TypeError: sequence item 0: expected str instance, int found
సంఖ్యల జాబితాను ఒకే స్ట్రింగ్‌గా కలపడానికి, సంఖ్యలను స్ట్రింగ్‌గా మార్చడానికి జాబితా కాంప్రహెన్షన్ సంజ్ఞామానంలోని ప్రతి మూలకానికి str() ఫంక్షన్‌ని వర్తింపజేయండి, ఆపై వాటిని join()తో కలపండి.
s = '-'.join([str(n) for n in l])
print(s)
# 0-1-2
ఇది జెనరేటర్ వ్యక్తీకరణగా కూడా వ్రాయబడుతుంది, ఇది జాబితా గ్రహణాల యొక్క జనరేటర్ వెర్షన్. జెనరేటర్ వ్యక్తీకరణలు కుండలీకరణాల్లో జతచేయబడతాయి, అయితే ఫంక్షన్ లేదా పద్ధతికి జెనరేటర్ వ్యక్తీకరణ మాత్రమే వాదన అయితే కుండలీకరణాలను విస్మరించవచ్చు.
s = '-'.join((str(n) for n in l))
print(s)
# 0-1-2
s = '-'.join(str(n) for n in l)
print(s)
# 0-1-2
జనరేటర్ ఎక్స్‌ప్రెషన్‌లు సాధారణంగా లిస్ట్ కాంప్రహెన్షన్‌ల కంటే తక్కువ మెమరీని ఉపయోగించడం వల్ల ప్రయోజనం కలిగి ఉంటాయి, అయితే జనరేటర్ ఎక్స్‌ప్రెషన్‌లను ఉపయోగించడం వల్ల ప్రత్యేక ప్రయోజనం లేదు, జాయిన్() జనరేటర్‌లను దాని అంతర్గత ప్రాసెసింగ్‌లో జాబితాలుగా మారుస్తుంది. వాస్తవానికి, మొదటి నుండి జాబితా గ్రహణాలను ఉపయోగించడం కొంచెం వేగంగా ఉంటుంది.
జాబితా గ్రహణాలు మరియు జనరేటర్ వ్యక్తీకరణల గురించి మరింత సమాచారం కోసం, క్రింది కథనాన్ని చూడండి.
- సంబంధిత కథనాలు:పైథాన్ జాబితా గ్రహణాలను ఎలా ఉపయోగించాలి
