பைத்தானில் string str ஐ எவ்வாறு இணைப்பது மற்றும் இணைப்பது என்பது பற்றிய விளக்கம் கீழே உள்ளது.
- பல சரங்களை ஒன்றிணைத்தல் மற்றும் ஒன்றிணைத்தல்:
+,+=இயக்குபவர் - எண்கள் மற்றும் சரங்களை ஒருங்கிணைத்து இணைக்கவும்:
+,+=இயக்குபவர்,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 முதல், எஃப்-ஸ்ட்ரிங்க்ஸ் (எஃப்-ஸ்ட்ரிங்) எனப்படும் ஒரு பொறிமுறையும் அறிமுகப்படுத்தப்பட்டது, இது வடிவமைப்பை விடவும் எழுத எளிதானது.
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])
இடையில் செருகுவதற்கான சரம்’ மூலம் join() முறையை அழைத்து, [இணைக்க வேண்டிய சரங்களின் பட்டியல்] ஒரு வாதமாக அனுப்பவும்.
வெற்று சரம் பயன்படுத்தப்பட்டால், [இணைக்கப்பட வேண்டிய சரங்களின் பட்டியல்] வெறுமனே இணைக்கப்படும், கமாவைப் பயன்படுத்தினால், சரங்கள் காற்புள்ளியால் பிரிக்கப்படும், மேலும் ஒரு புதிய வரி எழுத்து பயன்படுத்தப்பட்டால், ஒவ்வொரு சர உறுப்பும் புதியதாக இருக்கும்.
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
ஒரு பட்டியலின் உதாரணம் மட்டுமே இங்கே கொடுக்கப்பட்டிருந்தாலும், tuples போன்ற மற்ற திரும்பச் செய்யக்கூடிய பொருள்கள் () சேர வாதங்களாகவும் குறிப்பிடப்படலாம்.
ஜாயின்(), ஸ்பிலிட்() என்பதற்கு மாறாக, ஒரு குறிப்பிட்ட டிலிமிட்டரால் பிரிக்கப்பட்ட சரத்தைப் பிரித்து, பட்டியலாகப் பெறுவதற்குப் பயன்படுத்தப்படுகிறது.
எண்களின் பட்டியல்களை (வரிசைகள்) சரங்களாக இணைத்து இணைக்கவும்: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
ஜெனரேட்டர் வெளிப்பாடுகள் பொதுவாக பட்டியல் புரிதல்களைக் காட்டிலும் குறைவான நினைவகத்தைப் பயன்படுத்துவதன் நன்மையைக் கொண்டுள்ளன, ஆனால் ஜெனரேட்டர் வெளிப்பாடுகளைப் பயன்படுத்துவதில் குறிப்பிட்ட நன்மை எதுவும் இல்லை, ஏனெனில் join() ஜெனரேட்டர்களை அதன் உள் செயலாக்கத்தில் பட்டியல்களாக மாற்றுகிறது. உண்மையில், ஆரம்பத்தில் இருந்தே பட்டியல் புரிதல்களைப் பயன்படுத்துவது சற்று வேகமானது.
பட்டியல் புரிதல்கள் மற்றும் ஜெனரேட்டர் வெளிப்பாடுகள் பற்றிய கூடுதல் தகவலுக்கு, பின்வரும் கட்டுரையைப் பார்க்கவும்.
- தொடர்புடைய கட்டுரைகள்:பைதான் பட்டியல் புரிதல்களை எவ்வாறு பயன்படுத்துவது
