Does Python have a string 'contains' substring method?

Я ищу метод string.contains or string.indexof в Python.

Я хочу сделать:

if not somestring.contains("blah"):
   continue

Используйте in оператор:

if "blah" not in somestring: 
    continue

Примечание: Это чувствительно к регистру.

Если это просто поиск по подстроке , вы можете использовать string.find("substring").

Вы должны быть немного осторожны с find, index, и in хотя, поскольку они являются поиском по подстроке. Другими словами, это:

s = "This be a string"
if s.find("is") == -1:
    print("No 'is' here!")
else:
    print("Found 'is' in the string.")

Он будет выводиться Found 'is' in the string. аналогично, if "is" in s: будет вычисляться как True. Это может быть, а может и не быть тем, что вы хотите.

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

99% вариантов использования будут охвачены с помощью ключевого слова, in, которое возвращает True or 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**' # returns 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'testing if "{other}" in "{self}"')
        return super(NoisyString, self).__contains__(other)

ns = NoisyString('a string with a substring inside')

а теперь:

>>> 'substring' in ns
testing if "substring" in "a string with a substring inside"
True

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

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

>>> '**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: substring not found

В других языках может не быть методов для прямого тестирования подстрок, и поэтому вам придется использовать эти типы методов, но в 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 needle in haystack: это обычное использование, как говорит @Michael - оно опирается на in оператор, более читаемый и быстрый, чем вызов метода.

Если вам действительно нужен метод вместо оператора (например, чтобы сделать что-то странное key= для очень своеобразной сортировки ...?), это было бы 'haystack'.__contains__. Но поскольку ваш пример предназначен для использования в if, я думаю, вы на самом деле не имеете в виду то, что говорите;-). Использовать специальные методы напрямую не является хорошим тоном (ни читаемым, ни эффективным) - вместо этого они предназначены для использования через операторы и встроенные функции, которые делегируют им полномочия.