როგორ მუშაობს დაჭრა Python-ში?

Question

IT Interview Practice · Accepted Answer

**დაჭრა** აკრეფს თანმიმდევრობის (list, tuple, string) ნაწილს სინტაქსის გამოყენებით `sequence[start:stop:step]`. ეს არის ძლიერი, ლაკონური ფუნქცია, რომელიც მუდმივად გამოიყენება Python-ში.

## ძირითადი დაჭრა

```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-ის ერთ-ერთი ყველაზე ცნობილი იდიომაა.

## სტრიქონების დაჭრა

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

## დაჭრა უსაფრთხოა (არ არის IndexError)

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

ერთი ინდექსის წვდომის (რომელიც აწვება `IndexError`) განსხვავებით, დაჭრა მოწონებით ბრუნდება ის, რაც ხელმისაწვდომია.

## რატომ არის ეს მნიშვნელოვანი

დაჭრა არის ყოვლმხრივი, განსაკუთრებით Python-ური ფუნქცია თანმიმდევრობის აკრეფის, კოპირებისა და შებრუნებისთვის სუფთად.

`start:stop:step` სინტაქსის გაგება (განსაკუთრებით inclusive-start/exclusive-stop), უარყოფითი ინდექსები (დაითვლება ბოლოდან), შებრუნების იდიომა (`[::-1]`), და რომ დაჭრა უსაფრთხოა (არ ჩავარდება დიაპაზონის გარეთ) საშუალებას გაძლევთ ლაკონურად და სწორად მანიპულირება სიები და სტრიქონები.

ეს ცვლის ვერბოზული მარყუჟებს საერთო ოპერაციებისთვის და ჩნდება მთელი იდიომატური Python კოდი.

ძირითადი დაჭრა

უარყოფითი ინდექსები ითვლება ბოლოდან

step პარამეტრი

სტრიქონების დაჭრა

დაჭრის მინიჭება (მოდიფიცირებადი სიებისთვის)

დაჭრა უსაფრთხოა (არ არის IndexError)

რატომ არის ეს მნიშვნელოვანი

დაკავშირებული კითხვები