Метод find() в Python: как найти подстроку в строке

Представьте, что есть письмо, и нужно проверить, упоминается ли в нём слово оплата. Или в адресе почты нужно найти символ @, чтобы отделить имя от домена. В этом поможет Python и find() — рассказываем, как устроен метод, чем он отличается от index() и почему для некоторых проверок лучше использовать оператор in.

Что делает метод find в Питоне

find проходит по символам слева направо и возвращает номер позиции первого совпадения. Отсчёт индексов в Python начинается с нуля, поэтому первый символ строки получает номер 0.

Если совпадение отсутствует, метод find не выбрасывает исключение и не останавливает программу с ошибкой. Вместо этого он возвращает число -1. Такое поведение отличает find от других способов поиска и делает его удобным для проверок без конструкций try except.

Пример работы метода:

text = "Питон отлично подходит для анализа данных"
result = text.find("отлично")
print(result)

В консоли появится число 6, потому что именно с этого индекса начинается заданное слово. Попробуем найти то, чего в строке точно нет:

text = "Питон отлично подходит для анализа данных"
result = text.find("Java")
print(result)

Выполнение скрипта не прервётся ошибкой, программа выведет -1 и завершится.

Что нужно знать про синтаксис и аргументы find()

Метод find() принимает три аргумента: str.find(sub, start, end). Первый аргумент обязательный — это подстрока, которую нужно найти. Аргументы start и end задают границы поиска внутри строки.

Работают start и end почти так же, как границы среза у строки или списка. Поиск начинается с индекса start и заканчивается перед индексом end.

Разницу проще увидеть на примере:

text = "Python помогает автоматизировать рутину"
result = text.find("рутину", 0, 30)
print(result)

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

Поиск с определённой позиции

Иногда нужно найти не первое, а второе или третье вхождение подстроки. Отдельного аргумента для этого в find() нет, зато start превращает метод в инструмент для поочередного поиска. Сначала находят первое вхождение, а затем передают в start индекс, идущий сразу за ним, и вызывают find() ещё раз.

text = "кот сидит у окна, а рядом ещё один кот"
first = text.find("кот")
second = text.find("кот", first + 1)
print(first, second)

Первый вызов находит слово в начале строки. Второй начинает поиск сразу после найденного индекса и обнаруживает следующее вхождение.

Что делать, если find() возвращает -1

Метод find в Питоне возвращает -1, когда подстрока в строке отсутствует. Кажется логичным проверить результат простым условием if s.find(sub):, но здесь скрывается распространённая ошибка.

Питон нумерует символы строки с нуля, поэтому если искомая подстрока стоит в самом начале, find() вернёт 0. Условие if в Python автоматически считает число 0 значением False, а любое другое число — значением True. Получается, программа решит, что подстрока не найдена, хотя на самом деле она находится на первой позиции строки.

Вот пример, где такая проверка ломает логику:

text = "Python - гибкий язык программирования"
sub = "Python"

if text.find(sub):
    print("Подстрока найдена")
else:
    print("Подстрока не найдена")

Код в примере выведет фразу «Подстрока не найдена», хотя слово Python стоит в самом начале. Причина в том, что find() вернул 0, и условие if 0 всегда интерпретируется как ложное.

Правильный вариант проверки методом find в Питоне:

text = "Python - гибкий язык программирования"
sub = "Python"

if text.find(sub) != -1:
    print("Подстрока найдена")
else:
    print("Подстрока не найдена")

Проверка через != -1 избавляет от скрытых ошибок, которые сложно заметить при беглом просмотре кода.

Чем find() отличается от index()

Метод index() работает почти так же, как find(). В Python он тоже ищет подстроку внутри строки и возвращает номер позиции, с которой она начинается. Синтаксис у обоих методов совпадает: str.index(sub, start, end). Последние два аргумента можно не указывать — они задают границы поиска.

Разница заметна в момент, когда подстрока не найдена. Метод find() в такой ситуации возвращает -1, и программа продолжает работу без сбоев. index() же выбрасывает исключение ValueError, и выполнение кода останавливается, если это исключение никто не обработал.

text = "Python — язык программирования"

print(text.find("код"))

try:
    text.index("код")
except ValueError as error:
    print("Подстрока не найдена:", error)

Первая строка выведет -1, а вторая покажет текст ошибки вместо аварийной остановки программы.

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

index() удобнее применять там, где отсутствие подстроки указывает на ошибку в данных, и эту ошибку нужно поймать отдельно. Например, при разборе файлов конфигурации или проверке структуры входных данных.

Когда вместо find() использовать оператор in

Метод find() возвращает позицию подстроки, но иногда позиция вообще не нужна. Программа должна лишь выяснить, встречается ли подстрока в строке. С такой задачей быстрее справляется оператор in. Для строк он показывает, встречается ли одна последовательность символов внутри другой, и возвращает True или False.

Сравним на примере:

text = "Python — мощный язык программирования"

