Глава 3. Текст и работа со строками: очистка данных и вывод в отчёт

Задача главы: научиться приводить «грязные» текстовые данные из выгрузок — ФИО с лишними пробелами, разный регистр, опечатки, слитные поля — к единому стандарту, пригодному для объединения таблиц, и выводить результат ровной строкой отчёта средствами f-строк.

3.1 Текстовый тип `str` и базовая зачистка: `.strip()`, `.lower()`, `.upper()`, `.title()`

Зачем это нужно. Выгрузки из разных систем — LMS, гугл-формы, база данных — приносят один и тот же человек в трёх написаниях: 'Иванов ', 'иванов иван', 'ИВАНОВ'. Для Python это три разных значения, поэтому таблицы не склеятся, а в отчёте один ученик превратится в трёх.

// PYTHON_EXECUTOR (Pyodide Wasm)

raw_name = '   ИВАНОВ иван   '      # как пришло из выгрузки

# 1. Обрезка невидимого мусора по краям: пробелы, табуляции, переносы строк
trimmed_name = raw_name.strip()      # 'ИВАНОВ иван'

# 2. Нормализация регистра для сопоставления ключей
key_name = trimmed_name.lower()      # 'иванов иван' — таким видом сравнивают
code_name = trimmed_name.upper()     # 'ИВАНОВ ИВАН' — таким пишут коды и статусы

# 3. Красивый вид для отчёта
report_name = trimmed_name.title()   # 'Иванов Иван'

print(f'Ключ для сверки: {key_name} | В отчёт: {report_name}')

// Output:

Три родственных метода обрезки:

Метод	Что делает
`.strip()`	срезает пробелы с обеих сторон
`.lstrip()`	только слева (`left`)
`.rstrip()`	только справа (`right`) — им чистят «хвост» строк из CSV

Отдельно про регистр в именах:

// PYTHON_EXECUTOR (Pyodide Wasm)

double_surname = 'петрова-водкина анна'

print(double_surname.title())        # 'Петрова-Водкина Анна' — обе части фамилии с большой
print(double_surname.capitalize())   # 'Петрова-водкина анна' — большая только первая буква строки

// Output:

.title() поднимает регистр после каждого нецифробуквенного символа, поэтому двойные фамилии обрабатывает правильно. Но на аббревиатурах он ломается: 'МКОУ СОШ №1'.title() вернёт 'Мкоу Сош №1' — название школы в отчёте испортится.

⚠️ Подводный камень

Строки в Python неизменяемы (immutable). Метод не правит переменную на месте, а возвращает новую строку. Traceback не появится — ошибка тихая, в отчёт просто уйдут неочищенные данные.

// PYTHON_EXECUTOR (Pyodide Wasm)

raw_name = '   иванов иван   '

raw_name.strip()          # результат посчитан и выброшен
raw_name.title()          # и этот тоже

print(f'[{raw_name}]')    # [   иванов иван   ] — ничего не изменилось

// Output:

Ошибка	Что значит для Python	Человеческий перевод
— (тихая ошибка)	«Строка неизменяема, метод вернул новое значение»	Вызвали `.strip()`, но результат никуда не записали. Любой строковый метод нужно присваивать: `name = name.strip()`. Проверять результат удобно в квадратных скобках `[{name}]` — так видно границы строки и остатки пробелов.

Правильный паттерн

// PYTHON_EXECUTOR (Pyodide Wasm)

raw_name = '   ИВАНОВ иван   '

# Методы выстраиваются в цепочку: результат одного уходит на вход следующему
clean_name = raw_name.strip().title()     # 'Иванов Иван'

print(f'[{clean_name}]')                  # [Иванов Иван]

// Output:

Пояснение логики: цепочка .strip().title() читается слева направо — сначала обрезали края, потом привели регистр — и результат сохранён в новую переменную с говорящим именем. Исходный raw_name при этом цел: если очистка окажется неверной, всегда видно, что именно пришло из выгрузки.

⚠️ Одного .strip() мало: он чистит только края. Двойные пробелы внутри строки ('иванов иван') остаются — с ними разберёмся в разделе 3.4.

3.2 Поиск и замена: `.replace()`, `.find()` и оператор `in`

Зачем это нужно. В выгрузках предмет называют как попало: матеша, матем., Математика (проф). Плюс приходят комментарии проверяющих, в которых нужно найти ключевые слова — например, апелляция.

