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

URL: https://skillaria.top/ta/guides/python/stroki-python

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.14` | 2 தசம இடங்களுக்கு முழுமைப்படுத்தல் |

| `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.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 = ""
tpl = t"வணக்கம், {name}!"
print(tpl.strings)   # ('வணக்கம், ', '!')
print(tpl.values)    # ('',)
```

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

## சுருக்கம்

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

## FAQ

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

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

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

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

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

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

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

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

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

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


---
Source: Skillaria.Top (https://skillaria.top)