Ответ 1

Вы можете использовать оператор in:

if "blah" not in somestring: 
    continue

Ответ 2

Если это просто поиск по подстроке, вы можете использовать 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. будет напечатано Found 'is' in the string. Аналогично, if "is" in s: будет иметь значение True. Это может или не может быть то, что вы хотите.

Ответ 3

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

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

Ответ 4

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

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

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

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

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

Это семантически то же самое, что и 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}

Ответ 5

По сути, вы хотите найти подстроку в строке в Python. Есть два способа поиска подстроки в строке в Python.

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

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

>>> "King" in "King landing"
True

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

Метод 2: метод str.find()

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

>>> some_string = "valar morghulis"

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

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

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

Ответ 6

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

if substring in someString:
    print "It 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 ]

Ответ 7

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

Caveat. Списки являются итерабельными, а метод in действует на итерации, а не только на строки.

Ответ 8

Таким образом, по-видимому, нет ничего подобного для векторного сравнения. Очевидным способом 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

Ответ 9

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

import operator

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

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

Ответ 10

Другой способ найти, содержит ли строка несколько символов или нет с возвращаемым значением Boolean (т.е. 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

Ответ 11

Существует четыре простейших способа узнать, что такое подстрока и где начинается подстрока.

Первый через Питонов in операторе:

someString = "Polly is drinking Coca-Cola."

"Coca-Cola" in someString
# Result: True

"Pepsi" in someString
# Result: False

Второй способ - использовать метод find() для строк.

В отличие от оператора in который оценивается как логическое значение, метод find возвращает целое число. Это целое число является индексом начала подстроки, если эта подстрока существует, в противном случае -1. Вот как это работает:

someString = "Polly is drinking Coca-Cola."

someString.find("is")
# Result: 6

someString.find("Pepsi")
# Result: -1

someString.find("Polly")
# Result: 0

Вы также можете указать начальный и конечный индексы, чтобы ограничить поиск. Например:

someString = "Polly is drinking Coca-Cola."

someString.find("is", 5, 10)
# Result: 6

someString.find("Polly", 15, 20)
# Result: -1

В третьих. И, конечно, вы можете использовать if...is not Statement (он работает в Python 2.7 и 3.6):

someString = "Polly is drinking Coca-Cola."
substring = "drinking"

if someString.find(substring) is not -1:
    print("Cool! Python found the desired substring!")
else:
    print("Python didn't find the desired substring!")

# Result: "Cool! Python found the desired substring!"

Четыре. Используйте метод index(). Это почти так же, как метод find().

someString = "Polly is drinking Coca-Cola."
x = someString.index("drinking")
print(x)

# Result: 9

Надеюсь это поможет.

Ответ 12

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

Он вернет целочисленное значение числа раз, когда подстрока появляется в строке.

Например:

string.count("bah") >> 0
string.count("Hello") >> 1

Ответ 13

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

Путь Pythonic: использование Python 'in' Keyword -

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

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

Вывод:

True

Непитонический способ: использование Python str.find:

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

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

Вывод:

Substring found!

Ответ 14

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

В 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 это самый быстрый способ найти подстроку...

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

Ответ 15

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

if "insert_char_or_string_here" in "insert_string_to_search_here":
    #DOSTUFF

Для проверки, является ли он ложным:

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

Ответ 16

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

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

Ответ 17

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

>>> import re
>>> print(re.findall(r'( |t)', to_search_in)) # searches for t or space
['t', ' ', 't', ' ', ' ']

Ответ 18

Считая подстроки в строке

a = "Hello, what your name?"
if a.count("what's"):
    print("Found")
else:
    print("Not found")

Ответ 19

Есть много ответов.

Но использование count может быть удобно.

пример:

strblah = 'I have blah in me'
if strblah.count('blah') > 0:
    print('Yes: substring found')