Методы строк: поиск, замена, разбиение – Учебник

8.2

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

Из школьного журнала пришла строка ' Иванов;9А;5 '. Нужно убрать лишние пробелы по краям, выяснить, есть ли внутри точка с запятой, найти, на какой позиции она стоит, и разрезать строку на три поля: фамилию, класс и оценку.

Циклом из урока 8.1 это решается: пройти по символам, накопить куски до разделителя, хвост забрать отдельно. Работает – но ровно этот же перебор приходится писать заново для каждой следующей задачи. А у строки почти на каждый вопрос уже есть готовая операция, и вызывается она одной короткой записью через точку.

В этом уроке: как записывается вызов метода и почему он никогда не меняет исходную строку; склейка +, повтор * и проверка вхождения in; find() и rfind() – на какой позиции стоит кусок; count() – сколько раз он встретился; replace() – как заменить одно на другое; upper(), lower() и strip() – как привести строку к одному виду и снять невидимый мусор по краям; методы-вопросы вроде isdigit(); split() и join() – разрезать строку по разделителю и собрать обратно; f-строки – как подставить значение прямо в текст.

Метод: запись через точку

Действие до сих пор записывалось одинаково: имя, скобки, значение внутри – len(s), ord(c), int(x). У строки для её собственных действий есть другая запись: s.upper() – сначала строка, потом точка, потом название действия.

Метод – это действие, которое вызывают у конкретного значения, приписывая его имя через точку. s.find('@') читается «у строки s найди собаку».

Вызвать метод можно и прямо у строки, не заводя переменную: 'информатика'.count('а') – законная запись.

Зачем вторая форма, если есть len() и ord(). Разница в том, чьё это действие. len() умеет измерять что угодно – строку, список, файл, – поэтому стоит особняком. А поиск подстроки, смена регистра или разрезание – работа именно со строкой, и она «принадлежит» строке. Практическая выгода: набрав s., вы увидите в редакторе список всего, что строка умеет, – помнить наизусть ничего не нужно.

И главное правило всего урока. Строка неизменяема (урок 8.1), поэтому ни один метод строки её не трогает. Метод либо отвечает на вопрос – числом, строкой или True/False – либо строит рядом новую строку. Запись s = s.replace('а', 'о') означает «собрали новую строку и перевесили на неё имя s», а не «поправили строку на месте».

Отсюда ошибка, которая встретится в уроке ещё не раз: s.upper() без присваивания не делает ничего видимого – результат посчитан и выброшен. Не присвоил – потерял.

Склейка, повтор и оператор `in`

a + b склеивает две строки в одну (конкатенация), s * n повторяет строку n раз подряд (дублирование). Обе операции знакомы с урока 1.8, и обе после разговора о неизменяемости видны в новом свете: они создают новую строку, а исходные остаются нетронутыми.

Что здесь стоит помнить:

строка складывается только со строкой: 'возраст: ' + 16 останавливает программу с TypeError. Число превращают в текст функцией str(): 'возраст: ' + str(16);
длины предсказуемы: len(a + b) равно len(a) + len(b), а len(s * n) – это len(s) * n. Символы никуда не деваются;
s + '' – та же строка: пустая строка ничего не меняет. А s * 0 и s * -3 дают пустую строку, и это не ошибка – проверять знак заранее не нужно;
ширину удобно брать из самой строки: '=' * len(title) – линия ровно по длине заголовка, какой бы он ни был.

Оператор in отвечает, есть ли внутри строки такой кусок:

Подстрока – любой непрерывный кусок строки. sub in s истинно, если sub встречается внутри s хотя бы один раз; парный not in даёт обратный ответ.

Результат – True или False, поэтому in ставят прямо в условие if. Три вещи, о которые спотыкаются:

регистр важен. 'кот' in 'Кот учёный' – ложь: К и к – разные символы с разными кодовыми точками (урок 7.3). Как это вылечить, разберём ниже в этом же уроке;
пустая строка входит в любую, даже в пустую: '' in s – всегда истина. Так выходит из определения: пустой кусок есть в любом месте любой строки;
один символ – частный случай. '@' in email – та же операция, просто подстрока длины 1.

Отдельно – про то же слово в другом месте. В заголовке цикла (for ch in text) in ничего не проверяет: там оно часть синтаксиса for и означает «перебирай по одному».