// PYTHON_EXECUTOR (Pyodide Wasm)

subject_raw = 'матеша (профиль)'
comment = 'Работа проверена, подана апелляция по заданию 13'

# 1. Проверка наличия подстроки — оператор in, результат bool
has_appeal = 'апелляция' in comment
print(f'Есть апелляция: {has_appeal}')          # True

# 2. Массовая замена — .replace(что_ищем, на_что_меняем)
subject_clean = subject_raw.replace('матеша', 'Математика')
print(subject_clean)                            # Математика (профиль)

# 3. Точечный поиск индекса — .find() возвращает номер первого символа совпадения
position = comment.find('апелляция')
print(f'Слово начинается с символа №{position}')   # 27

// Output:

Полезные детали:

.replace() меняет все вхождения сразу, а не первое: 'а-а-а'.replace('а', 'б') даст 'б-б-б'.
.rfind() ищет с конца — нужен, когда разделитель встречается несколько раз.
Замены можно ставить в цепочку: .replace('матеша', 'Математика').replace(' ', ' ').

⚠️ Подводный камень

.find() при отсутствии совпадения возвращает -1, а не False. А -1 для Python — истина (Truthy), потому что ноль — единственное «ложное» число. Условие срабатывает всегда.

// PYTHON_EXECUTOR (Pyodide Wasm)

comment = 'Работа проверена, замечаний нет'

if comment.find('апелляция'):        # .find() вернул -1
  print('Требуется разбор апелляции')   # напечатается, хотя апелляции нет!

// Output:

Требуется разбор апелляции

Ошибка	Что значит для Python	Человеческий перевод
— (тихая ошибка)	«`-1` — не ноль, значит условие истинно»	Использовали `.find()` как проверку «есть или нет». Для проверки наличия существует оператор `in`, он возвращает честный `bool`. `.find()` берите только тогда, когда нужен именно номер позиции, и сравнивайте его явно: `if position != -1:`.

Вторая ловушка того же семейства — регистр. .replace() и in ищут посимвольно, без всякой догадливости:

// PYTHON_EXECUTOR (Pyodide Wasm)

subject = 'Матеша (профиль)'
print(subject.replace('матеша', 'Математика'))   # Матеша (профиль) — замена не сработала

// Output:

Правильный паттерн

// PYTHON_EXECUTOR (Pyodide Wasm)

comment = 'Работа проверена, замечаний нет'
subject_raw = '  Матеша (профиль) '

# Наличие — через in
if 'апелляция' in comment:
  print('Требуется разбор апелляции')
else:
  print('Апелляций нет')

# Замена — сначала приводим регистр, потом ищем
subject_clean = subject_raw.strip().lower().replace('матеша', 'математика').title()
print(subject_clean)          # Математика (Профиль)

// Output:

Пояснение логики: in отвечает на вопрос «есть ли», .find() — на вопрос «где именно». Перед заменой строка приводится к нижнему регистру, поэтому один шаблон 'матеша' покрывает и Матеша, и МАТЕША. Красивый вид наводится последним шагом.

3.3 Индексация и срезы: извлечение частей текста `[start:stop:step]`

Зачем это нужно. Технические коды в выгрузках — это склеенные поля: '77-2024-001234' — регион, год, номер бланка. Срезы позволяют достать нужный фрагмент без ручного разбора, а также собрать инициалы из имени.

// PYTHON_EXECUTOR (Pyodide Wasm)

blank_code = '772024001234'

# Индексация: отдельный символ. Нумерация начинается с 0
first_char = blank_code[0]        # '7' — первый символ
last_char = blank_code[-1]        # '4' — последний, отрицательный индекс считает с конца

# Срезы: [start:stop] — от start включительно до stop НЕ включительно
region_code = blank_code[0:2]     # '77'   — символы 0 и 1
year = blank_code[2:6]            # '2024' — символы 2,3,4,5
number = blank_code[6:]           # '001234' — от 6-го до конца

print(f'Регион: {region_code} | Год: {year} | Номер: {number}')

// Output:

Границы можно опускать, а третий параметр задаёт шаг:

// PYTHON_EXECUTOR (Pyodide Wasm)

student_name = 'Иванов'

print(student_name[:3])     # 'Ива'   — с начала до 3-го
print(student_name[3:])     # 'нов'   — с 3-го до конца
print(student_name[::-1])   # 'вонавИ' — шаг -1, реверс строки
print(len(student_name))    # 6 — длина строки, пригодится для проверок

