Строки в Python: методы split, replace, strip, join, срезы и f-строки

Строки в Python встречаются в любой программе: ввод пользователя, имена файлов, строки CSV, ответы API. Тип str хранит текст в Unicode, поэтому кириллица и эмодзи работают без настроек. Самые востребованные методы — split, replace, strip и join, а выводить значения удобнее всего f-строками. Разберём всё это на примерах.

Как устроена строка в Python

Строку записывают в одинарных или двойных кавычках — разницы нет: 'кофе' и "кофе" одинаковы. Тройные кавычки создают многострочную строку, в которой переносы сохраняются как есть.

name = "Кофе"
note = """Первая строка
Вторая строка"""
print(len(name))  # 4 — длина строки в символах

Главное свойство строк — неизменяемость. Метод не меняет строку, а возвращает новую. Поэтому s.replace("a", "b") без присваивания ничего не даст — нужно писать s = s.replace("a", "b"). Это самая частая ошибка новичков.

Спецсимволы, перенос строки и сырые строки

Перевод строки обозначается \n, табуляция — \t, обратный слеш — \\. Префикс r делает строку «сырой»: обратные слеши в ней не обрабатываются. Это удобно для путей Windows и регулярных выражений.

print("Итого:\n350 ₽")
path = r"C:\new\table.csv"   # \n и \t не превратятся в спецсимволы

Длинное выражение можно перенести на следующую строку кода, заключив его в скобки: соседние строковые литералы в скобках Python склеит сам.

split: разбить строку на список

Метод split() делит строку по разделителю и возвращает список. Без аргумента он режет по любым пробельным символам и игнорирует повторяющиеся пробелы — это удобно для разбора команд.

"add  Кофе 250".split()        # ['add', 'Кофе', '250']
"2026-10-16".split("-")        # ['2026', '10', '16']
"a,b,,c".split(",")            # ['a', 'b', '', 'c']
"key=value=x".split("=", 1)    # ['key', 'value=x']

Обратите внимание на разницу: с явным разделителем пустые фрагменты сохраняются. Второй аргумент maxsplit ограничивает число разрезов, а rsplit() режет справа. Чтобы разбить текст на строки, используйте splitlines(): он понимает и \n, и \r\n и не оставляет пустого элемента в конце.

text = "кофе\nтакси\n"
text.split("\n")     # ['кофе', 'такси', '']
text.splitlines()    # ['кофе', 'такси']

join: склеить список в строку

join() — обратная операция. Вызывается он у строки-разделителя, а аргументом получает список строк:

items = ["кофе", "такси", "обед"]
print(", ".join(items))   # кофе, такси, обед
print("\n".join(items))   # каждый пункт с новой строки

Все элементы должны быть строками, иначе получите TypeError: sequence item 0: expected str instance, int found. Числа сначала преобразуйте: ", ".join(str(x) for x in amounts).

Конкатенация и объединение строк

Сложить две строки можно через +, повторить — через *: "-" * 20. Но склеивать сотни фрагментов в цикле через += медленно, потому что каждый раз создаётся новая строка. Соберите части в список и объедините одним join(). Сложить строку с числом напрямую нельзя: "Итого: " + 5 вызовет TypeError, нужна функция str() или f-строка.

replace: замена подстроки

replace(old, new) заменяет все вхождения подстроки. Третий аргумент ограничивает количество замен.

price = "1 250,50"
price = price.replace(" ", "").replace(",", ".")
print(float(price))                  # 1250.5

"а-б-в".replace("-", "+", 1)         # 'а+б-в'

Метод чувствителен к регистру и ищет точное совпадение. Для замен по шаблону (например, «все цифры») нужен модуль re и функция re.sub().

strip, lstrip, rstrip: обрезать строку

strip() убирает пробелы, табуляции и переносы строки с обоих краёв. lstrip() чистит только слева, rstrip() — только справа. Это первое, что стоит сделать с вводом пользователя и строками из файла.

raw = "  Кофе \n"
raw.strip()       # 'Кофе'
raw.rstrip()      # '  Кофе'
"xxКофеxx".strip("x")   # 'Кофе'

Аргумент задаёт набор символов, а не подстроку: "abcТекстcba".strip("abc") уберёт все a, b и c с краёв в любом порядке. Чтобы отрезать именно префикс или суффикс, используйте removeprefix() и removesuffix() (с Python 3.9).

Другие полезные методы строк

Проверить, содержит ли строка подстроку, проще всего оператором in: if "кофе" in text.lower():. Строки сравниваются через == посимвольно и с учётом регистра; для сравнения без регистра приведите обе к casefold().

Срезы строк

Строка — последовательность, поэтому к символам можно обращаться по индексу с нуля, а отрицательный индекс считает с конца. Срез s[start:stop:step] возвращает подстроку; правая граница не включается.

