Методы строк

Вы уже умеете склеивать строки, вставлять переменные через f-строки и пользуетесь upper(), lower(), strip(), replace(), split() и count(). Этого хватает для простых программ, но реальные задачи с текстом требуют больше: найти подстроку, проверить, из чего состоит строка, красиво выровнять таблицу или собрать строку обратно из кусочков.

У строк в Python есть ещё несколько десятков методов, но по-настоящему часто используется около десятка. Их и разберём: как собрать строку из списка слов, как искать текст внутри текста, как быстро проверять содержимое и как наводить порядок в пользовательском вводе.

join() — склеиваем список обратно в строку

Когда вы вызываете "a,b,c".split(","), Python разбирает строку на кусочки и складывает их в список. Иногда нужна обратная операция: у вас есть несколько кусочков текста, и их нужно снова собрать в одну строку с каким-то разделителем между ними.

Именно это делает метод join() — «соединить». Особенность в том, что вызывается он не у списка, а у строки-разделителя: "разделитель".join(список). На первый взгляд непривычно, но логика простая: строка перед точкой — это то, что Python вставит МЕЖДУ элементами.

words = ["Питон", "это", "просто"]

sentence = " ".join(words)
print(sentence)
# Питон это просто

csv_line = ",".join(["Иван", "25", "Москва"])
print(csv_line)
# Иван,25,Москва

Разбор по строкам:

• words = [...] — список из трёх строк (такой список как раз возвращает split()).
• " ".join(words) — берём строку " " (один пробел) и просим её «соединить» элементы списка words, вставляя этот пробел между каждой парой соседних элементов. Перед первым и после последнего элемента ничего не добавляется.
• Во втором примере разделитель — запятая ",", поэтому элементы склеились через запятую без пробелов.

find() и index() — ищем подстроку внутри строки

Часто нужно не просто узнать, есть ли кусок текста внутри строки (для этого хватает оператора in), а узнать, где именно он находится — с какого символа начинается.

Для этого есть методы find() («найти») и index() («индекс»). Оба возвращают номер позиции первого вхождения подстроки — тот же индекс, что вы уже использовали для среза строки. Разница между ними — в поведении, когда подстроки нет.

text = "Привет, мир!"

pos = text.find("мир")
print(pos)          # 8

pos2 = text.find("Python")
print(pos2)         # -1 (не найдено)

• text.find("мир") — ищет подстроку "мир" в строке text и возвращает индекс её первого символа. Отсчёт, как и в срезах, идёт с нуля, поэтому результат 8.
• text.find("Python") — такой подстроки в тексте нет, поэтому find() не выбрасывает ошибку, а спокойно возвращает -1. Это единственный индекс, которого в строке гарантированно не бывает, поэтому его используют как сигнал «не найдено».

text = "Привет, мир!"

pos = text.index("мир")
print(pos)              # 8

pos2 = text.index("Python")
# ValueError: substring not found

index() работает так же, но если подстроки нет — программа останавливается с ошибкой ValueError. Поэтому find() удобнее, когда вы не уверены, есть ли подстрока: можно проверить результат на -1 в условии. index() используют, когда подстрока обязана быть, и её отсутствие — это как раз ошибка, о которой нужно узнать сразу.

Быстрые проверки: startswith(), endswith(), isdigit(), isalpha()

Иногда не нужен точный индекс — достаточно ответа «да» или «нет» на простой вопрос вроде «строка начинается с этого?» или «тут только цифры?». Для таких вопросов есть отдельная группа методов, которые всегда возвращают True или False.

startswith(sub) проверяет, начинается ли строка с указанной подстроки, а endswith(sub) — заканчивается ли ей.

filename = "report.pdf"

print(filename.startswith("report"))   # True
print(filename.endswith(".pdf"))       # True
print(filename.endswith(".docx"))      # False

Эти два метода избавляют от ручного сравнения срезов вроде filename[-4:] == ".pdf" — с ними код читается как обычное предложение на английском.

isdigit() проверяет, что строка состоит только из цифр, а isalpha() — что она состоит только из букв. Обратите внимание: это методы строки, а не проверка типа — они смотрят на символы внутри текста.

