அடிப்படை

Python-இல் சரங்கள்: split, replace, strip, join, துண்டிப்புகள் (slices) மற்றும் f-சரங்கள்

புதுப்பிக்கப்பட்டது: · Skillaria.Top

Python-இல் சரம் (str) என்பது மாற்ற முடியாத Unicode எழுத்துத் தொடர். split() சரத்தை பட்டியலாகப் பிரிக்கிறது, join() பட்டியலை மீண்டும் ஒட்டுகிறது, replace() ஒரு துணைச்சரத்தை மாற்றுகிறது, strip() ஓரங்களில் உள்ள இடைவெளிகளை நீக்குகிறது; ஒவ்வொரு முறையும் புதிய சரத்தைத் திருப்பித் தரும். மதிப்புகளைப் பொருத்த f-சரம் மிகவும் வசதியானது: f"{name}: {price:.2f}".

Python-இல் சரங்கள் எந்த நிரலிலும் வருகின்றன: பயனர் உள்ளீடு, கோப்புப் பெயர்கள், CSV வரிகள், API பதில்கள். str வகை உரையை Unicode-இல் சேமிக்கிறது, அதனால் தமிழ் எழுத்துகளும் ஈமோஜிகளும் சிறப்பு அமைப்பின்றி வேலை செய்கின்றன. மிகவும் பயன்படும் முறைகள் — split, replace, strip மற்றும் join; மதிப்புகளை வெளியிட f-சரங்கள் வசதியானவை. எல்லாவற்றையும் எடுத்துக்காட்டுகளுடன் பார்ப்போம்.

Python-இல் சரம் எப்படி அமைந்துள்ளது

சரத்தை ஒற்றை அல்லது இரட்டை மேற்கோள் குறிகளில் எழுதலாம் — வேறுபாடு இல்லை: 'காபி' மற்றும் "காபி" ஒன்றே. மூன்று மேற்கோள்கள் பல வரி சரத்தை உருவாக்கும்; அதில் வரி முறிவுகள் அப்படியே பாதுகாக்கப்படும்.

name = "காபி"
note = """முதல் வரி
இரண்டாம் வரி"""
print(len(name))  # 4 — எழுத்துகளில் நீளம்

சரங்களின் முக்கிய பண்பு — மாற்ற முடியாமை. ஒரு முறை சரத்தை மாற்றுவதில்லை; புதிய சரத்தைத் திருப்பித் தருகிறது. அதனால் s.replace("a", "b") ஒதுக்கீடு இல்லாமல் எதையும் மாற்றாது — s = s.replace("a", "b") என்று எழுத வேண்டும். இதுவே தொடக்கநிலையாளரின் மிகப் பொதுவான தவறு.

சிறப்பு எழுத்துகள், வரி முறிவு மற்றும் மூல சரங்கள்

வரி முறிவு \n, தாவல் (tab) \t, பின்சாய்வு \\ எனக் குறிக்கப்படும். r முன்னொட்டு சரத்தை "மூலமாக" ஆக்கும்: அதில் பின்சாய்வுகள் செயலாக்கப்படுவதில்லை. Windows பாதைகளுக்கும் வழக்கமான வெளிப்பாடுகளுக்கும் இது வசதியானது.

print("மொத்தம்:\n350 ₹")
path = r"C:\new\table.csv"   # \n மற்றும் \t சிறப்பு எழுத்துகளாக மாறாது

நீண்ட வெளிப்பாட்டை அடுத்த குறியீட்டு வரிக்கு மாற்றலாம், அதை அடைப்புக்குறிக்குள் வைத்து: அடைப்புக்குள் அருகருகே உள்ள சரங்களை Python தானாக இணைக்கும்.

split: சரத்தைப் பட்டியலாகப் பிரித்தல்

split() சரத்தை ஒரு பிரிப்பானால் பிரித்து பட்டியலைத் திருப்பித் தரும். வாதம் இல்லாமல் அழைத்தால் அது எந்த இடைவெளி எழுத்திலும் பிரிக்கும், திரும்பும் இடைவெளிகளைப் புறக்கணிக்கும் — கட்டளைகளைப் பிரிக்க இது வசதியானது.

"add  காபி 250".split()        # ['add', 'காபி', '250']
"2026-10-16".split("-")        # ['2026', '10', '16']
"a,b,,c".split(",")            # ['a', 'b', '', 'c']
"key=value=x".split("=", 1)    # ['key', 'value=x']