Сравнение == тоже идёт посимвольно: строки равны, если совпадают длина и все символы по порядку. 'Кот' и 'кот' не равны, 'кот ' и 'кот' – тоже: пробел такой же символ, как любой другой. Знаки < и > сравнивают строки по кодовым точкам до первого расхождения, а если одна строка – начало другой, короткая считается меньшей: 'кот' < 'котёнок'. Отсюда и порядок по алфавиту: 'а' < 'б'. И отсюда же неожиданное 'Я' < 'а' – заглавные кириллические буквы стоят в таблице раньше строчных.

a = 'Аня'
b = 'Иванова'

print(len(a + b), len(a) + len(b))  # 10 10 – символы не деваются
print(a + '')                       # Аня – пустая строка не меняет

print('ab' * 0)                     # пустая строка
print('ab' * -3)                    # тоже пустая – и не ошибка
print(len('ab' * 4))                # 8 – длина умножается

title = 'Методы строк'
print('=' * len(title))             # линия ровно по ширине

text = 'информатика'
print('фор' in text)                # True – буквы идут подряд
print('фока' in text)               # False – буквы есть, но не подряд
print('кот' in 'Кот учёный')        # False – регистр важен
print('' in text)                   # True – пустая входит в любую

print('кот' == 'кот')               # True
print('Кот' == 'кот')               # False – регистр
print('а' < 'б')                    # True – 1072 < 1073
print('Я' < 'а')                    # True – заглавные идут раньше
print('кот' < 'котёнок')            # True – короткая строка меньшая

`find()` и `rfind()`: где именно стоит кусок

s.find(sub) возвращает индекс первого символа первого вхождения подстроки sub. Если вхождения нет – возвращает -1. s.rfind(sub) ищет с правого конца и даёт позицию последнего вхождения; буква r – от английского right.

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

Ловушка, на которой спотыкаются все. Писать if s.find('@'): нельзя. Если собака стоит в самом начале строки, find() вернёт 0, а ноль – это ложь, и условие не сработает при том, что подстрока на месте. Сравнивать надо явно: if s.find('@') != -1:. А если нужен только ответ «есть или нет» – берите in и не зовите find() напрасно.

Второй параметр – откуда искать. s.find(sub, start) начинает просмотр с позиции start, а всё, что левее, пропускает. Позиция при этом возвращается в номерах исходной строки, а не отсчитывается заново от start.

rfind() нумерацию не переворачивает: позиция по-прежнему считается слева с нуля, метод лишь выбирает среди найденных мест самое правое. Нужен он там, где важен именно последний разделитель: расширение файла стоит после последней точки, имя файла в пути – после последнего слэша. При неудаче оба метода дают -1, а если вхождение в строке одно – ответы у них совпадают.

Найденную позицию почти всегда тут же подставляют в срез: s[:pos] – то, что до неё, s[pos + 1:] – то, что после (сам разделитель в срезы не входит). И одной строкой, чтобы не удивляться в чужом коде: у обоих методов есть парные index() и rindex(), которые вместо -1 аварийно останавливают программу.

`count()`: сколько раз встретилось

s.count(sub) возвращает число вхождений подстроки sub в строку s. Если не нашлось ничего, ответ – 0.

Главная тонкость – пересечения. Считаются только непересекающиеся вхождения, слева направо. В строке 'ААА' подстрока 'АА' на глаз встречается дважды – на позициях 0 и 1, – но count() вернёт 1: найдя кусок на позициях 0–1, он продолжает поиск с позиции 2, а не с 1. Правило простое: нашли – перепрыгнули через находку целиком.

Кому нужны перекрытия, тот собирает счёт сам: ищет все вхождения циклом через find() и сдвигает начало на один символ, а не на длину находки. Ровно этим занята трассировка ниже – и именно поэтому её итог совпадает с count(), а не с числом кусков, видимых глазом.

Курьёз, который прямо следует из определения подстроки: s.count('') даёт len(s) + 1 – пустая строка «стоит» в каждом промежутке между символами и по обоим краям. А ещё count(sub) > 0 – это то же самое, что sub in s; если нужен только ответ «да/нет», берите in, он не пересчитывает строку до конца.

