если это просто поиск подстроки можно использовать 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. Это может быть или не быть тем, чего вы хотите.

if needle in haystack: Это нормальное использование, как говорит @Michael - он полагается на in оператор, более читаемый и более быстрый, чем вызов метода.

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

в принципе, вы хотите найти подстроку в строке в Python. Существует два способа поиска подстроки в строке в Python.

Способ 1: in оператор

можно использовать в Python in оператор для проверки подстроки. Это довольно просто и интуитивно. Он вернется True если подстрока была найдена в строке else False.

>>> "King" in "King's landing"
True

>>> "Jon Snow" in "King's landing"
False

Способ 2: str.find() метод

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

>>> some_string = "valar morghulis"

>>> some_string.find("morghulis")
6

>>> some_string.find("dohaeris")
-1

Я бы рекомендовал вам использовать первый метод, поскольку он более Питонический и интуитивный.

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

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

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

противоположным (дополнением), которое задает исходный вопрос, является not in:

>>> 'foo' not in '**foo**' # returns False
False

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

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

как и было обещано, вот contains способ:

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

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

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

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

class NoisyString(str):
    def __contains__(self, other):
        print('testing if "{0}" in "{1}"'.format(other, 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

кроме того, избегайте следующих строковых методов:

>>> '**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 оператор сравнения.

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

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

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}

нет, нет string.contains(str) метод, но есть in оператор:

if substring in someString:
    print "It's there!!!"

вот более сложный пример:

# Print all files with dot in home directory
import commands
(st, output) = commands.getstatusoutput('ls -a ~')
print [f for f in output.split('\n') if '.' in f ]

in строки и списки Python

вот несколько полезных примеров, которые говорят сами за себя о in способ:

"foo" in "foobar"
True

"foo" in "Foobar"
False

"foo" in "Foobar".lower()
True

"foo".capitalize() in "Foobar"
True

"foo" in ["bar", "foo", "foobar"]
True

"foo" in ["fo", "o", "foobar"]
False

нюанс. Списки, итераторы, и 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

другой способ найти, содержит ли строка несколько символов или нет с логическим возвращаемым значением (т. е. True или ' False):

str1 = "This be a string"
find_this = "tr"
if find_this in str1:
    print find_this, " is been found in ", str1
else:
    print find_this, " is not found in ", str1

в Python есть два простых способа добиться этого:

Питонический способ: использование ключевого слова " in " Python -

in принимает два "аргумента", один слева(подстрока) и один справа, и возвращает True если левый аргумент содержится в аргументе правой стороны, а если нет, он возвращает False.

example_string = "This is an example string"
substring = "example"
print(substring in example_string)

выход:

True

не-подходящие для Python способ: использование языка Python ул.найти:

The find метод возвращает позицию строки в строку или -1, если не найден. Но просто проверьте, не является ли позиция -1.

if example_string.find(substring) != -1:
    print('Substring found!')
else:
    print('Substring not found!')

выход:

Substring found!

Если вы довольны "blah" in somestring но хочу, чтобы это был вызов функции, вы, вероятно, можете сделать это

import operator

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

все операторы в Python можно более или менее найти в модуль оператора в том числе in.

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

if "insert_char_or_string_here" in "insert_string_to_search_here":
    #DOSTUFF

для проверки, если это false:

if not "insert_char_or_string_here" in "insert_string_to_search_here":
    #DOSTUFF

или:

if "insert_char_or_string_here" not in "insert_string_to_search_here":
    #DOSTUFF

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

import string

s = 'This is my text example'
if 'is' not in (word.lower() 
    for split_char in string.punctuation + string.whitespace 
    for word in s.split(split_char)):
    # do something

Я вижу, что уже есть ответы, но я хочу добавить свои два цента.

в Python есть функции для этого, но самый простой (и в основном предпочтительный) метод - использовать ключевое слово in :

"test" in "testtext"
True

"abc" in "abcdefg"
True

"abc" in "Abc"
False

"ABC" in "abc"
False

"abc" in "def"
False

"abc" in ["abc", "def", "ghi"]
True

есть некоторые строковые методы, а также:

"xxabcxx".find("abc")
2 #returns the index of the first match

"xxabcxx".find("cde")
-1 #returns -1 if the substring 
#could not be found in the string

# and:

"xxabcxx".index("abc")
2

"xxabcxx".index("cde")
ValueError: substring not found
#raises ValueError...

о работе:

В общем in - это метод fasted для поиска подстроки...

find немного быстрее, чем index

надеюсь, я смогу помочь!