// Output:

⚠️ Обратите внимание: blank_code[2:6] берёт четыре символа, а не пять. Правая граница не включается — это то же правило, что и в range(), которое встретится в главе Циклы.

⚠️ Подводный камень

Строгая индексация падает с IndexError, если строка короче, чем вы ожидали. В выгрузке это норма: незаполненная ячейка приходит как пустая строка ''.

// PYTHON_EXECUTOR (Pyodide Wasm)

student_name = ''                 # ячейка «Имя» в выгрузке пустая
initial = student_name[0]         # хотим первую букву для инициала

// Output:

Traceback (most recent call last):
  File "report.py", line 2, in <module>
    initial = student_name[0]
IndexError: string index out of range

Ошибка	Что значит для Python	Человеческий перевод
`IndexError`	«Запрошенный индекс за пределами длины строки»	Обратились к символу, которого нет: строка пустая или короче ожидаемого. В строке из 6 символов последний индекс — `5`, а не `6`. Проверяйте `len()` перед строгим индексом либо используйте срез.

Правильный паттерн

Срез, в отличие от индекса, не падает — на короткой строке он просто вернёт то, что есть, а на пустой — пустую строку.

// PYTHON_EXECUTOR (Pyodide Wasm)

student_name = ''

initial = student_name[:1]        # '' — вместо IndexError
print(f'Инициал: [{initial}]')    # Инициал: []

# Если дальше нужен именно строгий индекс — проверяем длину
blank_code = '7720'
if len(blank_code) >= 6:
  year = blank_code[2:6]
else:
  year = 'не указан'

print(f'Год: {year}')             # Год: не указан

// Output:

Пояснение логики: text[:1] — «безопасный первый символ»: результат либо буква, либо пустая строка, но программа продолжает работать. Там, где короткие данные нужно поймать и отметить в отчёте, ставится проверка len(). Полноценная защита кривых данных — в главе Ошибки и исключения.

3.4 Разбиение и сборка: `.split()` и `.join()`

Зачем это нужно. ФИО в выгрузке чаще всего лежит в одной колонке — 'Иванов Иван Иванович' — а для отчёта нужны отдельные поля «Фамилия», «Имя», «Отчество». Обратная задача — собрать из них короткую подпись 'Иванов И. И.'.

// PYTHON_EXECUTOR (Pyodide Wasm)

full_name = 'Иванов Иван Иванович'

# .split() без аргументов — разбить по пробелам, получить список
name_parts = full_name.split()
print(name_parts)          # ['Иванов', 'Иван', 'Иванович']

surname = name_parts[0]
first_name = name_parts[1]
patronymic = name_parts[2]

# .join() — собрать список обратно в строку через разделитель
print(' | '.join(name_parts))     # Иванов | Иван | Иванович

// Output:

Разделитель задаётся явно — так вручную разбирают строку CSV:

// PYTHON_EXECUTOR (Pyodide Wasm)

csv_row = 'Иванов Иван;11А;87;сдал'

row_values = csv_row.split(';')
print(row_values)          # ['Иванов Иван', '11А', '87', 'сдал']
print(row_values[2])       # '87' — внимание, это строка, для расчётов нужен int()

// Output:

⚠️ Синтаксис .join() поначалу выглядит вывернутым: метод вызывается у разделителя, а список передаётся аргументом. Читайте так: «склей элементы, поставив между ними вот это».

⚠️ Подводный камень

.split() без аргументов сам справляется с любым количеством пробелов. А вот .split(' ') с явным пробелом честно режет по каждому — и из двойного пробела рождается пустой элемент ''.

// PYTHON_EXECUTOR (Pyodide Wasm)

raw_name = 'иванов   иван  петрович'      # из выгрузки, с двойными пробелами

parts = raw_name.split(' ')
print(parts)         # ['иванов', '', '', 'иван', '', 'петрович']
print(len(parts))    # 6 — вместо ожидаемых 3

print(parts[1])      # '' — вместо 'иван'

// Output:

Ошибка	Что значит для Python	Человеческий перевод
— (тихая ошибка)	«Режу строго по каждому символу-разделителю»	Указали `.split(' ')` там, где нужен `.split()`. Пустые элементы съезжают по индексам, и вместо имени в отчёт попадает пустота. Для ФИО и любого текста с пробелами вызывайте `.split()` без аргументов.