text = 'информатика'

print(text.find('ма'))    # 5 – позиция первого символа куска
print(text.find('а'))     # 6 – первая «а», хотя в слове их две
print(text.find('кот'))   # -1 – такого куска здесь нет
print(text.find('а', 7))  # 10 – искали с 7, ответ в номерах строки

s = '@school.ru'
if s.find('@'):           # так нельзя: find вернул 0, а 0 – ложь
    print('собака есть')  # эта строка не выполнится!
if s.find('@') != -1:     # а так правильно
    print('собака есть')

email = 'ivanov@school.ru'
pos = email.find('@')
print(email[:pos])        # ivanov – всё, что до собаки
print(email[pos + 1:])    # school.ru – и всё, что после

name = 'отчёт.итог.docx'
print(name.find('.'))     # 5 – первая точка, из середины имени
print(name.rfind('.'))    # 10 – последняя, та самая
dot = name.rfind('.')
print(name[dot + 1:])     # docx – расширение
print('нет точки'.rfind('.'))   # -1 – как и у find

print(text.count('а'))    # 2
print(text.count('кот'))  # 0 – ноль это ответ, а не сбой
print('ААА'.count('АА'))  # 1, а не 2! Вхождения не пересекаются:
                          # нашли на 0–1 и продолжили с позиции 2
print('кот и кот и кот'.count('кот', 6))   # 2 – считаем с позиции 6

`replace()`: замена всех вхождений

s.replace(old, new) возвращает новую строку, в которой каждое вхождение old заменено на new. Сама s не меняется – и не может: строка неизменяема.

Самая частая ошибка урока. Строка s.replace('а', 'о') сама по себе не делает ничего видимого: результат посчитан и тут же выброшен, потому что его некуда было записать. Нужно s = s.replace('а', 'о') – или другое имя, если исходная строка ещё понадобится.

Ещё три свойства:

третий параметр – сколько заменять. s.replace(old, new, 1) заменит только первое вхождение; без него заменяются все;
замена на пустую строку – это удаление. s.replace(' ', '') выбрасывает из строки все пробелы; отдельного метода «удалить» для этого не нужно;
метод не знает про слова. Он работает с подстрокой, а не со смыслом: замена 'кот' на 'пёс' превратит «котлета» в «пёслета». Это не поломка, а прямое следствие определения подстроки – границы слов методу неизвестны.

Вызовы можно ставить цепочкой: s.replace('a', 'b').replace('c', 'd') – второй метод вызывается уже у результата первого. Исходная строка при этом тоже не меняется, а вот порядок замен становится важен, если они задевают одни и те же буквы.

s = 'привет'

s.replace('и', 'ы')       # результат посчитан и выброшен
print(s)                  # привет – строка не изменилась

s = s.replace('и', 'ы')   # вот теперь сохранили
print(s)                  # прывет

line = 'кот и кот и котлета'
print(line.count('кот'))                # 3
print(line.replace('кот', 'пёс'))       # пёс и пёс и пёслета
print(line.replace('кот', 'пёс', 1))    # пёс и кот и котлета

print('  1 2 3  '.replace(' ', ''))     # 123 – замена на пустую
                                        # строку это удаление
print('abc'.replace('a', 'b').replace('b', 'c'))  # ccc, а не cbc:
                                        # вторая замена работает
                                        # с результатом первой

Регистр и невидимый мусор по краям

Программа спрашивает столицу России и сравнивает ответ с эталоном 'Москва'. В ответ ввели москва – верно и по смыслу, и почти по буквам, а программа говорит «неверно»: 'м' и 'М' – разные символы с разными кодовыми точками, а пробел на конце делает строку длиннее эталона. Задача не в том, чтобы научить программу понимать смысл, а в том, чтобы привести обе строки к одному виду перед сравнением.

s.upper() возвращает новую строку со всеми заглавными буквами, s.lower() – со всеми строчными. Не-букв метод не трогает: цифры, пробелы и знаки препинания переезжают в результат как есть – регистра у них нет.

Что стоит знать про эту пару:

русские буквы работают наравне с латинскими, включая ё. Арифметика кодов из урока 7.2 (chr(ord(c) - 32)) на этой паре ломается: между ё и Ё в таблице 80 позиций, а не 32. Метод ничего не вычисляет – он смотрит в таблицу, где для каждой буквы прописана её пара, и исключения его не смущают;
главный приём урока – сравнивать после приведения. if answer.lower() == 'москва': – введённое приводим к нижнему регистру, а эталон сразу пишем строчными. Привести одну сторону и сравнить с 'Москва' – типичная ошибка: тогда не совпадёт вообще ничего, даже правильно набранный ответ. Тем же способом закрывается дыра в поиске: text.lower().count('кот') считает и 'Кот', и 'кот'. Позиции при этом не съезжают – lower() меняет буквы, а не их количество;
берут обычно lower(), а не upper(): разницы по сути нет, просто эталон строчными писать привычнее. Важно другое – не смешивать оба способа в одной программе.

Второй вид мусора невидим: это не только пробел, но и табуляция \t, и перевод строки \n. На экране их нет, а в строке они есть и сравнению мешают.

s.strip() возвращает новую строку без пробельных символов в начале и в конце. lstrip() срезает только слева, rstrip() – только справа.

середину метод не трогает. ' а б '.strip() даёт 'а б': два пробела внутри остались. Выбрасывать их – работа replace();
аргумент – это набор символов, а не подстрока. s.strip('.,!') срезает с краёв любые из перечисленных символов, в любом порядке и количестве, пока не встретит что-то другое. 'test.txt'.strip('.txt') даёт 'es': метод не искал кусок .txt, он грыз края, пока попадались символы ., t и x. Отрезать расширение по-честному – это rfind('.') и срез;
откуда мусор берётся. input() перевод строки не отдаёт, но случайно набранные пробелы остаются полностью. А при чтении данных из файла в конце каждой строки будет \n – там strip() станет обязательным ритуалом.

Итоговая связка урока: сначала strip(), потом lower(), и только потом сравнение.

s = 'Привет, Мир!'

print(s.upper())        # ПРИВЕТ, МИР!
print(s.lower())        # привет, мир!
print(s)                # Привет, Мир! – строка не изменилась

print('ёжик'.upper())         # ЁЖИК – метод знает про ё
print(chr(ord('ё') - 32))     # б – арифметика кодов здесь
                              # врёт: между ё и Ё 80 позиций

answer = 'МОСКВА'
if answer.lower() == 'москва':      # эталон сразу строчными
    print('верно')                  # верно

line = 'Кот и кот'
print(line.count('кот'))            # 1 – заглавная К не подошла
print(line.lower().count('кот'))    # 2 – вот теперь оба
print(line.lower().find('кот'))     # 0 – ищем в приведённой
                                    # строке, позиции прежние

t = '  Москва  '
print('[' + t.strip() + ']')        # [Москва]
print('[' + t.lstrip() + ']')       # [Москва  ] – только слева
print('[' + t.rstrip() + ']')       # [  Москва] – только справа
print('[' + '  а  б  '.strip() + ']')   # [а  б] – середина цела

print('test.txt'.strip('.txt'))     # es, а не test: набор
                                    # символов, а не кусок

print(' Москва '.strip().lower() == 'москва')   # True – вся связка

Методы-вопросы: `isdigit()`, `isalpha()` и остальные

Вторая группа методов ничего не строит – они отвечают True или False:

Метод	Отвечает `True`, если
`s.isdigit()`	все символы – цифры
`s.isalpha()`	все символы – буквы
`s.isalnum()`	все символы – буквы или цифры
`s.isspace()`	все символы – пробельные
`s.isupper()`	все буквы заглавные
`s.islower()`	все буквы строчные

Три вещи, из-за которых на них ошибаются:

вопрос задаётся про всю строку целиком, а не про первый символ. '123'.isdigit() – True, '12а'.isdigit() – False: одного чужого символа достаточно, чтобы ответ стал ложным. 'Привет!'.isalpha() – тоже False, из-за восклицательного знака, а 'Привет мир'.isalpha() – из-за пробела;
пустая строка даёт False у всех. Утверждать «все символы – цифры» не о чем, если символов нет. Практический вывод: проверку «человек вообще что-то ввёл» этими методами не заменить;
isdigit() – это про цифры, а не про числа. У '-5' есть минус, у '3.14' – точка, и обе строки дают False. Значит, такая проверка пропускает только неотрицательные целые; для остального её не хватит.