# через find()
if text.find("мощный") != -1:
    print("Подстрока найдена")

# через in
if "мощный" in text:
    print("Подстрока найдена")

Скорость работы у двух подходов немного отличается, хотя разница заметна только на больших объёмах данных. Оператор in обрабатывается интерпретатором через специальный метод __contains__, оптимизированный именно под проверку вхождения. На коротких строках выигрыш небольшой, однако при частых вызовах внутри цикла экономия времени накапливается.

Стоит учитывать разницу в возможностях. Оператор in не подскажет, с какого символа начинается подстрока и сколько раз она встречается в тексте. Если нужна такая информация, выбирайте find().

Как искать подстроку с конца строки в Python

У метода find() есть родственный метод rfind(), который решает похожую задачу, только отсчёт ведёт с конца строки. Возвращает он тоже индекс, но не первого, а последнего вхождения подстроки.

Разница между двумя методами видна на строке с несколькими одинаковыми символами:

text = "report.final.docx"
print(text.find("."))   # 6
print(text.rfind("."))  # 12

find() остановился на первой точке, а rfind() нашёл последнюю.

Метод rfind() используют для извлечения расширения файла из его имени. Файл может называться как угодно, и точек в названии иногда несколько, например «archive.backup.2026.zip». Если искать точку методом find(), результат окажется бесполезным: программа зацепится за первую же точку и отрежет часть настоящего имени файла. rfind() решает проблему:

filename = "archive.backup.2026.zip"
dot_index = filename.rfind(".")
extension = filename[dot_index + 1:]
print(extension)  # zip

Здесь срез filename[dot_index + 1:] берёт всё, что стоит после найденной точки. Способ рабочий, но не единственный. В модуле os.path есть готовая функция splitext(), которая делает то же самое, но учитывает случаи, о которые ручной поиск спотыкается: файлы без расширения и имена, начинающиеся с точки.

Как искать подстроки методом find в Python на практике

Разобранные возможности редко применяются по отдельности. Обычно их комбинируют для решения задач поиска подстроки в строке Python.

Первый сценарий посвящён поиску маркера в логе. Нужно быстро найти строку с ошибкой среди прочих записей:

log_line = "10:23 INFO start, 10:24 ERROR connection lost, 10:25 INFO stop"
position = log_line.find("ERROR")
if position != -1:
    print(log_line[position:position + 25])
else:
    print("Ошибок не найдено")

Метод возвращает позицию слова ERROR, а срез вырезает фрагмент строки для дальнейшего анализа.

Второй сценарий раскрывает извлечение значения между двумя разделителями. Задача типична для разбора простых конфигов или ответов API:

text = "temperature=[23.5]"
start = text.find("[")
end = text.find("]")

if start != -1 and end != -1:
    value = text[start + 1:end]
    print(value)
else:
    print("Разделители не найдены")

Работает, пока разделители встречаются в тексте только один раз. Проверка на -1 обязательна: без неё find() вернёт -1, к нему прибавится единица, срез отработает без ошибки и выдаст мусор.

Третий пример показывает подсчёт всех вхождений подстроки. Если нужно только количество, хватит метода count(): вызов text.count(“яблоко”) вернёт 3 одной строкой. Цикл с find() нужен, когда важны ещё и позиции каждого вхождения, — тогда точку старта поиска сдвигаем вручную.

text = "яблоко банан яблоко груша яблоко"
substring = "яблоко"
count = 0
start = 0
while True:
    position = text.find(substring, start)
    if position == -1:
        break
    count += 1
    start = position + len(substring)
print(count)

Как только шаблон усложняется, например, нужно найти email или дату в произвольном формате, цепочка из нескольких find() превращается в громоздкую конструкцию. В такой ситуации логичнее взять модуль re, созданный специально для работы с регулярными выражениями.

Метод find() решает большинство задач поиска подстроки, где нужен сам факт совпадения и его позиция в тексте. Программа получает число вместо исключения, поэтому код не падает на пустом месте.

Когда задача перестаёт сводиться к точному фрагменту текста и требует шаблона, диапазона символов или нескольких вариантов написания, методы str не справляются. В таком случае лучше перейти на модуль re с регулярными выражениями, чтобы не путаться в нагромождениях find.

Советуем дополнительно почитать

Метод str.replace () в Python — следующий шаг после того, как подстрока найдена: заменить её на другую, не собирая строку заново.

Метод join () в Python — обратная операция: собрать строку из кусков, на которые её разобрали.

Анализируем самые частые слова в любом тексте — проект, где поиск подстрок перестаёт быть учебным примером и превращается в разбор реального текста.

Задача с собеседования про перебор букв в словах — как те же операции над строками выглядят в формате задачи с ограничением по времени.

Собеседование на Python-разработчика: что спрашивают у джунов и мидлов — что спрашивают про стандартную библиотеку и почему разница между find() и index() иногда всплывает на техническом интервью.