வேறுபாட்டைக் கவனியுங்கள்: தெளிவான பிரிப்பானுடன் வெற்றுத் துண்டுகள் பாதுகாக்கப்படும். இரண்டாவது வாதம் maxsplit பிளவுகளின் எண்ணிக்கையைக் கட்டுப்படுத்தும்; rsplit() வலப்புறத்திலிருந்து பிரிக்கும். உரையை வரிகளாகப் பிரிக்க splitlines() பயன்படுத்துங்கள்: அது \n மற்றும் \r\n இரண்டையும் புரிந்துகொள்ளும், இறுதியில் வெற்று உறுப்பை விடாது.

text = "காபி\nடாக்ஸி\n"
text.split("\n")     # ['காபி', 'டாக்ஸி', '']
text.splitlines()    # ['காபி', 'டாக்ஸி']

join: பட்டியலை ஒரு சரமாக ஒட்டுதல்

join() எதிர்ச் செயல். அதை பிரிப்பான் சரத்தின் மீது அழைத்து, வாதமாக சரங்களின் பட்டியலைக் கொடுக்கிறோம்:

items = ["காபி", "டாக்ஸி", "மதிய உணவு"]
print(", ".join(items))   # காபி, டாக்ஸி, மதிய உணவு
print("\n".join(items))   # ஒவ்வொரு உருப்படியும் புதிய வரியில்

எல்லா உறுப்புகளும் சரங்களாக இருக்க வேண்டும்; இல்லையென்றால் TypeError: sequence item 0: expected str instance, int found வரும். எண்களை முதலில் மாற்றுங்கள்: ", ".join(str(x) for x in amounts).

சரங்களை இணைத்தல்

இரண்டு சரங்களை + மூலம் கூட்டலாம், * மூலம் திரும்பச் செய்யலாம்: "-" * 20. ஆனால் சுழலில் நூற்றுக்கணக்கான துண்டுகளை += மூலம் ஒட்டுவது மெதுவானது, ஏனெனில் ஒவ்வொரு முறையும் புதிய சரம் உருவாகிறது. பகுதிகளை பட்டியலில் சேர்த்து ஒரே join() மூலம் இணையுங்கள். சரத்தையும் எண்ணையும் நேரடியாகக் கூட்ட முடியாது: "மொத்தம்: " + 5 TypeError தரும்; str() செயல்பாடு அல்லது f-சரம் தேவை.

replace: துணைச்சரத்தை மாற்றுதல்

replace(old, new) துணைச்சரத்தின் எல்லா நிகழ்வுகளையும் மாற்றும். மூன்றாவது வாதம் மாற்றங்களின் எண்ணிக்கையைக் கட்டுப்படுத்தும்.

price = "1 250,50"
price = price.replace(" ", "").replace(",", ".")
print(float(price))                  # 1250.5

"அ-ஆ-இ".replace("-", "+", 1)         # 'அ+ஆ-இ'

இந்த முறை பெரிய சிறிய எழுத்துகளை வேறுபடுத்தும்; சரியான பொருத்தத்தைத் தேடும். வடிவத்தின்படி மாற்றங்களுக்கு (உதாரணமாக "எல்லா இலக்கங்கள்") re தொகுதியும் re.sub() செயல்பாடும் தேவை.

strip, lstrip, rstrip: சரத்தின் ஓரங்களைத் துண்டித்தல்

strip() இரு ஓரங்களிலிருந்தும் இடைவெளிகள், தாவல்கள் மற்றும் வரி முறிவுகளை நீக்கும். lstrip() இடப்புறம் மட்டும், rstrip() வலப்புறம் மட்டும். பயனர் உள்ளீடு மற்றும் கோப்பு வரிகளுடன் முதலில் செய்ய வேண்டியது இதுவே.

raw = "  காபி \n"
raw.strip()       # 'காபி'
raw.rstrip()      # '  காபி'
"xxகாபிxx".strip("x")   # 'காபி'

வாதம் எழுத்துகளின் தொகுப்பைக் குறிக்கிறது, துணைச்சரத்தை அல்ல: "abcஉரைcba".strip("abc") ஓரங்களிலிருந்து எந்த வரிசையிலும் a, b, c எல்லாவற்றையும் நீக்கும். குறிப்பிட்ட முன்னொட்டு அல்லது பின்னொட்டை மட்டும் நீக்க removeprefix() மற்றும் removesuffix() (Python 3.9 முதல்) பயன்படுத்துங்கள்.

சரங்களின் பிற பயனுள்ள முறைகள்