Вторая ловушка — распаковка списка в переменные. Если в ФИО нет отчества, строк в списке окажется меньше, чем переменных слева:

// PYTHON_EXECUTOR (Pyodide Wasm)

full_name = 'Иванов Иван'                          # отчества нет
surname, first_name, patronymic = full_name.split()

// Output:

Traceback (most recent call last):
  File "report.py", line 2, in <module>
    surname, first_name, patronymic = full_name.split()
ValueError: not enough values to unpack (expected 3, got 2)

Ошибка	Что значит для Python	Человеческий перевод
`ValueError`	«Слева три переменные, справа два значения»	Распаковка требует точного совпадения количества. В реальной выгрузке отчество есть не у всех — либо обращайтесь по индексам с проверкой `len(parts)`, либо распаковывайте только гарантированные поля.

Правильный паттерн

// PYTHON_EXECUTOR (Pyodide Wasm)

raw_name = '  иванов   иван  петрович '

# .split() без аргументов: обрезка краёв и склейка пробелов идут бонусом
name_parts = raw_name.split()
print(name_parts)              # ['иванов', 'иван', 'петрович']
print(len(name_parts))         # 3 — как и ожидалось

# Обратная сборка: нормализованное ФИО одной строкой
clean_full_name = ' '.join(name_parts).title()
print(clean_full_name)         # Иванов Иван Петрович

// Output:

Пояснение логики: .split() без аргументов — универсальный инструмент для текста, набранного людьми: он игнорирует и краевые пробелы, и двойные, и табуляции. Связка ' '.join(text.split()) — готовый рецепт «нормализовать пробелы внутри строки», который решает проблему, оставшуюся из раздела 3.1. Явный разделитель .split(';') уместен только там, где формат строгий — например, в CSV.

3.5 Форматирование в отчётах: спецификаторы f-строк

Зачем это нужно. Очищенный текст — это полдела: его ещё надо поставить в строку отчёта так, чтобы колонки не разъезжались, а средний балл не печатался как 27.666666666666668. За это отвечает вторая половина f-строки — то, что пишется после двоеточия: {value:спецификатор}.

// PYTHON_EXECUTOR (Pyodide Wasm)

student_name = 'Иванов И. П.'
average_score = 87.6666
pass_share = 0.8712

# Точность для чисел: .2f — две цифры после запятой, .0f — целое
print(f'Средний балл: {average_score:.2f}')     # Средний балл: 87.67

# Проценты: .1% сам умножает на 100 и дописывает знак
print(f'Доля сдавших: {pass_share:.1%}')        # Доля сдавших: 87.1%

# Выравнивание: < влево, > вправо, ^ по центру, число — ширина поля
print(f'[{student_name:<20}]')                  # [Иванов И. П.        ] — 8 пробелов до ширины 20
print(f'[{average_score:>8.2f}]')               # [   87.67]

// Output:

Базовый синтаксис f-строк разбирался в главе Переменные и ввод данных (раздел 1.2), а :.2f уже выручал при округлении в разделе 2.2 главы Числа и вычисления. Здесь собираем всё вместе — ради главной задачи аналитика — ровной таблицы в консоли:

// PYTHON_EXECUTOR (Pyodide Wasm)

report_rows = [
  ('Иванов Иван Петрович', 87.5, 'сдал'),
  ('Ким Ю', 62.0, 'сдал'),
  ('Петрова-Водкина Анна', 41.25, 'не сдал'),
]

# Заголовок и строки печатаются одним и тем же шаблоном ширин
print(f'{"ФИО":<24}{"Балл":>6}  {"Статус":<8}')

for full_name, score, status in report_rows:
  print(f'{full_name:<24}{score:>6.1f}  {status:<8}')

// Output:

ФИО                       Балл  Статус
Иванов Иван Петрович      87.5  сдал
Ким Ю                     62.0  сдал
Петрова-Водкина Анна      41.2  не сдал

Спецификатор	Что делает	Где нужен
`:.2f`	фиксированная точность	средний балл, прирост
`:.1%`	доля → проценты со знаком	конверсия, доля сдавших
`:<20`	текст влево, добить пробелами до 20	колонка ФИО
`:>6`	значение вправо	числовые колонки
`:^10`	по центру	заголовки
`:,`	разделитель тысяч (`1,250`)	количество работ

⚠️ Подводный камень

