Строки: символы, индексы и срезы – Учебник

8.1

О чём этот урок

В строке '2026-08-01' записана дата, и из неё нужно достать год – четыре первых символа. Пока строка умеет отдавать символы только по одному, задача решается циклом: завести пустую строку-накопитель, отсчитать первые четыре позиции, приклеить символы по одному. Работает – но стоит понадобиться не году, а месяцу или куску между дефисами, и цикл придётся переписывать заново.

В этом уроке: из чего состоит строка; как обратиться к одному символу по индексу – прямому и отрицательному; как вырезать кусок строки одной короткой записью; почему строку нельзя изменить и что делают вместо изменения; зачем языку такой запрет.

Строка – последовательность символов

Строка (str) – упорядоченная последовательность символов. У каждого символа есть своё место в ней – индекс.

Слово «упорядоченная» здесь не украшение: порядок – часть значения. 'кот' и 'ток' состоят из одних и тех же букв, но это две разные строки, и Python считает их неравными.

Длину строки даёт len():

s = 'Привет'
print(len(s))       # 6 – символов в строке
print(len(s[0]))    # 1 – символ это тоже строка

Отдельного типа «символ» в Python нет: то, что возвращает s[0], – строка длины 1, у неё и type() даст str, и len() – единицу. В C и Java для одиночного символа есть свой тип char, и там 'a' и "a" – вещи принципиально разные; в Python кавычки взаимозаменяемы, и отдельного типа под один символ не завелось. Практическое следствие: функция ord() из урока 7.3 принимает строку ровно из одного символа – ни пустую, ни из двух букв.

Числовые коды символов здесь больше не понадобятся, но если нужно освежить: ord() и chr() разобраны в уроке 7.3, а устройство кодовых таблиц – почему буквы и цифры лежат подряд и почему регистр отличается на 32 – в уроке 7.2.

Строка итерируема: её можно поставить прямо в заголовок for, и цикл выдаст символы по одному, слева направо. Если нужен ещё и номер позиции, берут range(len(s)) и обращаются к s[i] внутри цикла.

text = 'Привет'

# по символам – когда номер не важен
for ch in text:
    print(ch, end=' ')      # П р и в е т

print()

# по индексам – когда нужен номер позиции
for i in range(len(text)):
    print(i, text[i])       # 0 П / 1 р / 2 и / ...

Индекс: номер символа

Индекс – это номер места символа в строке. Нумерация начинается с нуля, как и везде в Python: у строки 'Привет' буква П стоит на позиции 0, а т – на позиции 5. Обращение записывается квадратными скобками: s[0], s[5].

Из нумерации с нуля следует важное: последний допустимый индекс равен len(s) - 1. Обращение по индексу len(s) – уже выход за границу, и программа останавливается с ошибкой IndexError: string index out of range. Читается она просто: попросили позицию, которой в строке нет.

Считать от конца удобнее особой записью:

Отрицательный индекс отсчитывает позицию с конца строки: s[-1] – последний символ, s[-2] – предпоследний, s[-len(s)] – первый.

Нового здесь, по сути, ничего: s[-k] – ровно то же место, что s[len(s) - k], просто записанное короче. Счёт с конца начинается с −1, потому что ноль уже занят первым символом, а «минус ноль» от него ничем не отличался бы. Границы те же: у строки длины 6 допустимы индексы от −6 до 5, а s[-7] – такой же IndexError, как s[6].

Символ	П	р	и	в	е	т
прямой индекс	0	1	2	3	4	5
с конца	−6	−5	−4	−3	−2	−1

s = 'Привет'
print(s[0])           # П – первый символ, индекс 0
print(s[5])           # т – последний, он же len(s) - 1
print(s[-1])          # т – то же самое, только короче
print(s[-2])          # е – предпоследний

print(s[6])           # IndexError: string index out of range
print(s[-7])          # IndexError: string index out of range

Срез: кусок строки одной записью

Срез s[start:stop] – новая строка из символов, начиная с позиции start включительно и до позиции stop не включая.

Правая граница в срез не входит – это главное, что придётся запомнить. Поначалу раздражает, но из такой договорённости следуют два свойства, которыми потом пользуются постоянно:

длина среза равна stop - start (когда обе границы внутри строки, а шаг единичный) – считать ничего не надо;
s[:i] + s[i:] при любом i даёт исходную строку – куски стыкуются без нахлёста и без дырки.

Второе свойство и объясняет, почему границу не включают: вторая половина начинается ровно там, где кончилась первая, и один и тот же символ не попадает в обе.

s = '2026-08-01'      # len(s) == 10

print(s[0:4])         # 2026 – символы 0, 1, 2, 3
print(s[5:7])         # 08 – символы 5 и 6
print(s[8:10])        # 01 – символы 8 и 9
# дефисы стоят на позициях 4 и 7 – ни в один срез они не попали
print(s[0:4] + s[4:]) # 2026-08-01 – куски стыкуются без нахлёста

Пропущенные границы и шаг

Любую границу можно не писать – тогда Python подставит край строки: s[:n] – от начала, s[n:] – до конца, s[:] – вся строка целиком. Дату это делает заметно короче: год s[:4], день s[8:].

Полная форма среза – s[start:stop:step].

Шаг step – через сколько позиций брать следующий символ. По умолчанию он равен 1, то есть символы берутся подряд.

Отсюда s[::2] – каждый второй символ начиная с нулевого, а s[1::2] – каждый второй начиная с первого. Шаг бывает и отрицательным: тогда обход идёт справа налево, а пропущенные границы подставляются наоборот. Так получается самая известная идиома Python: s[::-1] – строка задом наперёд. Правило про правую границу при этом не отменяется: s[5:0:-1] дойдёт до позиции 1 и остановится, потому что нулевой символ в границу не входит. Чтобы дойти до самого начала, границу опускают: s[5::-1].

И отдельно – важное отличие среза от индекса.

Срез никогда не падает из-за границ. Индексу нужно, чтобы символ существовал; срезу – нет, он просто берёт то, что попало в диапазон.

Поэтому s[100:200] у короткой строки – не IndexError, а пустая строка '', а s[:1000] – вся строка. Практическое следствие: если нужны «первые три символа строки, которая может оказаться и короче» – срез справится сам, проверять длину заранее не нужно.

s = '2026-08-01'
print(s[:4])       # 2026 – от начала
print(s[8:])       # 01 – до конца
print(s[:])        # 2026-08-01 – вся строка

t = 'Привет'
print(t[::2])      # Пие – каждый второй начиная с нулевого
print(t[1::2])     # рвт – каждый второй начиная с первого
print(t[1:5:2])    # рв – от 1 до 5 (не включая), через один

print(t[::-1])     # тевирП – вся строка задом наперёд
print(t[5::-1])    # тевирП – то же самое, границы записаны явно
print(t[5:0:-1])   # тевир – ловушка: позиция 0 не включается

# срез за границей строки – не ошибка, в отличие от индекса
print(t[100:200])  # '' – пустая строка
print(t[:1000])    # Привет – взял всё, что было
print(t[100])      # IndexError: string index out of range

Шпаргалка типовых срезов

Эти записи встречаются так часто, что их проще запомнить целиком, чем каждый раз выводить заново:

Запись	Что даёт	Пример при `s = 'Привет'`
`s[-1]`	последний символ	`'т'`
`s[:-1]`	всё, кроме последнего	`'Приве'`
`s[:3]`	первые три символа	`'При'`
`s[-3:]`	последние три символа	`'вет'`
`s[1:-1]`	без первого и последнего	`'риве'`
`s[1:4]`	от позиции 1 до 4, не включая 4	`'рив'`
`s[::2]`	каждый второй символ	`'Пие'`
`s[::-1]`	строка задом наперёд	`'тевирП'`

Строку изменить нельзя

Тип str – неизменяемый (immutable): у существующей строки нельзя заменить, вставить или удалить ни одного символа.

Попытка присвоить что-нибудь по индексу заканчивается сообщением TypeError: 'str' object does not support item assignment – «объект типа str не поддерживает присваивание по элементу». Читать s[0] можно, писать в s[0] – нельзя.

А ведь строки в программах меняются постоянно: к ним что-то дописывают, из них что-то вырезают. Как это уживается с запретом? Все такие операции создают новую строку, а имя переменной – всего лишь ярлык, который можно перевесить на другой объект. Запись s = s + '!' означает не «дописали восклицательный знак в конец s», а «собрали в памяти новую строку из старой и восклицательного знака и назвали её тем же именем s». Старая строка осталась ровно такой, какой была: если на неё указывало ещё одно имя, там ничего не изменилось.

