Python-இல் strings-ஐ எவ்வாறு format செய்வீர்கள்?

Question

Accepted Answer

டைனமிக் மதிப்புகளுடன் strings உருவாக்க Python-இல் பல வழிகள் உள்ளன. நவீனமான, பரிந்துரைக்கப்படும் அணுகுமுறை **f-string** (formatted string literal) ஆகும், இது Python 3.6-இல் அறிமுகப்படுத்தப்பட்டது.

## f-strings — நவீன இயல்புநிலை

```python
name = "Ann"
age = 30

msg = f"{name} is {age} years old"   # "Ann is 30 years old"

# any expression works inside the braces
f"{name.upper()} in {age * 12} months"   # "ANN in 360 months"
f"Total: {price * quantity:.2f}"          # format spec: 2 decimals
```

`f` prefix உங்களை expressions-ஐ நேரடியாக `{}`-க்குள் உட்பொதிக்க அனுமதிக்கிறது — சுருக்கமான, படிக்கக்கூடிய, மற்றும் வேகமான. நவீன Python-இல் இதுவே விரும்பப்படும் முறை.

## Format specifiers — வெளியீட்டைக் கட்டுப்படுத்துதல்

```python
f"{3.14159:.2f}"     # "3.14"      — 2 decimal places
f"{1000000:,}"        # "1,000,000" — thousands separator
f"{0.85:.1%}"         # "85.0%"     — percentage
f"{42:05d}"           # "00042"     — pad with zeros to width 5
f"{'hi':>10}"         # "        hi" — right-align in width 10
f"{'hi':^10}"         # "    hi    " — center
```

மதிப்புக்குப் பிறகு வரும் `:spec` துல்லியம், padding, alignment, மற்றும் எண் formatting ஆகியவற்றைக் கட்டுப்படுத்துகிறது — தூய்மையான வெளியீட்டிற்கு சக்திவாய்ந்தது.

## Debugging குறுக்குவழி (3.8+)

```python
f"{name=}"            # "name='Ann'" — prints both the expression AND value
```

விரைவான debugging-க்கு `=` வசதியானது — இது variable-இன் பெயரையும் அதன் மதிப்பையும் காட்டுகிறது.

## பழைய முறைகள் (இவற்றை இன்னும் காண்பீர்கள்)

```python
"{} is {}".format(name, age)     # str.format() — pre-f-string standard
"%s is %d" % (name, age)          # %-formatting — old C-style (avoid in new code)
name + " is " + str(age)          # concatenation — verbose, error-prone
```

`.format()` பழைய code-இல் இன்னும் பொதுவானது; `%`-formatting பழமையானது; raw concatenation ஊக்கப்படுத்தப்படுவதில்லை (சொற்பெருக்கானது மற்றும் கைமுறையாக `str()` conversion தேவைப்படுகிறது).

## இது ஏன் முக்கியம்

String formatting தொடர்ந்து தேவைப்படுகிறது — messages, logs, output, queries உருவாக்குதல்.

F-strings நவீன, படிக்கக்கூடிய, மற்றும் திறமையான தரநிலையாகும், மேலும் அவற்றின் format specifiers (துல்லியம், padding, alignment, separators) தெரிந்திருப்பது சொற்பெருக்கான code இல்லாமல் தூய்மையான, தொழில்முறை வெளியீட்டை உருவாக்க உங்களை அனுமதிக்கிறது.

பழைய `.format()` மற்றும் `%` பாணிகளை அடையாளம் காண்பது தற்போதுள்ள codebases-ஐ படிக்கும்போது உதவுகிறது.

f-strings-ஐ நன்றாகப் பயன்படுத்துவது தெளிவான, idiomatic Python எழுதுவதன் சிறிய ஆனால் பரவலான பகுதியாகும்.