Строки

Программы постоянно работают с текстом: имя, слово, запись числа, строка из файла. В задачах ЕГЭ часто нужно найти в длинной строке символ, кусок или повтор. Python берёт из строки символ по номеру, кусок по срезу и строит из старой строки новую. Срезы устроены как range из прошлого урока: начало включено, граница нет.

Индексы и срезы покажем на строках "PYTHON" и "ABCDEFG", а потом соберём новую строку из символов старой.

У строки есть длина и элементы, пронумерованные с нуля. Порядок символов важен: "кот" и "ток" состоят из одинаковых букв, но являются разными строками.

word = "PYTHON"print(len(word))print(word[0])print(word[2])print(word[-1])

len получает количество элементов. Индекс — номер позиции. Положительные индексы начинаются с 0: это удобно понимать как число шагов от начала. Для строки длины n допустимы индексы от 0 до n - 1. Отрицательные индексы считают с конца: −1 — последний элемент, −2 — предпоследний.

Обращение к word[6] вызывает ошибку: такой позиции нет.

word = "PYTHON"print(word[6])

У пустой строки "" длина 0, поэтому в ней нет даже элемента с индексом 0. Отдельного встроенного типа «символ» в Python нет: word[0] тоже строка, просто длины 1.

Срез берёт элементы от начала до остановки, не включая её. Срез получает последовательность элементов по правилу s[start:stop:step]. Остановка не включается, как в range.

s = "ABCDEFG"print(s[1:4])print(s[:3])print(s[4:])print(s[::2])print(s[::-1])print(s[5:1:-1])

s[1:4] берёт индексы 1, 2, 3 — ровно как range(1, 4). Для положительного шага пропущенное начало означает начало строки, пропущенная остановка — её конец. Для отрицательного шага значения по умолчанию меняются: движение начинается с конца и идёт до начала. Поэтому s[::-1] разворачивает всю строку, а s[5:1:-1] идёт от индекса 5 вниз до 2.

Срез за пределами длины обрезается: s[:100] вернёт всю строку. Одиночный неверный индекс вызывает ошибку. Срез может быть пустым; это нормальный результат. Шаг 0 недопустим.

Проверь срезы сам. Песочница начинается с s[::2] — каждый второй символ. Поле start или stop можно оставить пустым, шаг — сделать отрицательным. Номер под буквой — очередь, в которой срез её берёт.

Строку нельзя изменить на месте — можно только построить новую. Неизменяемость означает, что нельзя заменить элемент внутри существующей строки:

s = "кот"s[0] = "р"

Можно построить новую строку и связать с ней имя:

s = "кот"s = "р" + s[1:]print(s)

+ соединяет строки. Это действие называют конкатенацией. "ab" * 3 повторяет текст и создаёт "ababab". Старая строка при этом не меняется: имя просто связывается с новой.

Новую строку собирают по символам: перебирают старую и добавляют нужные символы к накопителю. Строку нельзя изменить, но можно построить новую. Уберём из слова все буквы «а» — пройди программу по шагам и следи за result:

word = "банан"result = ""for ch in word:    if ch != "а":        result += chprint(result)

for ch in word берёт символы по одному, как в уроке о for. Накопитель-строка начинается с пустой строки "" — как сумма с 0, а result += ch дописывает символ в конец.

Когда нужны соседние символы, перебирают индексы. Посчитаем пары одинаковых соседних букв — такие задачи встречаются в ЕГЭ:

s = "AABBBC"count = 0for i in range(len(s) - 1):    if s[i] == s[i + 1]:        count += 1print(count)

У последнего символа соседа справа нет, поэтому индекс i идёт до len(s) - 2 включительно — это range(len(s) - 1). Пары AA, BB и ещё одна BB дают 3.

Метод — действие, которое вызывают у объекта через точку. Запись s.lower() означает «вызвать действие lower для строки s». Точка связывает действие с объектом, скобки запускают его.

Частые методы строки на примере s = "Banana" — выбери метод, чтобы увидеть результат:

lower / upper

s.lower() → 'banana'новая строка в нижнем регистре; s.upper() — в верхнем

strip

" Banana ".strip() → 'Banana'пробелы и переводы строки по краям; rstrip — только справа

replace

s.replace("a", "o") → 'Bonono'все вхождения; с третьим аргументом 1 — только первое

find

s.find("an") → 1индекс первого вхождения, −1 если нет

count

s.count("an") → 2неперекрывающиеся вхождения

startswith

s.startswith("Ba") → Trueendswith — проверка конца

zfill

"101".zfill(8) → '00000101'нули слева до длины 8

in

"nan" in s → Trueесть ли фрагмент внутри строки

Методы не меняют исходную строку. Вызов s.replace("a", "b") с проигнорированным результатом не обновляет s; для этого нужно присваивание.

s = "  Python  "clean = s.strip().lower()print(clean)print("th" in clean, clean.find("th"))print("101".zfill(8))

Сначала strip создаёт промежуточную строку без крайних пробелов; затем lower вызывается уже для неё. Это два последовательных действия. zfill удобен, когда запись числа нужно выровнять по длине, например двоичную запись до восьми знаков.

Не проверяй поиск как if s.find(part):: индекс 0 ложен, а отсутствие с индексом −1 истинно. Используй part in s или явное сравнение с −1.

count не считает перекрывающиеся вхождения. В "AAAA" фрагмент "AA" начинается на позициях 0, 1 и 2. Но "AAAA".count("AA") возвращает 2: после найденного совпадения поиск продолжится за ним.

Для подсчёта всех начал можно проверить каждую позицию:

s = "AAAA"part = "AA"count = 0for i in range(len(s) - len(part) + 1):    if s[i:i + len(part)] == part:        count += 1print(count, s.count(part))

Последнее допустимое начало — len(s) - len(part). Именно поэтому верхняя граница range на 1 больше. Если шаблон длиннее текста, диапазон пуст. С пустым шаблоном count ведёт себя неожиданно: "abc".count("") равно 4 — пустая строка «находится» перед каждым символом и в конце. Если шаблон может оказаться пустым, обработай этот случай отдельно.

Некоторые символы записывают через обратный слеш, а сами символы — это коды Unicode. \n внутри обычной строки означает перевод строки, \t — табуляцию, \\ — один обратный слеш. Чтобы увидеть представление со специальными символами, используй repr:

s = "A\nB"print(len(s))print(repr(s))print(ord("A"), chr(66))

Длина 3: A, перевод строки, B. Python хранит строки как Unicode-текст. ord("A") возвращает код символа, chr(66) — символ по коду. Обычная сортировка строк основана на кодах, а не на словарных правилах русского языка.