Python строка содержит подстроку: содержит ли строка подстроку в Python на примерах

содержит ли строка подстроку в Python на примерах

Автор В. Дронов

/

22.03.2021

/

Строки в Python /

Чтобы проверить, содержит ли данная строка конкретную подстроку в Python, используйте оператор in.

Синтаксис условия для проверки наличия в строке определенной подстроки:

substring in string

Вышеприведенное выражение возвращает True, если подстрока присутствует в строке, или False, если подстрока отсутствует в строке.

Пример 1

В этом примере мы возьмем две строки: одна – наша основная строка, а другая – подстрока. А с помощью оператора in мы проверим, присутствует ли подстрока в основной строке.

string = 'Hello World!'
substring = 'Wor'
isSubstringPresent = substring in string
print(isSubstringPresent)

Вывод:

True

Поскольку оператор in возвращает логическое значение, вы можете использовать это выражение в качестве условия в операторе if.

В следующем примере мы проверим, содержит ли строка подстроку, и на основе результата мы выполним блок кода условно, используя оператор if.

string = 'Hello World!'
substring = 'Wor'
if substring in string:
    print('String contains substring.')
else :
    print('String does not contain substring.')

Вывод:

String contains substring.

Другие способы проверки

Вы также можете использовать другие методы, такие как string.find(), чтобы проверить, содержит ли строка подстроку. string.find (substring) возвращает индекс подстроки в строке. Если подстрока присутствует в строке, то функция возвращает неотрицательное целое число. Мы можем использовать это как условие и проверить, содержит ли строка подстроку.

