Slicing trong Python hoạt động như thế nào?

Question

Accepted Answer

**Slicing** trích xuất một phần của một chuỗi (list, tuple, string) bằng cú pháp `sequence[start:stop:step]`. Đây là một tính năng mạnh mẽ, súc tích được dùng liên tục trong Python.

## Slicing cơ bản

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

nums[1:4]     # [1, 2, 3]   — bắt đầu từ chỉ số 1, đến (KHÔNG bao gồm) 4
nums[:3]      # [0, 1, 2]   — từ đầu (start mặc định là 0)
nums[3:]      # [3, 4, 5]   — đến cuối (stop mặc định là len)
nums[:]       # [0, 1, 2, 3, 4, 5] — một BẢN SAO (nông) đầy đủ
```

Quy tắc chính: `start` là **bao gồm**, `stop` là **loại trừ** (`nums[1:4]` cho các chỉ số 1, 2, 3 — không phải 4).

## Chỉ số âm đếm từ cuối

```python
nums[-1]      # 5  — phần tử cuối
nums[-2]      # 4  — phần tử áp chót
nums[-3:]     # [3, 4, 5] — ba phần tử cuối
nums[:-1]     # [0, 1, 2, 3, 4] — mọi thứ trừ phần tử cuối
```

## Tham số step

```python
nums[::2]     # [0, 2, 4]      — mỗi phần tử thứ 2
nums[1::2]    # [1, 3, 5]      — mỗi phần tử thứ 2, bắt đầu từ chỉ số 1
nums[::-1]    # [5, 4, 3, 2, 1, 0] — ĐẢO NGƯỢC chuỗi (một thành ngữ nổi tiếng)
```

`nums[::-1]` đảo ngược một chuỗi là một trong những thành ngữ Python dễ nhận biết nhất.

## Slicing chuỗi ký tự

```python
s = "Hello"
s[1:4]        # "ell"
s[::-1]       # "olleH" — đảo ngược một chuỗi
s[0]          # "H"
```

## Gán slice (cho list mutable)

```python
nums = [0, 1, 2, 3, 4]
nums[1:3] = [10, 20, 30]   # thay thế một slice (có thể thay đổi độ dài)
# nums → [0, 10, 20, 30, 3, 4]
```

## Slicing an toàn (không có IndexError)

```python
nums[10:20]   # [] — slice ngoài phạm vi trả về rỗng, không crash (khác nums[10])
```

Khác với truy cập theo một chỉ số (gây ra `IndexError`), slicing trả về một cách nhẹ nhàng những gì có sẵn.

## Tại sao điều này quan trọng

Slicing là một tính năng phổ biến, đặc trưng-Python để trích xuất, sao chép và đảo ngược chuỗi một cách gọn gàng.

Hiểu cú pháp `start:stop:step` (đặc biệt là bao-gồm-start/loại-trừ-stop), chỉ số âm (đếm từ cuối), thành ngữ đảo ngược (`[::-1]`), và việc slice là an toàn (không crash khi ngoài phạm vi) cho phép bạn thao tác list và chuỗi một cách súc tích và đúng đắn.

Nó thay thế các vòng lặp dài dòng cho các thao tác phổ biến và xuất hiện xuyên suốt code Python đúng phong cách.