Зачем всё это нужно: int(x) на нечисловой строке аварийно останавливает программу, а if x.isdigit(): позволяет проверить заранее и вежливо попросить ввести число ещё раз.

И коротко про несколько методов: capitalize() делает заглавной первую букву, а все остальные – строчными ('пРИВЕТ' → 'Привет'); title() – с заглавной каждое слово, причём границей слова считает любой не-буквенный символ, поэтому 'мария-луиза' превращается в 'Мария-Луиза'; swapcase() меняет регистр на противоположный. Ни один из них не знает, что такое имя собственное или начало предложения: они работают с символами по таблице, а не со смыслом текста.

`split()`: разрезать по разделителю

s.split(sep) возвращает список кусков строки s, разрезанной по разделителю sep. Сам разделитель ни в один кусок не попадает.

Здесь появляется новый тип – список (list). Всерьёз им займёмся в блоке 9, а пока хватит трёх фактов, и все три уже знакомы по строкам: список печатается в квадратных скобках – ['2026', '08', '01']; к элементу обращаются по индексу с нуля (parts[0], работает и parts[-1]); длину даёт len(), а перебрать элементы можно циклом for – ровно как символы строки в уроке 8.1.

Главное правило блока никуда не делось: split() исходную строку не трогает, а строит результат рядом. Не присвоили – потеряли. И следствие, которое стоит запомнить сразу: частей всегда на одну больше, чем разделителей. Два дефиса в дате – три части.

Дальше главная развилка: split() без аргумента и split(sep) – это не одно и то же с умолчанием, а два разных поведения.

s.split(sep) – строгий. Режет по каждому вхождению sep и ничего не додумывает: два разделителя подряд дают между собой пустую строку, разделитель в начале или в конце – пустую строку с краю. Это не недоразумение: в таблице пустое поле – тоже значение, и терять его нельзя;
s.split() без аргумента – «человеческий». Разделителем считается любая цепочка пробельных символов (пробел, \t, \n), несколько подряд идут за один, а пробелы по краям отбрасываются. Пустых кусков в результате не бывает никогда. Это готовый инструмент «разбей предложение на слова», и для текста берут именно его.

Контрольный пример, который стоит увидеть глазами: у строки ' мама мыла раму ' вызов .split() даёт три слова, а .split(' ') – девять элементов, шесть из которых пустые.

Третий полезный факт: второй параметр s.split(sep, maxsplit) ограничивает число разрезов, а не число кусков, – весь остаток целиком уезжает в последний элемент. 'ivan@mail.ru'.split('@', 1) даёт логин и всё остальное, даже если правее встретится ещё одна собака.

Чего от split() ждать не надо: несколько разных разделителей за раз он не умеет – строку 'Иванов, Петров; Сидоров' сначала приводят к одному разделителю через replace(), и только потом режут. И пробелы вокруг частей split(sep) не убирает: 'Иванов; 9А'.split(';') даёт кусок ' 9А' вместе с пробелом, поэтому обычная связка – разрезали и к каждой части strip().

s = '2026-08-01'
parts = s.split('-')

print(parts)           # ['2026', '08', '01'] – список из трёх строк
print(parts[0])        # 2026 – первый элемент, индекс с нуля
print(parts[-1])       # 01 – последний, как и у строки
print(len(parts))      # 3 – столько частей получилось
print(s)               # 2026-08-01 – исходная не изменилась

row = '  Иванов;9А;5  '
print(row.strip().split(';'))   # ['Иванов', '9А', '5'] – задача
                                # из начала урока

dirty = '  мама  мыла   раму '
print(dirty.split())            # ['мама', 'мыла', 'раму']
print(len(dirty.split()))       # 3 – цепочка пробелов идёт
                                # за один разделитель
print(dirty.split(' '))         # ['', '', 'мама', '', 'мыла',
                                #  '', '', 'раму', '']
print(len(dirty.split(' ')))    # 9 – режет каждый пробел,
                                # шесть кусков пустые

print('a,,b'.split(','))        # ['a', '', 'b'] – между запятыми
                                # пустой кусок
print(';Иванов;'.split(';'))    # ['', 'Иванов', ''] – и по краям