Числовой спецификатор нельзя применять к строке. Из выгрузки балл приходит текстом ('87.5' — это str, помним из раздела 3.4), и :.1f на нём падает.

// PYTHON_EXECUTOR (Pyodide Wasm)

score_from_csv = '87.5'          # значение прочитано из выгрузки — это строка

print(f'Средний балл: {score_from_csv:.1f}')

// Output:

Traceback (most recent call last):
  File "report.py", line 3, in <module>
    print(f'Средний балл: {score_from_csv:.1f}')
ValueError: Unknown format code 'f' for object of type 'str'

Ошибка	Что значит для Python	Человеческий перевод
`ValueError`	«Код формата `f` не подходит объекту типа `str`»	Форматируете как число то, что осталось строкой после чтения выгрузки. Приведите тип до вывода: `float(score_from_csv)`. Спецификаторы `.f`, `.%`, `,` работают только с `int` и `float`; строке доступно лишь выравнивание `:<`, `:>`, `:^`.

Вторая ловушка — тихая: ширина поля не обрезает длинное значение. Если ФИО длиннее выделенных 24 символов, строка просто раздвинет колонку, и таблица поедет.

// PYTHON_EXECUTOR (Pyodide Wasm)

full_name = 'Константинопольский Константин Константинович'

print(f'{full_name:<24}{87.5:>6.1f}')   # колонка «Балл» уехала вправо

// Output:

Правильный паттерн

// PYTHON_EXECUTOR (Pyodide Wasm)

score_from_csv = '87.5'
full_name = 'Константинопольский Константин Константинович'

# 1. Числа приводим к типу в момент чтения, а не в момент вывода
score = float(score_from_csv)

# 2. Длинный текст подрезаем срезом из раздела 3.3, и только потом выравниваем
name_cell = full_name[:22]

print(f'{name_cell:<24}{score:>6.1f}')

// Output:

Константинопольский Ко    87.5

Пояснение логики: приведение типа — задача слоя чтения данных, форматирование — задача слоя вывода; если смешать их, ValueError вылезет в самой последней строке скрипта, когда все расчёты уже сделаны. А связка «срез плюс выравнивание» (name[:22] и :<24) гарантирует, что ширина колонки известна заранее: два пробела зазора остаются даже у самой длинной фамилии.

3.6 Мини-словарик ошибок третьей главы

Ошибка	Что значит для Python	Человеческий перевод
`IndexError`	«Индекс за пределами длины строки»	Взяли `text[0]` у пустой ячейки выгрузки. Используйте безопасный срез `text[:1]` или проверку `len()`.
`AttributeError`	«У объекта `int` / `None` нет метода `lower`»	Вызвали строковый метод у числа или пустого значения из выгрузки. Приведите к строке: `str(value).lower()`.
`TypeError`	«`join` ждал `str`, получил `int`»	Передали в `.join()` список с числами. Элементы нужно заранее превратить в строки.
`ValueError`	«Слева три переменные, справа два значения»	Распаковали `.split()` в фиксированное число переменных, а отчества в ФИО не оказалось.
`ValueError`	«Код формата `f` не подходит объекту типа `str`»	Применили `:.1f` к значению, которое после чтения выгрузки осталось строкой. Приведите к `float()` до вывода.
— (тихая ошибка)	«Строка неизменяема, метод вернул новое значение»	Написали `text.strip()` вместо `text = text.strip()` — очистка не сохранилась.
— (тихая ошибка)	«`-1` — не ноль, значит условие истинно»	Проверили наличие подстроки через `.find()`. Для проверки нужен `in`.
— (тихая ошибка)	«Режу по каждому пробелу»	`.split(' ')` вместо `.split()` — в списке появились пустые элементы `''`.
— (тихая ошибка)	«Ширина поля — минимум, а не максимум»	Значение длиннее `:<24` раздвинуло колонку, и таблица отчёта поехала. Подрезайте срезом до вывода.

Самый частый случай целиком — AttributeError. Он ловит момент, когда в текстовой колонке внезапно оказалось число: например, класс записан как 11 без литеры.

// PYTHON_EXECUTOR (Pyodide Wasm)

student_class = 11              # в выгрузке колонка «Класс» оказалась числовой
print(student_class.lower())

// Output:

Traceback (most recent call last):
  File "report.py", line 2, in <module>
    print(student_class.lower())
AttributeError: 'int' object has no attribute 'lower'