s = "Python"
s[0]      # 'P'
s[-1]     # 'n'
s[0:3]    # 'Pyt'
s[2:]     # 'thon'
s[::2]    # 'Pto'
s[::-1]   # 'nohtyP' — перевернуть строку

Срез никогда не вызывает ошибку при выходе за границы: s[0:100] вернёт всю строку. А вот s[100] даст IndexError. Изменить символ по индексу нельзя (s[0] = "J" — TypeError), нужно собрать новую строку: "J" + s[1:].

f-строки в Python

Буква f перед строкой означает, что выражения в фигурных скобках будут вычислены и подставлены в текст. Это основной способ форматирования строк с Python 3.6: короче format() и быстрее старого оператора %.

item = "Кофе"
price = 250
print(f"{item}: {price} ₽")              # Кофе: 250 ₽
print(f"Со скидкой: {price * 0.9} ₽")    # Со скидкой: 225.0 ₽
print(f"{item=}")                         # item='Кофе' — удобно для отладки

Форматирование чисел и выравнивание

После двоеточия внутри скобок пишется спецификатор формата. Он задаёт округление, разделители разрядов, ширину и выравнивание:

Выравнивание удобно для таблиц в терминале: f"{name:<12}{amount:>10.2f}" выстроит колонки ровно. Учтите, что форматирование нужно только при выводе. Деньги храните в копейках (int) или в Decimal, а не во float: 0.1 + 0.2 даёт 0.30000000000000004.

Кавычки и перенос строки внутри f-строки

С Python 3.12 (PEP 701) у f-строк появилась формальная грамматика: внутри фигурных скобок можно использовать те же кавычки, что и снаружи, обратные слеши и переносы, а вложенность больше не ограничена. Ошибки внутри скобок теперь показывают точную позицию. На старых версиях пишите внутри другой тип кавычек: f"{d['key']}", а перенос — через отдельную переменную или chr(10).

Для многострочного текста подходит f-строка в тройных кавычках: f"""Итого: {total}\nПозиций: {count}""".

format() и %: старые способы

В чужом коде встретятся "{}: {}".format(item, price) и "%s: %d" % (item, price). Спецификаторы у format() те же, что у f-строк. Метод format() до сих пор полезен, когда шаблон хранится отдельно от данных, например в конфиге.

Парсинг строки: практический пример

Соберём методы вместе. Допустим, из файла приходят строки вида " 2026-10-16; Кофе ; 250,50 \n", и нужно получить дату, название и сумму в копейках. Порядок обычный: очистить края, разрезать по разделителю, почистить каждую часть, привести типы.

line = "  2026-10-16; Кофе ; 250,50 \n"

date, item, raw_amount = [p.strip() for p in line.strip().split(";")]
amount_kop = round(float(raw_amount.replace(",", ".")) * 100)

print(date, item, amount_kop)            # 2026-10-16 Кофе 25050
print(f"{item:<10}{amount_kop / 100:>10.2f}")

Если частей окажется не три, распаковка упадёт с ValueError: not enough values to unpack или too many values to unpack. В реальном коде такие строки стоит проверять заранее или ловить исключение. Для настоящих CSV-файлов с кавычками и экранированием лучше взять стандартный модуль csv, а не split.

Типичные ошибки со строками

• Результат метода не сохранён: s.strip() без присваивания ничего не меняет.
• join от списка чисел — TypeError; сначала map(str, ...).
• strip с подстрокой: аргумент — набор символов, для префикса нужен removeprefix().
• Сравнение с учётом регистра: "Кофе" == "кофе" — False.
• Слеши в путях Windows без префикса r превращаются в спецсимволы.

t-строки: шаблон вместо готового текста

В Python 3.14 появились t-строки. Выглядят они как f-строки, только с префиксом t, но результат другой: не готовая строка, а объект string.templatelib.Template. В нём отдельно лежат куски текста (.strings) и подставленные значения (.values).

name = "<script>"
tpl = t"Привет, {name}!"
print(tpl.strings)   # ('Привет, ', '!')
print(tpl.values)    # ('<script>',)

Зачем это нужно: библиотека получает значения до склейки и может их обработать — экранировать угловые скобки в HTML или правильно передать параметры в SQL-запрос. f-строка такого шанса не даёт, она уже всё склеила. Для обычного вывода по-прежнему используйте f-строки.

Итог

Для повседневной работы со строками Python хватает небольшого набора: split() и join() разбирают и собирают текст, strip() чистит ввод, replace() заменяет фрагменты, срезы вырезают подстроки, а f-строки выводят значения с нужным форматом. Помните о неизменяемости: метод возвращает новую строку, её нужно сохранить. Строки, числа и f-строки на примере трекера расходов разобраны на практике в лекции курса по Python.