Python ਵਿੱਚ slicing ਕਿਵੇਂ ਕੰਮ ਕਰਦੀ ਹੈ?

Question

Accepted Answer

**Slicing** ਇੱਕ ਸਿਲਸਿਲਤ (ਲਿਸਟ, ਟਿਪਲ, ਸਤਰ) ਦੇ ਇੱਕ ਹਿੱਸੇ ਨੂੰ `sequence[start:stop:step]` ਸਿੰਟੈਕਸ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਬਾਹਰ ਕੱਢਦਾ ਹੈ। ਇਹ ਇੱਕ ਸ਼ਕਤੀਸ਼ਾਲੀ, ਸੰਖੇਪ ਵਿਸ਼ੇਸ਼ਤਾ ਹੈ ਜੋ 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
```

## ਸਟੈਪ ਪੈਰਾਮੀਟਰ

```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 ਦੇ ਸਭ ਤੋਂ ਮਾਨਤਾ ਪ੍ਰਾਪਤ ਪ੍ਰਥਾਵਾਂ ਵਿੱਚੋਂ ਇੱਕ ਹੈ।

## ਸਤਰਾਂ ਦੀ 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 ਵਿਸ਼ੇਸ਼ਤਾ ਹੈ।

`start:stop:step` ਸਿੰਟੈਕਸ ਨੂੰ ਸਮਝਣਾ (ਖਾਸ ਤੌਰ ਉੱਤੇ ਸ਼ਾਮਿਲ-ਸ਼ੁਰੂ/ਬਾਹਰ-ਸਟਾਪ), ਨਕਾਰਾਤਮਕ ਸੂਚਕਾਂਕ (ਅੰਤ ਤੋਂ ਗਿਣਤੇ ਹਨ), ਰਿਵਰਸ ਪ੍ਰਥਾ (`[::-1]`), ਅਤੇ ਇਹ ਕਿ slices ਸੁਰੱਖਿਅਤ ਹਨ (ਬਾਹਰ-ਰੇਂਜ 'ਤੇ ਕੋਈ ਕ੍ਰੈਸ਼ ਨਹੀਂ) ਤੁਹਾਨੂੰ ਲਿਸਟਾਂ ਅਤੇ ਸਤਰਾਂ ਨੂੰ ਸੰਖੇਪ ਅਤੇ ਸਹੀ ਤਰੀਕੇ ਨਾਲ ਹੇਰਾਫੇਰੀ ਕਰਨ ਦਿੰਦਾ ਹੈ।

ਇਹ ਆਮ ਓਪਰੇਸ਼ਨ ਲਈ ਵਰਬਲ ਲੂਪਾਂ ਨੂੰ ਬਦਲਦਾ ਹੈ ਅਤੇ idiomatic Python ਕੋਡ ਵਿੱਚ ਦਿਖਾਈ ਦਿੰਦਾ ਹੈ।