Что такое срезы в Python?

Срезы (Slicing) в Python

Определение

Срезы — это способ получить часть последовательности (список, кортеж, строка) по индексам. Они работают с синтаксисом [start:stop:step] и возвращают новую последовательность, не изменяя исходную.

Базовый синтаксис

sequence[start:stop:step]

• start — индекс начала (включается), по умолчанию 0
• stop — индекс конца (не включается), по умолчанию конец
• step — шаг итерации, по умолчанию 1

Простые примеры

numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

# start:stop
print(numbers[2:5])        # [2, 3, 4] — индексы 2, 3, 4 (5 не включается)
print(numbers[0:3])        # [0, 1, 2] — первые три элемента
print(numbers[7:10])       # [7, 8, 9] — последние три элемента

# Без start и stop
print(numbers[:5])         # [0, 1, 2, 3, 4] — с начала до индекса 5
print(numbers[5:])         # [5, 6, 7, 8, 9] — с индекса 5 до конца
print(numbers[:])          # [0, 1, 2, ...9] — копия всего списка

# Отрицательные индексы
print(numbers[-3:])        # [7, 8, 9] — последние три элемента
print(numbers[:-3])        # [0, 1, 2, 3, 4, 5, 6] — всё кроме последних трёх
print(numbers[-5:-2])      # [5, 6, 7] — с -5 до -2

Параметр step (шаг)

numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

# step = 1 (по умолчанию)
print(numbers[::1])        # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

# step = 2 (через один)
print(numbers[::2])        # [0, 2, 4, 6, 8]
print(numbers[1::2])       # [1, 3, 5, 7, 9]

# step = 3 (через два)
print(numbers[::3])        # [0, 3, 6, 9]

# step = -1 (в обратном порядке)
print(numbers[::-1])       # [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

# step = -2 (в обратном порядке через один)
print(numbers[::-2])       # [9, 7, 5, 3, 1]

Работа со строками

text = "Hello, World!"

print(text[0:5])           # "Hello" — первые 5 символов
print(text[7:12])          # "World" — символы с 7 по 12
print(text[:5])            # "Hello"
print(text[7:])            # "World!" — со строки 7 до конца

# Обратный порядок
print(text[::-1])          # "!dlroW ,olleH" — строка вдругу

# Проверка палиндрома
def is_palindrome(s):
    return s == s[::-1]    # Сравним со своей обратной версией

print(is_palindrome("рacecar"))  # True
print(is_palindrome("hello"))    # False

Срезы с кортежами

coords = (10, 20, 30, 40, 50)

print(coords[1:3])         # (20, 30)
print(coords[::2])         # (10, 30, 50)
print(coords[::-1])        # (50, 40, 30, 20, 10)

# Кортежи — неизменяемые, срезы создают новый кортеж
sliced = coords[1:4]
print(type(sliced))        # <class 'tuple'>

Важные правила

arr = [0, 1, 2, 3, 4, 5]

# 1. Срезы НЕ вызывают ошибку при выходе за границы
print(arr[2:100])          # [2, 3, 4, 5] — просто берёт до конца
print(arr[100:200])        # [] — пустой список
print(arr[-100:-50])       # [] — пустой список

# 2. Срезы создают НОВЫЙ объект, не меняют исходный
original = [1, 2, 3, 4, 5]
sliced = original[1:3]
sliced[0] = 999
print(original)            # [1, 2, 3, 4, 5] — не изменился
print(sliced)              # [999, 3]

# 3. Начало должно быть меньше конца (при положительном step)
print(arr[5:2])            # [] — пустой список, потому что 5 > 2

# 4. С отрицательным step правила меняются
print(arr[5:2:-1])         # [5, 4, 3] — от 5 к 3 в обратном порядке

Срезы мультимерных структур

# Двумерные списки (матрицы)
matrix = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
]

print(matrix[0])           # [1, 2, 3] — первая строка
print(matrix[0][1])        # 2 — элемент в первой строке, втором столбце
print(matrix[0:2])         # [[1,2,3], [4,5,6]] — первые две строки
print(matrix[0:2][0])      # [1, 2, 3] — сначала берём срез, потом индекс

# Для более сложных операций используй NumPy
import numpy as np
arr = np.array(matrix)
print(arr[0:2, 1:3])       # Срезы по двум измерениям

Практические примеры

# 1. Получить последний элемент
lst = [1, 2, 3, 4, 5]
print(lst[-1])             # 5

# 2. Получить последние N элементов
print(lst[-3:])            # [3, 4, 5]

# 3. Пропустить первый и последний элемент
print(lst[1:-1])           # [2, 3, 4]

# 4. Разделить строку на слова (грубо)
sentence = "Python - это мощный язык программирования"
words = sentence.split()
print(words[::2])          # Каждое второе слово

# 5. Инвертировать список
print(lst[::-1])           # [5, 4, 3, 2, 1]

# 6. Извлечь четные индексы
print(lst[::2])            # [1, 3, 5]

# 7. Очистить начало и конец
data = "   hello world   "
print(data.strip())        # Встроенный метод
print(data[3:-3])          # Или так (если точно знаем)

# 8. Циклический сдвиг
arr = [1, 2, 3, 4, 5]
n = 2
rotated = arr[-n:] + arr[:-n]  # [4, 5, 1, 2, 3]
print(rotated)

Срезы vs индексация

lst = ['a', 'b', 'c', 'd', 'e']

# Индексация [n] — один элемент
print(lst[2])              # 'c' — тип: str

# Срезы [n:m] — всегда список/кортеж/строка
print(lst[2:3])            # ['c'] — тип: list
print(lst[2:4])            # ['c', 'd'] — тип: list

# Это важно для обработки результатов
result = lst[2]            # 'c'
result = lst[2:3]          # ['c']

Сложные срезы

def process_data(data):
    # Пропустить заголовок, взять каждую вторую строку
    return data[1::2]

# Обратный порядок с пропуском
lst = list(range(10))      # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
print(lst[8:2:-2])         # [8, 6, 4]

# Зеркало
print(lst[::-1])           # [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

# Альтернирующие отступы
print(lst[::3])            # [0, 3, 6, 9] — каждый третий

Итоговое резюме

sequence[start:stop:step]

# Ключевые точки:
# - start включается, stop исключается
# - Отрицательные индексы считаются с конца
# - Срезы НЕ вызывают IndexError при выходе за границы
# - Срезы создают НОВЫЙ объект
# - Работают со строками, списками, кортежами, range()
# - step может быть отрицательным для реверса
# - Очень полезны для обработки данных и текста