Есть ли в Python метод подстроки 'contains' для строк?

Есть ли в Python метод для проверки, содержится ли подстрока в строке?

99% случаев можно решить с помощью ключевого слова in, которое возвращает True или False:

'substring' in any_string

Если вам нужно получить индекс, используйте str.find (возвращает -1 в случае неудачи и имеет дополнительные параметры):

start = 0
stop = len(any_string)
any_string.find('substring', start, stop)

Либо str.index (подобен find, но вызывает исключение ValueError в случае неудачи):

start = 100 
end = 1000
any_string.index('substring', start, end)

Объяснение

Используйте оператор сравнения in, потому что

1. это то, что предполагается использовать в языке, и
2. другие программисты Python ожидают, что вы будете использовать его.

>>> 'foo' in '**foo**'
True

Обратное (дополнение), которое затрагивает исходный вопрос, - это not in:

>>> 'foo' not in '**foo**' # возвращает False
False

Это семантически то же самое, что и not 'foo' in '**foo**', но намного читаемее и явно предусмотрено в языке как улучшение читаемости.

Избегайте использования __contains__

Метод "contains" реализует поведение для in. Например, данный код:

str.__contains__('**foo**', 'foo')

возвращает True. Вы также можете вызвать эту функцию из экземпляра суперстроки:

'**foo**'.__contains__('foo')

Но делать этого не следует. Методы, начинающиеся с подчеркивания, считаются семантически непубличными. Единственная причина использовать это - при реализации или расширении функциональности in и not in (например, при подкласса str):

class NoisyString(str):
    def __contains__(self, other):
        print(f'проверка, содержится ли "{other}" в "{self}"')
        return super(NoisyString, self).__contains__(other)

ns = NoisyString('строка с подстрокой внутри')

Теперь:

>>> 'substring' in ns
проверка, содержится ли "substring" в "строка с подстрокой внутри"
True

Не используйте find и index для проверки "содержится ли"

Не используйте следующие методы строк для проверки на "содержится ли":

>>> '**foo**'.index('foo')
2
>>> '**foo**'.find('foo')
2

>>> '**oo**'.find('foo')
-1
>>> '**oo**'.index('foo')

Traceback (most recent call last):
  File "<pyshell#40>", line 1, in <module>
    '**oo**'.index('foo')
ValueError: подстрока не найдена

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

Кроме того, эти методы не являются прямыми заменами для in. Вам, возможно, придется обрабатывать случаи исключений или -1, а если они возвращают 0 (так как подстрока найдена в начале), то логическое значение будет False, а не True.

Если вы действительно имеете в виду not any_string.startswith(substring), лучше выразите это явно.

Сравнение производительности

Мы можем сравнить различные способы достижения одной и той же цели.

import timeit

def in_(s, other):
    return other in s

def contains(s, other):
    return s.__contains__(other)

def find(s, other):
    return s.find(other) != -1

def index(s, other):
    try:
        s.index(other)
    except ValueError:
        return False
    else:
        return True

perf_dict = {
'in:True': min(timeit.repeat(lambda: in_('superstring', 'str'))),
'in:False': min(timeit.repeat(lambda: in_('superstring', 'not'))),
'__contains__:True': min(timeit.repeat(lambda: contains('superstring', 'str'))),
'__contains__:False': min(timeit.repeat(lambda: contains('superstring', 'not'))),
'find:True': min(timeit.repeat(lambda: find('superstring', 'str'))),
'find:False': min(timeit.repeat(lambda: find('superstring', 'not'))),
'index:True': min(timeit.repeat(lambda: index('superstring', 'str'))),
'index:False': min(timeit.repeat(lambda: index('superstring', 'not'))),
}

Теперь мы видим, что использование in намного быстрее, чем другие методы. Меньше времени на выполнение эквивалентной операции - это лучше:

>>> perf_dict
{'in:True': 0.16450627865128808,
 'in:False': 0.1609668098178645,
 '__contains__:True': 0.24355481654697542,
 '__contains__:False': 0.24382793854783813,
 'find:True': 0.3067379407923454,
 'find:False': 0.29860888058124146,
 'index:True': 0.29647137792585454,
 'index:False': 0.5502287584545229}

Как in может быть быстрее, чем __contains__, если in использует __contains__?

Это хороший дополнительный вопрос.

Давайте разберем функции с интересующими нас методами:

>>> from dis import dis
>>> dis(lambda: 'a' in 'b')
  1           0 LOAD_CONST               1 ('a')
              2 LOAD_CONST               2 ('b')
              4 COMPARE_OP               6 (in)
              6 RETURN_VALUE
>>> dis(lambda: 'b'.__contains__('a'))
  1           0 LOAD_CONST               1 ('b')
              2 LOAD_METHOD              0 (__contains__)
              4 LOAD_CONST               2 ('a')
              6 CALL_METHOD              1
              8 RETURN_VALUE

Как мы видим, метод .__contains__ должен быть отдельно найден и затем вызван из виртуальной машины Python - это и объясняет разницу в производительности.

Вот ваш ответ:

Чтобы проверить, содержится ли подстрока в строке, вы можете использовать следующий код:

if "вставьте_символ_или_строку_здесь" in "вставьте_строку_для_поиска_здесь":
    # ДЕЛАЙТЕ ЧТО-ТО

Для проверки, если это ложь:

if not "вставьте_символ_или_строку_здесь" in "вставьте_строку_для_поиска_здесь":
    # ДЕЛАЙТЕ ЧТО-ТО

ИЛИ:

if "вставьте_символ_или_строку_здесь" not in "вставьте_строку_для_поиска_здесь":
    # ДЕЛАЙТЕ ЧТО-ТО

Вы можете использовать регулярные выражения для получения вхождений:

>>> import re
>>> print(re.findall(r'( |t)', to_search_in)) # ищет букву t или пробел
['t', ' ', 't', ' ', ' ']

Этот код находит все вхождения буквы 't' или пробела в строке to_search_in.

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

names = ['bob', 'john', 'mike']
any(st in 'bob and john' for st in names) 
# Результат: True

any(st in 'mary and jane' for st in names) 
# Результат: False

В первом случае одно из имен ('bob' или 'john') встречается в строке, поэтому возвращается True, а во втором — ни одно из имен не содержится в строке, что дает False.

Вы можете использовать метод y.count().

Этот метод вернет целочисленное значение, представляющее количество вхождений подстроки в строку.

Например:

string.count("bah")   # вернет 0
string.count("Hello") # вернет 1