Hogyan működik a slicing a Pythonban?

Question

IT Interview Practice · Accepted Answer

**A slicing** a `sequence[start:stop:step]` szintaxissal kivonja a szekvencia (lista, tuple, string) egy részét. Ez egy hatékony, tömör szolgáltatás, amelyet a Pythonban folyamatosan használnak.

## Alapvető 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
```

A legfontosabb szabály: a `start` **inkluzív**, a `stop` **exkluzív** (`nums[1:4]` az 1, 2, 3 indexeket adja — nem a 4-et).

## A negatív indexek a végről számítanak

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

## A lépés paramétere

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

A `nums[::-1]` szekvencia megfordítása a Python legfelismerhetőbb idiómái közül egyik.

## Stringek slicingje

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

## Slice hozzárendelés (módosítható listák esetén)

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

## A slicing biztonságos (nincs IndexError)

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

Az egyetlen indexszel végzett hozzáférés másodlagos (amely `IndexError`-t dob), a slicing kegyes módon visszaadja azt, amely elérhető.

## Miért fontos

A slicing egy mindenütt jelen lévő, jellegzetesen pythoni funkcionalitás a szekvenyek tiszta kinyeréséhez, másolásához és megfordításához.

A `start:stop:step` szintaxis megértése (különösen az inclusive-start/exclusive-stop), a negatív indexek (a végről számítás), az inverz idiom (`[::-1]`), és az, hogy a sliceek biztonságosak (nincs összeomlás a tartományon kívül), lehetővé teszi a listák és stringek tömör és helyes kezelését.

Helyettesíti a közös műveletek részletesebb hurkait, és az idiomatikus Python kódban mindenütt jelen van.

Alapvető slicing

A negatív indexek a végről számítanak

A lépés paramétere

Stringek slicingje

Slice hozzárendelés (módosítható listák esetén)

A slicing biztonságos (nincs IndexError)

Miért fontos

Kapcsolódó kérdések