Лечится приведением типа в момент чтения данных — тем же приёмом, что и int(input()) из главы 1, только в обратную сторону:

// PYTHON_EXECUTOR (Pyodide Wasm)

student_class = 11
print(str(student_class).lower())     # 11

// Output:

Мини-кейс: нормализатор ФИО и генератор краткого отчёта

Задача: принять «грязную» строку ФИО от преподавателя и технический код записи, очистить их, сформировать корректную подпись «Иванов И. П.» и извлечь из кода год, класс и регион.

// PYTHON_EXECUTOR (Pyodide Wasm)

# 1. Сбор данных
raw_fio = input('ФИО ученика: ')          # '  иванов   иван  петрович  '
raw_code = input('Код записи: ')          # ' grp-2024-11а-77 '

# 2. Обработка текста
# 2.1 ФИО: разбор на части и сборка инициалов
name_parts = raw_fio.split()              # ['иванов', 'иван', 'петрович']

surname = name_parts[0].title()                  # 'Иванов'
name_initial = name_parts[1][:1].upper()         # 'И' — безопасный срез вместо [0]
patronymic_initial = name_parts[2][:1].upper()   # 'П'

short_fio = f'{surname} {name_initial}. {patronymic_initial}.'
full_fio = ' '.join(name_parts).title()          # 'Иванов Иван Петрович'
sort_key = ' '.join(name_parts).lower()          # ключ для сверки с другой выгрузкой

# 2.2 Код записи: очистка и разбор по разделителю
clean_code = raw_code.strip().upper()            # 'GRP-2024-11А-77'
code_parts = clean_code.split('-')               # ['GRP', '2024', '11А', '77']

year = code_parts[1]
student_class = code_parts[2]
region_code = code_parts[3]

# 3. Вывод итогового отчёта
print('--- КАРТОЧКА УЧЕНИКА ---')
print(f'Полное ФИО: {full_fio}')
print(f'Подпись в ведомость: {short_fio}')
print(f'Ключ для сверки: {sort_key}')
print(f'Код записи: {clean_code}')
print(f'Год: {year} | Класс: {student_class} | Регион: {region_code}')

// Output:

Пример работы при вводе иванов иван петрович и grp-2024-11а-77:

--- КАРТОЧКА УЧЕНИКА ---
Полное ФИО: Иванов Иван Петрович
Подпись в ведомость: Иванов И. П.
Ключ для сверки: иванов иван петрович
Код записи: GRP-2024-11А-77
Год: 2024 | Класс: 11А | Регион: 77

Что получилось: одна строка ввода дала три представления одних данных, и каждое решает свою задачу — full_fio для печати, short_fio для ведомости, sort_key для сопоставления с другой выгрузкой. Пробелы нормализованы связкой ' '.join(raw_fio.split()), а не одним .strip(), поэтому двойные пробелы внутри строки не помешали разбору. Инициалы взяты безопасным срезом [:1], а не индексом [0]: на пустой части ФИО скрипт не упадёт с IndexError.

⚠️ Одна дыра осталась: если преподаватель введёт ФИО без отчества, name_parts[2] даст IndexError. Проверка if len(name_parts) == 3: закроет её — оператор if разбирается в главе Условия.

Чек-лист главы

Дальше: Списки

Глава 3. Текст и работа со строками: очистка данных и вывод в отчёт

3.1 Текстовый тип str и базовая зачистка: .strip(), .lower(), .upper(), .title()

⚠️ Подводный камень

Правильный паттерн

3.2 Поиск и замена: .replace(), .find() и оператор in

⚠️ Подводный камень

Правильный паттерн

3.3 Индексация и срезы: извлечение частей текста [start:stop:step]

⚠️ Подводный камень

Правильный паттерн

3.4 Разбиение и сборка: .split() и .join()

⚠️ Подводный камень

Правильный паттерн

3.5 Форматирование в отчётах: спецификаторы f-строк

⚠️ Подводный камень

Правильный паттерн

3.6 Мини-словарик ошибок третьей главы

Мини-кейс: нормализатор ФИО и генератор краткого отчёта

Чек-лист главы

3.1 Текстовый тип `str` и базовая зачистка: `.strip()`, `.lower()`, `.upper()`, `.title()`

3.2 Поиск и замена: `.replace()`, `.find()` и оператор `in`

3.3 Индексация и срезы: извлечение частей текста `[start:stop:step]`

3.4 Разбиение и сборка: `.split()` и `.join()`