print('ivan@mail.ru'.split('@', 1))   # ['ivan', 'mail.ru'] – один
                                      # разрез, остаток целиком
                                      # в последний кусок

`join()`: собрать обратно

Обратная операция.

sep.join(parts) возвращает новую строку: все элементы parts подряд, а между соседними – строка sep.

И сразу странность синтаксиса, на которой спотыкаются все: метод вызывается у разделителя, а список идёт в скобки. Пишут '-'.join(parts), а не parts.join('-'). Выглядит вывернуто, но логика есть: результат – строка, поэтому и метод принадлежит строке-разделителю, а главное решение (чем склеивать) принимает именно он. В скобках при этом может оказаться что угодно перебираемое – список сегодня, другие типы позже.

Второе правило, о которое спотыкаются не реже: все элементы должны быть строками. '-'.join(['a', 'b']) работает, а '-'.join([2026, 8, 1]) падает с TypeError: sequence item 0: expected str instance, int found – «ожидалась строка, получено целое». Числа перед сборкой приводят к строке через str().

Частные случаи, которые пригодятся: ' '.join(...) собирает слова в предложение; ''.join(...) склеивает вообще без разделителя – пустая строка тоже полноценный разделитель; если элемент один, разделитель не появится вообще, а пустой список даст пустую строку. Разделитель ставится между кусками, а не после каждого, – у трёх частей стыков всего два.

И наконец, почему длинную строку собирают join()-ом, а не склейкой в цикле. Каждая склейка result = result + ch строит новую строку и копирует в неё всё уже накопленное, поэтому в длинном цикле работа растёт как снежный ком. join() знает все куски заранее, считает нужный размер один раз и собирает результат за один проход. На слове из шести букв разницы не увидеть, на сотнях тысяч кусков она принципиальная – измерить её можно будет, когда появится язык для разговора о скорости. Правило простое: если строка собирается в цикле – собирайте её через join().

# 1. переставить дату: 2026-08-01 -> 01.08.2026
s = '2026-08-01'
p = s.split('-')
print('.'.join([p[2], p[1], p[0]]))   # 01.08.2026

# 2. слова предложения задом наперёд
text = 'мама мыла раму'
print(' '.join(text.split()[::-1]))   # раму мыла мама
                                      # срез с шагом -1 работает
                                      # и со списком: это тоже
                                      # последовательность

# 3. нормализация ввода: убрать лишние пробелы разом
dirty = '  мама  мыла   раму '
print(' '.join(dirty.split()))        # мама мыла раму

print('-'.join(['одно']))             # одно – разделителю
                                      # негде появиться
print('-'.join([2026, 8, 1]))
# TypeError: sequence item 0: expected str instance, int found
print('-'.join([str(2026), str(8), str(1)]))   # 2026-8-1 – вот так

f-строки: подставить значение прямо в текст

Заходим в тему через боль из урока 1.8: чтобы напечатать «Тебе 16 лет», приходилось писать 'Тебе ' + str(age) + ' лет' – не забыть str(), не потерять пробелы у краёв кусков, не запутаться в кавычках. Одно предложение так собрать можно, а строку отчёта из пяти значений – уже мучение.

f-строка – строка, перед кавычкой которой стоит буква f. Внутри неё в фигурных скобках {} можно написать выражение – при выполнении на его место подставится значение.

age = 16
print(f'Тебе {age} лет')        # Тебе 16 лет

a = 2
b = 3
print(f'{a} + {b} = {a + b}')   # 2 + 3 = 5 – в скобках выражение
print(f'{0.1 + 0.2}')          # 0.30000000000000004
print(f'{0.1 + 0.2:.2f}')      # 0.30 – два знака после запятой

Что это даёт: str() не нужен – число превратится в текст само; в скобках любое выражение, а не только имя переменной ({a + b}, {name.upper()}, {parts[0]}, {len(s)}); текст остаётся текстом – пробелы и знаки препинания видно там же, где они окажутся в выводе.

Отдельно про форматирование числа. После выражения можно поставить двоеточие и указать, как его печатать: {x:.2f} – вещественное с двумя знаками после запятой. Это ровно тот случай, ради которого стоит вспомнить про точность float: 0.1 + 0.2 печатается как 0.30000000000000004, а нужны нам обычно две цифры, а не все семнадцать.