முறைஎன்ன செய்கிறதுஎடுத்துக்காட்டு → முடிவு
lower(), upper()எழுத்துவகை"Coffee".lower() → 'coffee'
startswith(), endswith()தொடக்கம் மற்றும் முடிவைச் சரிபார்த்தல்"a.csv".endswith(".csv") → True
find()துணைச்சரத்தின் நிலை அல்லது -1"காபி".find("பி") → 3
count()நிகழ்வுகளின் எண்ணிக்கை"banana".count("a") → 3
isdigit()இலக்கங்கள் மட்டுமா?"250".isdigit() → True
zfill()பூஜ்ஜியங்களால் நிரப்புதல்"7".zfill(3) → '007'

சரத்தில் துணைச்சரம் உள்ளதா என்று சோதிக்க எளிய வழி in இயக்கி: if "காபி" in text.lower():. சரங்கள் == மூலம் எழுத்து எழுத்தாக, பெரிய சிறிய எழுத்தை வேறுபடுத்தி ஒப்பிடப்படும்; எழுத்துவகையைப் பொருட்படுத்தாமல் ஒப்பிட இரண்டையும் casefold() மூலம் மாற்றுங்கள்.

சரங்களின் துண்டிப்புகள் (slices)

சரம் ஒரு தொடர் என்பதால், எழுத்துகளை பூஜ்ஜியத்திலிருந்து தொடங்கும் குறியீட்டால் அணுகலாம்; எதிர்மறைக் குறியீடு இறுதியிலிருந்து எண்ணும். s[start:stop:step] துண்டிப்பு துணைச்சரத்தைத் திருப்பித் தரும்; வலது எல்லை சேராது.

s = "Python"
s[0]      # 'P'
s[-1]     # 'n'
s[0:3]    # 'Pyt'
s[2:]     # 'thon'
s[::2]    # 'Pto'
s[::-1]   # 'nohtyP' — சரத்தைத் தலைகீழாக்கு

எல்லையைத் தாண்டினாலும் துண்டிப்பு பிழை தராது: s[0:100] முழு சரத்தையும் தரும். ஆனால் s[100] IndexError தரும். குறியீட்டில் உள்ள எழுத்தை மாற்ற முடியாது (s[0] = "J" — TypeError); புதிய சரத்தை உருவாக்க வேண்டும்: "J" + s[1:].

Python-இல் f-சரங்கள்

சரத்துக்கு முன் உள்ள f எழுத்து, சுருள் அடைப்புக்குள் உள்ள வெளிப்பாடுகளைக் கணக்கிட்டு உரையில் பொருத்தப்படும் என்று குறிக்கிறது. Python 3.6 முதல் சரங்களை வடிவமைக்க இதுவே முக்கிய வழி: format()-ஐ விடச் சுருக்கமானது, பழைய % இயக்கியை விட வேகமானது.

item = "காபி"
price = 250
print(f"{item}: {price} ₹")              # காபி: 250 ₹
print(f"தள்ளுபடியுடன்: {price * 0.9} ₹")    # தள்ளுபடியுடன்: 225.0 ₹
print(f"{item=}")                         # item='காபி' — பிழைதிருத்தத்துக்கு வசதி

எண்களின் வடிவமைப்பும் சீரமைப்பும்

அடைப்புக்குள் பெருங்குடலுக்குப் பின் வடிவமைப்புக் குறிப்பு எழுதப்படும். அது முழுமைப்படுத்தல், இலக்க பிரிப்பான்கள், அகலம் மற்றும் சீரமைப்பைத் தீர்மானிக்கிறது:

எழுத்துமுடிவுபொருள்
f"{3.14159:.2f}"3.142 தசம இடங்களுக்கு முழுமைப்படுத்தல்
f"{1250000:,}"1,250,000இலக்க பிரிப்பான்
f"{1250000:_}"1_250_000காற்புள்ளிக்குப் பதிலாக அடிக்கோடு
f"{0.256:.1%}"25.6%சதவீதம்
f"{'காபி':<10}|"காபி |இடப்புறம், அகலம் 10
f"{250:>8}" 250வலப்புறம்
f"{7:03d}"007பூஜ்ஜியங்களால் நிரப்புதல்

டெர்மினலில் அட்டவணைகளுக்கு சீரமைப்பு வசதியானது: f"{name:<12}{amount:>10.2f}" நெடுவரிசைகளை சரியாக வரிசைப்படுத்தும். வடிவமைப்பு வெளியீட்டின்போது மட்டுமே தேவை. பணத்தை float-இல் அல்ல, பைசாக்களில் (int) அல்லது Decimal-இல் சேமியுங்கள்: 0.1 + 0.2 0.30000000000000004 தரும்.

