Python मध्ये slicing कसे काम करते?

Question

Accepted Answer

**Slicing** `sequence[start:stop:step]` syntax वापरून sequence (list, tuple, string) चा एक भाग काढून टाकते. हा एक शक्तिशाली, संक्षिप्त वैशिष्ट्य आहे जो 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]` indexes 1, 2, 3 देते — 4 नाही).

## नकारात्मक indexes शेवटपासून मोजले जातात

```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]` sequence उलट करणे हा सर्वात ओळखता येणारा Python idiom आहे.

## Strings slicing

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

## Slice assignment (mutable lists साठी)

```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])
```

एकल-index access (जे `IndexError` उंचवते) च्या विपरीत, slicing दयाळूपणे उपलब्ध असलेले काही परत करते.

## हे महत्वाचे का आहे

Slicing हा एक सर्वव्यापी, विशिष्ट Python वैशिष्ट्य आहे sequences काढून टाकणे, कॉपी करणे आणि उलट करणे साफ करण्यासाठी.

`start:stop:step` syntax (विशेषत: inclusive-start/exclusive-stop), नकारात्मक indexes (शेवटपासून मोजले), reverse idiom (`[::-1]`), आणि slicing सुरक्षित आहे (out-of-range वर क्रॅश होत नाही) हे समजून आपण lists आणि strings संक्षिप्तपणे आणि योग्यरीत्या हाताळू शकता.

हे सामान्य ऑपरेशन्सच्या verbose loops बदलते आणि idiomatic Python code मध्ये दिसते.