Python இல் slicing எவ்வாறு செயல்படுகிறது?

Question

Accepted Answer

**Slicing** என்பது `sequence[start:stop:step]` என்ற வாக்கியைப் பயன்படுத்தி ஒரு தொடர்முறையின் (பட்டியல், tuple, சரம்) ஒரு பகுதியை பிரித்தெடுக்கும் ஒரு சக்திशালী, சுருக்கமான பண்பு ஆகும். இது Python இல் நிரந்தரமாகப் பயன்படுத்தப்படுகிறது.

## அடிப்படை slicing

```python
nums = [0, 1, 2, 3, 4, 5]

nums[1:4]     # [1, 2, 3]   — start at index 1, up to (NOT including) 4
nums[:3]      # [0, 1, 2]   — from the start (start defaults to 0)
nums[3:]      # [3, 4, 5]   — to the end (stop defaults to len)
nums[:]       # [0, 1, 2, 3, 4, 5] — a full (shallow) COPY
```

முக்கிய விதி: `start` **உள்ளடக்கம்**, `stop` **விதிவிலக்கு** (`nums[1:4]` இடங்கள் 1, 2, 3 ஐ கொடுக்கிறது — 4 அல்ல).

## எதிர்மறை குறியீடுகள் முடிவிலிருந்து கணக்கிடப்படுகின்றன

```python
nums[-1]      # 5  — last element
nums[-2]      # 4  — second to last
nums[-3:]     # [3, 4, 5] — last three elements
nums[:-1]     # [0, 1, 2, 3, 4] — everything except the last
```

## step அளவுரு

```python
nums[::2]     # [0, 2, 4]      — every 2nd element
nums[1::2]    # [1, 3, 5]      — every 2nd, starting at index 1
nums[::-1]    # [5, 4, 3, 2, 1, 0] — REVERSE the sequence (a famous idiom)
```

`nums[::-1]` ஒரு தொடர்முறையை தலைகீழாக மாற்றுவது பெரும்பாலான Python idioms இல் ஒன்றாகும்.

## சரங்கள் slicing

```python
s = "Hello"
s[1:4]        # "ell"
s[::-1]       # "olleH" — reverse a string
s[0]          # "H"
```

## Slice வெளியீடு (மாறக்கூடிய பட்டியலுக்கு)

```python
nums = [0, 1, 2, 3, 4]
nums[1:3] = [10, 20, 30]   # replace a slice (can change length)
# nums → [0, 10, 20, 30, 3, 4]
```

## Slicing பாதுகாப்பாக உள்ளது (IndexError இல்லை)

```python
nums[10:20]   # [] — out-of-range slices return empty, don't crash (unlike nums[10])
```

ஒற்றை-குறியீடு அணுகலைப் போலல்லாமல் (இது `IndexError` எழுப்புகிறது), slicing திருக்கமாக கிடைக்கக்கூடிய வற்றை திரும்ப அளிக்கிறது.

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

Slicing என்பது Python இல் தொடர்முறையை சுலபமாக பிரித்தெடுக்க, நகல் செய்ய மற்றும் தலைகீழாக மாற்ற பயன்படும் ஒரு நிரந்தர, Python-சாரமான பண்பு ஆகும்.

`start:stop:step` வாக்கியை (குறிப்பாக உள்ளடக்கம்-தொடக்கம்/விதிவிலக்கு-நிறுத்தம்) புரிந்துகொள்ளுதல், எதிர்மறை குறியீடுகள் (முடிவிலிருந்து கணக்கிடப்படுகிறது), தலைகீழ் idiom (`[::-1]`), மற்றும் slices பாதுகாப்பாக உள்ளன (அணையின் வெளியே பொடிந்து விழாது) பட்டியல்களையும் சரங்களையும் சுருக்கமாகவும் சரியாகவும் கையாள உங்களை அனுமதிக்கிறது.

இது பொதுவான செயல்பாடுகளுக்கான verbose loops ஐ பதிலாக வைக்கிறது மற்றும் idiomatic Python குறியீட்டை முழுவதுமாகத் தோன்றும்.