f-சரத்துக்குள் மேற்கோள்கள் மற்றும் வரி முறிவு

Python 3.12 (PEP 701) முதல் f-சரங்களுக்கு முறையான இலக்கணம் வந்தது: சுருள் அடைப்புக்குள் வெளியே உள்ள அதே மேற்கோள்களையும், பின்சாய்வுகளையும், வரி முறிவுகளையும் பயன்படுத்தலாம்; உள்ளமைவுக்கு இனி வரம்பு இல்லை. அடைப்புக்குள் உள்ள பிழைகள் இப்போது துல்லியமான இடத்தைக் காட்டுகின்றன. பழைய பதிப்புகளில் உள்ளே வேறு வகை மேற்கோள்களை எழுதுங்கள்: f"{d['key']}", வரி முறிவை தனி மாறி மூலமாகவோ chr(10) மூலமாகவோ சேர்க்கவும்.

பல வரி உரைக்கு மூன்று மேற்கோள்களில் f-சரம் பொருந்தும்: f"""மொத்தம்: {total}\nஉருப்படிகள்: {count}""".

format() மற்றும் %: பழைய முறைகள்

பழைய குறியீட்டில் "{}: {}".format(item, price) மற்றும் "%s: %d" % (item, price) வரும். format()-இன் குறிப்புகள் f-சரங்களைப் போன்றவையே. டெம்ப்ளேட் தரவிலிருந்து தனியாக, உதாரணமாக கட்டமைப்புக் கோப்பில், சேமிக்கப்படும்போது format() இன்னும் பயனுள்ளது.

சரத்தைப் பகுப்பது: நடைமுறை எடுத்துக்காட்டு

முறைகளை ஒன்றாகப் பயன்படுத்துவோம். கோப்பில் " 2026-10-16; காபி ; 250,50 \n" போன்ற வரிகள் வருகின்றன என்று வைத்துக்கொள்வோம்; தேதி, பெயர் மற்றும் தொகையை பைசாக்களில் பெற வேண்டும். வழக்கமான வரிசை: ஓரங்களைச் சுத்தம் செய், பிரிப்பானால் வெட்டு, ஒவ்வொரு பகுதியையும் சுத்தம் செய், வகைகளை மாற்று.

line = "  2026-10-16; காபி ; 250,50 \n"

date, item, raw_amount = [p.strip() for p in line.strip().split(";")]
amount_kop = round(float(raw_amount.replace(",", ".")) * 100)

print(date, item, amount_kop)            # 2026-10-16 காபி 25050
print(f"{item:<10}{amount_kop / 100:>10.2f}")

பகுதிகள் மூன்றுக்கு மேலோ குறைவாகவோ இருந்தால், பிரித்தெடுத்தல் ValueError: not enough values to unpack அல்லது too many values to unpack தரும். உண்மையான குறியீட்டில் அத்தகைய வரிகளை முன்கூட்டியே சரிபார்க்க வேண்டும் அல்லது விதிவிலக்கைப் பிடிக்க வேண்டும். மேற்கோள்களும் தப்பிக்குறிகளும் கொண்ட உண்மையான CSV கோப்புகளுக்கு split-க்குப் பதிலாக நிலையான csv தொகுதியைப் பயன்படுத்துங்கள்.

சரங்களில் பொதுவான தவறுகள்

  • முடிவை சேமிக்காமை: ஒதுக்கீடு இல்லாமல் s.strip() எதையும் மாற்றாது.
  • எண்களின் பட்டியலில் join — TypeError; முதலில் map(str, ...).
  • strip-க்கு துணைச்சரம் கொடுப்பது: வாதம் எழுத்துத் தொகுப்பு; முன்னொட்டுக்கு removeprefix() தேவை.
  • பெரிய சிறிய எழுத்து ஒப்பீடு: "காபி" == "காபி" — எழுத்து வேறுபட்டால் False.
  • Windows பாதைகளில் பின்சாய்வுகள் r முன்னொட்டு இல்லாமல் சிறப்பு எழுத்துகளாக மாறும்.

t-சரங்கள்: தயாராக உள்ள உரைக்குப் பதிலாக டெம்ப்ளேட்

Python 3.14-இல் t-சரங்கள் வந்தன. அவை f-சரங்களைப் போலவே தெரியும், ஆனால் t முன்னொட்டுடன்; முடிவு வேறு: தயார் சரம் அல்ல, string.templatelib.Template பொருள். அதில் உரைத் துண்டுகள் (.strings) மற்றும் பொருத்தப்பட்ட மதிப்புகள் (.values) தனித்தனியாக இருக்கும்.

