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 ఆదర్శాలలో ఒకటి.

## స్ట్రింగ్‌ల slicing

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

## స్లైస్ నియామకం (మార్పు చేయదగిన జాబితాల కోసం)

```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` వాక్యనిర్మాణాన్ని (ముఖ్యంగా చేర్చుకున్న-ప్రారంభం/మినహాయించిన-ఆపు) అర్థం చేసుకోవడం, ప్రతికూల సూచికలు (ముగింపు నుండి లెక్కించబడతాయి), రివర్స్ ఆదర్శం (`[::-1]`), మరియు slices సురక్షితమైనవి (పరిధి బయటకు క్రాష్ లేదు) జాబితాలను మరియు స్ట్రింగ్‌లను సంక్షిప్తంగా మరియు సరిగ్గా మార్చడానికి మిమ్మల్ని అనుమతిస్తుంది.

ఇది సాధారణ కార్యకలాపాల కోసం వివరమైన loops లను భర్తీ చేస్తుంది మరియు సమస్త idiomatic Python కోడ్ లో కనిపిస్తుంది.