Срез устроен так же: t = s[1:] не укорачивает s, а строит рядом новую строку. Отдельной операции «удалить символ из строки» в Python поэтому нет – её собирают из двух срезов: удалить символ на позиции i – это s[:i] + s[i+1:], а вставить перед позицией i – s[:i] + 'X' + s[i:].

Убедиться, что перед нами уже другой объект, помогает функция id() – она выдаёт номер, по которому объект лежит в памяти. Если после «изменения» номер стал другим, прежнего объекта перед нами нет.

Правило, которое стоит запомнить на всю оставшуюся работу со строками: не присвоил – потерял. Пока новая строка не записана в переменную, её никто не хранит.

s = 'привет'
s[0] = 'П'           # TypeError: 'str' object does not support item assignment

# «изменение» строки – это на самом деле новая строка
s = 'кот'
t = s                # второе имя для той же самой строки
s = s + '!'          # собрали новую строку и перевесили на неё имя s
print(s)             # кот!
print(t)             # кот – старая строка не пострадала

s = 'Привет'
# «удаление» символа на позиции 3 – склейка двух срезов
print(s[:3] + s[4:]) # Приет – буквы «в» больше нет
# «вставка» устроена так же
print(s[:3] + '!' + s[3:])  # При!вет

s = 'кот'
print(id(s))         # например, 2158751223856
s = s + '!'
print(id(s))         # другое число – перед нами другой объект

Зачем языку такой запрет

Неизменяемость – не придирка синтаксиса, а свойство, за которое платят удобством: строку можно спокойно отдавать куда угодно – раз значение нельзя изменить в принципе, ни один кусок программы не перепишет его так, чтобы это заметили остальные, и целого класса ошибок «кто-то поменял мои данные, а я и не знал» просто не существует; одинаковые строки можно не хранить дважды; а в качестве ключа словаря строка годится потому, что хеш такого значения достаточно посчитать один раз – он уже не устареет.

Обратная сторона у запрета тоже есть: каждая склейка создаёт новую строку, поэтому накопление результата в цикле – result = result + ch – каждый раз копирует всё уже накопленное заново. На слове из шести букв этого не заметит никто, а на строке в миллион символов разница станет ощутимой.

Коротко

Строка – упорядоченная последовательность символов; отдельного типа «символ» нет, s[0] – это строка длины 1.
Индексы нумеруются с нуля, последний равен len(s) - 1; s[-1] – тот же последний символ, названный с конца. Выход за границу – IndexError.
Срез s[start:stop:step] берёт start включительно, stop – не включая, а step задаёт, через сколько символов брать следующий (по умолчанию 1). Отсюда длина stop - start и склейка s[:i] + s[i:], равная исходной строке; любую границу можно опустить (s[:n], s[n:], s[:]), а отрицательный шаг разворачивает строку: s[::-1]. Срез не падает при выходе за границы – он вернёт меньше символов или пустую строку.
str неизменяем: s[0] = 'A' – это TypeError. Любое «изменение» собирает новую строку, а имя переменной лишь перевешивается на неё; срез тоже создаёт новую строку, а не укорачивает исходную.

Что нас ждёт в этом блоке

Читать строку мы теперь умеем: достать символ по индексу и вырезать кусок срезом. Дальше в блоке:

8.2. Методы строк: поиск, замена, разбиение – готовые операции над строкой целиком: find(), replace(), split(), смена регистра и проверки вроде isalpha(). Та самая join(), которой собирают длинные строки без копирования на каждом шаге, – тоже там;
8.3. Алгоритмические задачи со строками – перебор, подсчёт, поиск подстроки своими руками: что именно прячется за оператором in;
8.4. Файлы: чтение и запись – как прочитать текст из файла на диске и записать результат обратно;
8.5. Модули и библиотеки: import – как подключать чужие готовые функции;
8.6–8.7. Регулярные выражения – язык шаблонов для поиска по образцу: одна короткая запись вместо десятка условий;
Практикум блока – страница обязательных задач с автопроверкой. Именно он определяет, пройден блок или нет: самопроверки после уроков ничего не блокируют, а задачи практикума нужно решить.