name = "<script>"
tpl = t"வணக்கம், {name}!"
print(tpl.strings)   # ('வணக்கம், ', '!')
print(tpl.values)    # ('<script>',)

இது ஏன் தேவை: நூலகம் ஒட்டுவதற்கு முன்பே மதிப்புகளைப் பெற்று அவற்றைச் செயலாக்க முடியும் — உதாரணமாக HTML-இல் கோண அடைப்புக்குறிகளைத் தப்பிக்கச் செய்வது அல்லது SQL வினவலுக்கு அளவுருக்களை சரியாக அனுப்புவது. f-சரம் அப்படி வாய்ப்பு தராது; அது எல்லாவற்றையும் ஏற்கனவே ஒட்டிவிட்டது. சாதாரண வெளியீட்டுக்கு இன்னும் f-சரங்களையே பயன்படுத்துங்கள்.

சுருக்கம்

அன்றாட சரம் வேலைக்கு Python-இல் சில முறைகள் போதும்: split() மற்றும் join() உரையைப் பிரித்து இணைக்கும், strip() உள்ளீட்டைச் சுத்தம் செய்யும், replace() துண்டுகளை மாற்றும், துண்டிப்புகள் துணைச்சரங்களை வெட்டும், f-சரங்கள் மதிப்புகளைச் சரியான வடிவத்தில் வெளியிடும். மாற்ற முடியாமையை நினைவில் கொள்ளுங்கள்: முறை புதிய சரத்தைத் திருப்பித் தருகிறது, அதை சேமிக்க வேண்டும். சரங்கள், எண்கள் மற்றும் f-சரங்கள் செலவு கண்காணிப்பானின் எடுத்துக்காட்டில் Python பாடநெறியின் பாடத்தில் நடைமுறையில் விளக்கப்பட்டுள்ளன.

அடிக்கடி கேட்கப்படும் கேள்விகள்

Python-இல் சரத்தின் நீளத்தை எப்படி அறிவது?

len(s) செயல்பாடு எழுத்துகளின் எண்ணிக்கையைத் தரும். தமிழ் எழுத்துகளுக்கும் ஈமோஜிகளுக்கும் பைட்டுகள் அல்ல, Unicode எழுத்துகள் கணக்கிடப்படுகின்றன; பைட்டுகளில் அளவு <code>len(s.encode("utf-8"))</code> தரும்.

எண்ணை சரமாகவும் மீண்டும் எண்ணாகவும் எப்படி மாற்றுவது?

<code>str(250)</code> <code>'250'</code> தரும்; <code>int("250")</code> மற்றும் <code>float("2.5")</code> தலைகீழ் மாற்றம். சரம் எண்ணைப் போலத் தெரியவில்லை என்றால் <code>int()</code> <code>ValueError</code> தரும், அதனால் உள்ளீட்டைச் சரிபார்க்க வேண்டும்.

replace என் சரத்தை ஏன் மாற்றவில்லை?

சரங்கள் மாற்ற முடியாதவை; replace புதிய சரத்தைத் திருப்பித் தரும். முடிவை ஒதுக்குங்கள்: <code>s = s.replace("a", "b")</code>.

சரம் காலியா என்று எப்படிச் சோதிப்பது?

வெற்றுச் சரம் பொய்யாகக் கருதப்படுவதால் <code>if not s:</code> போதும். சரம் இடைவெளிகளால் மட்டும் ஆகி இருக்கக்கூடும் என்றால் <code>if not s.strip():</code> சரிபாருங்கள்.

t-சரமும் f-சரமும் இடையே வேறுபாடு என்ன?

f-சரம் உடனே தயார் <code>str</code>-ஐத் தருகிறது; t-சரம் (Python 3.14+) உரைத் துண்டுகளும் மதிப்புகளும் தனித்தனியாக உள்ள <code>Template</code> பொருளைத் தருகிறது. அதனால் தரவை HTML மற்றும் SQL-க்கு பாதுகாப்பாகத் தப்பிக்கச் செய்ய முடியும்.

இந்தத் தலைப்பை வீடியோவில் கற்றுக்கொள்ளுங்கள்

“Python 3.15: от новичка до профи” பாடநெறியில் இந்தத் தலைப்பு பயிற்சியுடன் விரிவாக விளக்கப்பட்டுள்ளது.

பாடநெறிக்குச் செல்