string = 'Hello World!'
substring = 'Wor'
if string.find(substring) > -1:
    print('String contains substring.
  ')
else :
    print('String does not contain substring.')

Вывод:

String contains substring.

В этом руководстве примеров в Python мы узнали, как проверить, содержит ли данная строка определенную подстроку, используя оператор in и другие методы.

Проверка, содержит ли строка подстроку из списка

Чтобы проверить, содержит ли строка подстроку из списка строк, выполните итерацию по списку строк и для каждого элемента в списке проверьте, присутствует ли элемент в данной строке.

В этом скрипте мы имеем:

• исходную строку, в которой мы должны проверить, присутствует ли какая-либо подстрока;
• список строк, элементы которых могут встречаться в исходной строке, и мы должны определить, встречается ли какая-либо из этих строк в списке в исходной строке.

Пример 1

В этом примере мы возьмем исходную строку и список строк. Мы будем использовать цикл for, чтобы проверить, присутствует ли строка из списка как подстрока в исходной строке.

source_string = 'a b c d e f'
list_of_strings = ['k', 'm', 'e' ]

for substring in list_of_strings:
    if substring in source_string:
        print('String contains substring from list.')
        break

Вывод:

String contains substring from list.

Поскольку элемент из списка ‘e’ присутствует как подстрока в исходной строке, во время выполнения цикла for для элемента ‘e’ условие в цикле if становится True.

Резюме

В этом руководстве примеров в Python мы узнали, как проверить, содержит ли строка подстроку из списка строк, с помощью программы-примера.

This div height required for enabling the sticky sidebar

Проверка вхождения одной строки в другую в Python

Как проверить, содержит ли строка Python другую строку?

Проверка, содержит ли строка какую-нибудь другую строку, это одна из самых распространенных операций, осуществляемых разработчиками.

Если вы раньше (до перехода на Python) писали код, скажем, на Java, для подобной проверки вы могли использовать метод contains.

В Python есть два способа достичь той же цели.

1. Использование оператора in

Самый простой способ проверить, содержится ли в строке другая строка, это использовать оператор Python in.

Давайте рассмотрим пример.

>>> str = "Messi is the best soccer player"
>>> "soccer" in str
True
>>> "football" in str
False

Как видите, оператор in возвращает True, если указанная подстрока является частью строки. В противном случае он возвращает False.

Этот метод очень простой, понятный, читаемый и идиоматичный.

2. Использование метода find

Также для проверки вхождения одной строки в другую можно использовать строковый метод find.

В отличие от оператора, возвращающего булево значение, метод find возвращает целое число.

Это число является по сути индексом начала подстроки, если она есть в указанной строке. Если этой подстроки в строке не содержится, метод возвращает -1.

Давайте посмотрим, как работает метод find.

 >>> str = "Messi is the best soccer player"
>>> str.find("soccer")
18
>>> str.find("Ronaldo")
-1
>>> str.find("Messi")
0

Что особенно хорошо в применении этого метода — вы можете при желании ограничить пределы поиска, указав начальный и конечный индекс.

Например:

>>> str = "Messi is the best soccer player"
>>> str. find("soccer", 5, 25)
18
>>> str.find("Messi", 5, 25)
-1

Обратите внимание, что для подстроки «Messi» метод вернул -1. Это произошло потому, что мы ограничили поиск в строке промежутком символов с индексами от 5-го до 25-го.

Более сложные способы

Представьте на минутку, что в Python нет никаких встроенных функций или методов, позволяющих проверить, входит ли одна строка в другую. Как бы вы написали функцию для этой цели?

Можно использовать брутфорс-подход и на каждой возможной позиции в строке проверять, начинается ли там искомая подстрока. Но для длинных строк этот процесс будет очень медленным.

Есть лучшие алгоритмы поиска строк. Если вы хотите углубиться в эту тему, можем порекомендовать статью «Rabin-Karp and Knuth-Morris-Pratt Algorithms». Также вам может пригодиться статья «Поиск подстроки» в Википедии.

Если вы прочитаете указанные статьи, у вас может родиться закономерный вопрос: так какой же алгоритм используется в Python?

Для поиска ответов на подобные вопросы практически всегда нужно углубиться в исходный код.

В этом плане вам повезло: Python это технология с открытым кодом. Давайте же в него заглянем.

Как удачно, что разработчики прокомментировали свой код! Теперь нам совершенно ясно, что метод find использует смесь алгоритмов Бойера-Мура и Бойера-Мура-Хорспула.

Заключение

Для проверки, содержится ли указанная строка в другой строке, в Python можно использовать оператор in или метод find.

Оператор in возвращает True, если указанная подстрока является частью другой строки. В противном случае он возвращает False.

Метод find возвращает индекс начала подстроки в строке, если эта подстрока там есть, или -1 — если подстрока не найдена.

CPython использует для поиска строк комбинацию алгоритмов Бойера-Мура и Бойера-Мура-Хорспула.

Мини-задача на разогрев: являются ли две строки анаграммами?

Строка Python содержит — Проверить, содержит ли строка подстроку — LearnDataSci если .

.. в операторе . Мы можем сделать это следующим образом:

, если «яблоки» в «Эта строка содержит яблоки»:
    print('Яблоки в строке')
еще:
    print('Яблоки не в строке') 

Вышло:

 Яблоки в строке 

Сегодня мы рассмотрим различные варианты проверки наличия в строке подстроки . Мы начнем с изучения использования if ... в операторах

, а затем воспользуемся функцией find() . Ближе к концу также есть раздел об использовании регулярных выражений (регулярных выражений) с re.search() для поиска строк.

В приведенном выше примере продемонстрирован быстрый способ найти подстроку в другой строке с помощью if ... в 9Заявление 0013. Оператор вернет True , если строка действительно содержит то, что мы ищем, и False , если нет. См. ниже расширение примера, использованного ранее:

 strings = ['В этой строке есть яблоки', 'В этой строке есть апельсины', 'В этой строке нет ни того, ни другого']
для s в строках:
    если «яблоки» в s:
        print('Яблоки в строке')
    еще:
        print('Яблоки не в строке') 

Вышло:

  Яблоки в строке
Яблоки не в ряд
Яблоки не в строке 

Вывод показывает, что наш оператор if ... in ищет 'яблок' вернул только True для первого элемента в строках , что верно.

Стоит отметить, что if ... в операторах учитывается регистр. Строка , если «яблоки» в строке: не обнаружит «Яблоки» . Один из способов исправить это — использовать метод lower() , который преобразует все строковые символы в нижний регистр.

Мы можем использовать метод lower() с приведенным ниже изменением:

 strings = ['В этой строке есть яблоки', 'В этой строке есть апельсины', 'В этой строке есть яблоки']
для s в строках:
    если «яблоки» в s.lower():
        print('Яблоки в строке')
    еще:
        print('Яблоки не в строке') 

Вышло:

 Яблоки в строке
Яблоки не в ряд
Яблоки в строке 

В качестве альтернативы мы могли бы использовать функцию upper() для поиска «ЯБЛОКИ» вместо этого.

Подход if .. in имеет наибольшую производительность в большинстве случаев. Он также имеет отличную читабельность, что позволяет другим разработчикам легко понять, что делает скрипт.

Из трех вариантов, перечисленных в этой статье, использование if ... в обычно является лучшим подходом для проверки наличия в строке подстроки. Помните, что самое простое решение часто оказывается лучшим!

Другим вариантом поиска строки является использование метод find() . Если аргумент, который мы предоставляем find() , существует в строке, то функция вернет индекс начального положения искомой подстроки. Если нет, то функция вернет -1. На изображении ниже показано, как строковым символам назначаются индексы:

Мы можем применить find() к первому if ... в примере следующим образом:

 strings = ['В этой строке есть яблоки', 'Эта строка есть апельсины», «В этой строке нет ни того, ни другого»]
для s в строках:
    apples_index = s.find('яблоки')
    если apples_index < 0:
        print('Яблоки не указаны в строке')
    еще:
        print(f'Apples в строке, начинающейся с индекса {apples_index}') 

Исходящий:

 Яблоки в строке, начиная с индекса 16
Яблоки не в ряд
Apples not in string 

Для первого элемента списка 'apples' начинается с индекса 16, поэтому find('apples') возвращает 16. 'apples' не находится в строке для двух других элементов , поэтому find('apples') возвращает -1.

Функцию index() можно использовать аналогичным образом, и она также будет возвращать начальный индекс своего аргумента. Недостаток использования index() заключается в том, что он выдаст ValueError: подстрока не найдена , если Python не может найти аргумент. Функции find() и index() также чувствительны к регистру.

Regex — это сокращение от reg ular ex pression, что похоже на собственный язык программирования. С помощью re.search , поиска по регулярному выражению, мы можем определить, соответствует ли строка шаблону. Функция re.search() генерирует Match объект, если шаблон соответствует.

Вот пример:

 импорт повторно
re. search('apples', 'Эта строка содержит яблоки') 

Out:

Глядя на объект Match , span дает нам начальный и конечный индекс для 'apples' . Разрезание строки с помощью 'В этой строке есть яблоки'[16:22] возвращает подстроку 'яблоки' . совпадение 9Поле 0013 показывает нам часть строки, которая была совпадением, что может быть полезно при поиске диапазона возможных подстрок, удовлетворяющих условиям поиска.

Мы можем получить доступ к атрибутам span и match , используя методы span() и group() следующим образом: ).охватывать()) print(re.search('яблоки', 'Эта строка содержит яблоки').group())