code = "12345"
name = "Москва"
mixed = "дом12"

print(code.isdigit())    # True
print(name.isalpha())    # True
print(mixed.isdigit())   # False, есть буквы
print(mixed.isalpha())   # False, есть цифры

• code.isdigit() — каждый символ строки "12345" является цифрой, поэтому результат True.
• name.isalpha() — вся строка "Москва" состоит из букв, поэтому True. Пробелы и знаки препинания сломают эту проверку: isalpha() вернёт False, если внутри есть хоть один пробел.
• mixed.isdigit() и mixed.isalpha() — строка "дом12" смешанная, поэтому обе проверки дают False: ни «только цифры», ни «только буквы» не выполняются.

Выравнивание текста: ljust(), rjust(), center(), zfill()

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

ljust(n) («left justify», выравнивание по левому краю) дополняет строку пробелами справа до общей длины n. rjust(n) делает то же самое, но пробелы добавляются слева, а сам текст прижимается к правому краю. center(n) размещает текст по центру, добавляя пробелы с обеих сторон.

word = "кот"

print(word.ljust(10) + "|")     # "кот       |"
print(word.rjust(10) + "|")     # "       кот|"
print(word.center(10) + "|")    # "   кот    |"

• word.ljust(10) — строка "кот" занимает 3 символа, метод дополняет её пробелами справа до общей длины 10 символов. Символ | в конце добавлен просто для наглядности, чтобы было видно, где заканчиваются пробелы.
• word.rjust(10) — та же идея, но пробелы уходят влево, а "кот" прижимается к правому краю.
• word.center(10) — пробелы распределяются поровну с обеих сторон (если поровну не получается, лишний пробел уходит вправо).

Отдельный частый случай — дополнить число ведущими нулями, например для номера заказа 007 вместо 7. Для этого есть zfill(n) («zero fill») — он дополняет строку нулями слева до длины n, при этом правильно ставит знак - перед числом, если он есть.

order_id = "42"
print(order_id.zfill(6))    # "000042"

temperature = "-5"
print(temperature.zfill(4)) # "-005"

Во втором примере знак минуса Python не считает обычным символом: он остаётся первым, а нули вставляются уже после него — получается "-005", а не "000-5".

capitalize() и title() — заглавные буквы по правилам

Вы уже умеете переводить весь текст в верхний или нижний регистр через upper() и lower(). Но часто нужен не сплошной регистр, а аккуратное оформление: первая буква заглавная, остальные строчные — как в начале предложения или в имени.

capitalize() делает первый символ строки заглавным, а все остальные — строчными. title() делает то же самое, но для каждого слова в строке — получается заголовочный стиль, как в названиях книг.

sentence = "привет, ДРУЗЬЯ"

print(sentence.capitalize())   # "Привет, друзья"
print(sentence.title())        # "Привет, Друзья"

• sentence.capitalize() — первая буква "п" становится заглавной "П", а все остальные буквы, включая "ДРУЗЬЯ", переводятся в нижний регистр.
• sentence.title() — Python находит границы каждого слова (по пробелам и знакам препинания) и делает заглавной первую букву каждого из них: и "Привет", и "Друзья".

Цепочки методов

Каждый метод строки возвращает новую строку, а у новой строки снова можно сразу вызвать метод. Так получаются цепочки методов, записанные подряд через точку: результат предыдущего метода становится тем, к чему применяется следующий.

raw = "  Иван ПЕТРОВ  "

# По одному шагу, с промежуточными переменными:
step1 = raw.strip()          # "Иван ПЕТРОВ"
step2 = step1.lower()        # "иван петров"
result = step2.title()       # "Иван Петров"

# То же самое одной цепочкой:
result = raw.strip().lower().title()
print(result)                # "Иван Петров"

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

Частые ошибки

words = ["a", "b", "c"]

words.join(", ")
# AttributeError: 'list' object has no attribute 'join'

text = "яблоко"

if text.find("я"):
    print("нашли")
else:
    print("не нашли")
# выведет "не нашли", хотя буква "я" есть на позиции 0

name = "иван"
name.title()
print(name)   # всё ещё "иван"

Что важно запомнить