# Строки в Python: методы split, replace, strip, join, срезы и f-строки URL: https://skillaria.top/ru/guides/python/stroki-python Строка в Python (тип str) — неизменяемая последовательность символов Unicode. Метод split() разбивает строку на список, join() склеивает список обратно, replace() заменяет подстроку, strip() убирает пробелы по краям; каждый метод возвращает новую строку. Подставлять значения удобнее всего f-строкой: f"{name}: {price:.2f}". Строки в 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). ## Другие полезные методы строк | Метод | Что делает | Пример → результат | | --- | --- | --- | | `lower()`, `upper()` | регистр | `"Кофе".lower()` → `'кофе'` | | `startswith()`, `endswith()` | проверка начала и конца | `"a.csv".endswith(".csv")` → `True` | | `find()` | позиция подстроки или -1 | `"кофе".find("ф")` → `2` | | `count()` | число вхождений | `"банан".count("а")` → `2` | | `isdigit()` | только цифры? | `"250".isdigit()` → `True` | | `zfill()` | дополнить нулями | `"7".zfill(3)` → `'007'` | Проверить, содержит ли строка подстроку, проще всего оператором `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"{3.14159:.2f}"` | `3.14` | округление до 2 знаков | | `f"{1250000:,}"` | `1,250,000` | разделитель разрядов | | `f"{1250000:_}"` | `1_250_000` | подчёркивание вместо запятой | | `f"{0.256:.1%}"` | `25.6%` | проценты | | `f"{'кофе':<10}|"` | `кофе |` | по левому краю, ширина 10 | | `f"{250:>8}"` | ` 250` | по правому краю | | `f"{7:03d}"` | `007` | дополнение нулями | Выравнивание удобно для таблиц в терминале: `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.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 = "" tpl = t"Привет, {name}!" print(tpl.strings) # ('Привет, ', '!') print(tpl.values) # ('',) ``` Зачем это нужно: библиотека получает значения до склейки и может их обработать — экранировать угловые скобки в HTML или правильно передать параметры в SQL-запрос. f-строка такого шанса не даёт, она уже всё склеила. Для обычного вывода по-прежнему используйте f-строки. ## Итог Для повседневной работы со строками Python хватает небольшого набора: `split()` и `join()` разбирают и собирают текст, `strip()` чистит ввод, `replace()` заменяет фрагменты, срезы вырезают подстроки, а f-строки выводят значения с нужным форматом. Помните о неизменяемости: метод возвращает новую строку, её нужно сохранить. Строки, числа и f-строки на примере трекера расходов разобраны на практике в лекции курса по Python. ## FAQ **Как узнать длину строки в Python?** Функция len(s) возвращает число символов. Для кириллицы и эмодзи считаются символы Unicode, а не байты; размер в байтах даёт len(s.encode("utf-8")). **Как превратить число в строку и обратно?** str(250) даёт '250', а int("250") и float("2.5") — обратное преобразование. Если строка не похожа на число, int() вызовет ValueError, поэтому ввод стоит проверять. **Почему replace не меняет мою строку?** Строки неизменяемы, replace возвращает новую строку. Присвойте результат: s = s.replace("a", "b"). **Как проверить, пустая ли строка?** Пустая строка ложна, поэтому достаточно if not s:. Если строка может состоять из пробелов, проверяйте if not s.strip():. **Чем t-строка отличается от f-строки?** f-строка сразу возвращает готовый str, а t-строка (Python 3.14+) — объект Template с отдельными кусками текста и значениями. Это позволяет безопасно экранировать данные для HTML и SQL. --- Source: Skillaria.Top (https://skillaria.top)