У Python есть метод подстроки "содержит"?

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

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

if not somestring.contains("blah"):
   continue
3073
задан 09 авг. '10 в 5:52
источник поделиться
15 ответов

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

if "blah" not in somestring: 
    continue
4628
ответ дан 09 авг. '10 в 5:56
источник

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

487
ответ дан 09 авг. '10 в 5:55
источник

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

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

131
ответ дан 09 авг. '10 в 6:19
источник

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

Метод 1: in оператор

Вы можете использовать оператор Python in для проверки подстроки. Это довольно просто и интуитивно понятно. Он вернет True, если подстрока была найдена в строке else 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 и интуитивно понятен.

105
ответ дан 26 мая '15 в 20:46
источник

Есть ли в 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}
98
ответ дан 26 нояб. '14 в 1:33
источник

Нет, нет метода 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 ]
63
ответ дан 30 сент. '13 в 21:59
источник

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 действует на итерации, а не только на строки.

32
ответ дан 28 апр. '17 в 21:52
источник

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

Другой способ найти, содержит ли строка несколько символов или нет с возвращаемым значением 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
17
ответ дан 28 июля '11 в 15:32
источник

В 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!
9
ответ дан 20 нояб. '16 в 21:58
источник

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

import operator

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

Все операторы в Python могут быть более или менее находятся в модуле оператора в том числе in.

9
ответ дан 28 марта '18 в 12:59
источник

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

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
8
ответ дан 26 мая '15 в 1:50
источник

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

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
6
ответ дан 13 янв. '18 в 18:32
источник

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

В 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


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

5
ответ дан 16 июня '18 в 15:02
источник

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

a = "Hello, what your name?"
if a.count("what's"):
    print("Found")
else:
    print("Not found")
0
ответ дан 02 дек. '17 в 23:12

Другие вопросы по меткам или Задайте вопрос