Две ловушки. Забыли f – ошибки не будет, программа честно напечатает {age} фигурными скобками; симптом узнаваемый. И нужна сама фигурная скобка в тексте – её удваивают: {{ и }}. Оговорка про чужой код: старые способы форматирования ('%d' и метод .format()) в нём встречаются, и знать об их существовании полезно, – но писать сегодня надо f-строки.

Шпаргалка

Одна таблица на весь урок – каждая операция встречается здесь ровно один раз:

Операция	Что делает	Пример	Результат
`a + b`	склеивает две строки	`'Ива' + 'нов'`	`'Иванов'`
`s * n`	повторяет строку `n` раз	`'ab' * 3`	`'ababab'`
`sub in s`	отвечает, есть ли подстрока	`'фор' in 'информатика'`	`True`
`s == t`	сравнивает посимвольно	`'Кот' == 'кот'`	`False`
`s.find(sub)`	позиция первого вхождения	`'информатика'.find('ма')`	`5`
`s.rfind(sub)`	позиция последнего вхождения	`'отчёт.итог.docx'.rfind('.')`	`10`
`s.count(sub)`	число непересекающихся вхождений	`'ААА'.count('АА')`	`1`
`s.replace(a, b)`	заменяет все вхождения	`'кот и кот'.replace('кот', 'пёс')`	`'пёс и пёс'`
`s.replace(a, b, n)`	заменяет первые `n` вхождений	`'кот и кот'.replace('кот', 'пёс', 1)`	`'пёс и кот'`
`s.upper()` / `s.lower()`	приводит к одному регистру	`'Москва'.lower()`	`'москва'`
`s.strip()`	убирает пробельные по краям	`' да '.strip()`	`'да'`
`s.isdigit()`	все ли символы цифры	`'-5'.isdigit()`	`False`
`s.split(sep)`	режет по разделителю	`'Иванов;9А;5'.split(';')`	`['Иванов', '9А', '5']`
`s.split()`	режет текст на слова	`'мама мыла'.split()`	`['мама', 'мыла']`
`sep.join(parts)`	собирает строку из списка	`'-'.join(['2026', '08', '01'])`	`'2026-08-01'`
`f'{x}'`	подставляет значение в текст	`f'Тебе {age} лет'`	`'Тебе 16 лет'`

И одно правило, верное для каждой строки таблицы: ни одна из этих операций не меняет исходную строку. Любая возвращает новое значение – строку, число или True/False, – и если это строка, её надо куда-то присвоить, иначе она просто пропадёт.

Коротко

Метод вызывается у значения через точку: s.upper(), s.split(';'). И ни один метод строки не меняет саму строку – он либо отвечает на вопрос, либо строит новую. Не присвоил – потерял.
+ склеивает строки (только строка со строкой, иначе TypeError и str()), * повторяет, in отвечает «есть ли кусок», == сравнивает посимвольно, а < и > – по кодовым точкам, отсюда 'Я' < 'а'.
find() и rfind() дают позицию первого и последнего вхождения, а при неудаче -1, поэтому проверка всегда != -1. count() считает непересекающиеся вхождения: в 'ААА' кусок 'АА' находится один раз.
replace() заменяет все вхождения, третий параметр ограничивает их число, а замена на пустую строку – это удаление.
Приводить строки к одному виду перед сравнением: сначала strip() – снять невидимые пробелы и переводы строки по краям, потом lower() – и только потом ==. Методы-вопросы (isdigit(), isalpha()) спрашивают про всю строку, на пустой дают False, а минус и точку цифрами не считают.
split() режет строку по разделителю и возвращает список; частей всегда на одну больше, чем разделителей. Без аргумента он делит текст на слова и пустых кусков не оставляет, с аргументом – режет строго и пустые куски сохраняет.
join() вызывается у разделителя ('-'.join(parts)), элементы обязаны быть строками, а разделитель ставится между кусками. Собирать длинную строку в цикле склейкой не надо – для этого есть join(). А f-строка (f'Тебе {age} лет') подставляет значение выражения прямо в текст.

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

Метод: запись через точку

Склейка, повтор и оператор in

find() и rfind(): где именно стоит кусок

count(): сколько раз встретилось

replace(): замена всех вхождений