Исход:

 (16, 22)
яблоки 

Если подстрока не совпадает, мы получаем нулевое значение None вместо получения объекта Match . См. приведенный ниже пример того, как мы можем применить регулярное выражение к проблеме строки , которую мы использовали:

 строк = ['В этой строке есть яблоки', 'В этой строке есть апельсины', 'В этой строке нет ни того, ни другого']
для s в строках:
    если re.search('яблоки', s):
        print('Яблоки в строке')
    еще:
        print('Яблоки не в строке') 

Вышло:

 Яблоки в строке
Яблоки не в ряд
Яблоки не в строке 

В этом случае оператор if определяет, возвращает ли re.search() что-либо, кроме None .

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

Например, мы можем изменить первый аргумент функции search() на 'яблоки|апельсины' , где | - это логический оператор "ИЛИ". В этом контексте re.search() вернет объект соответствия для любых строк с подстрокой 'яблоки' или 'апельсины' .

Следующий пример демонстрирует это:

 strings = ['В этой строке есть яблоки', 'В этой строке есть апельсины', 'В этой строке нет ни того, ни другого']
для s в строках:
    if re.search('яблоки|апельсины', s):
        print('Яблоки или апельсины в строке')
    еще:
        print('Ни одного фрукта в строке') 

Исход:

 Яблоки или апельсины в строке
Яблоки или апельсины в нитке
Ни одного фрукта нет в строке 

Самый простой и эффективный способ узнать, содержит ли строка подстроку, — это использовать if . .. в операторах , которые возвращают True , если подстрока обнаружена. В качестве альтернативы, используя функцию find() , можно получить индекс, с которого начинается подстрока, или -1, если Python не может найти подстроку. REGEX также является опцией: re.search() генерирует объект Match , если Python находит первый аргумент во втором.

Начать бесплатное обучение

---

Познакомьтесь с авторами

Алфи Грейс Специалист по данным

Альфи получила степень магистра машиностроения в Университетском колледже Лондона. В настоящее время он работает специалистом по данным в Square Enix. Найдите его в LinkedIn.

Вернуться к индексу блога

python — Проверить, содержит ли строка подстроку

спросил 7 лет, 10 месяцев назад

Изменено 7 лет, 10 месяцев назад

Просмотрено 20 тысяч раз

Я искал способ написать код, который проверяет, является ли определенная строка частью другой строки.