удалить У Python есть метод подстроки «содержит»?




поиск слова в строке python (12)

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

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

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

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

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

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

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

Как и было обещано, вот метод contains :

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

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

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

Но не надо. Методы, начинающиеся с подчеркивания, считаются семантически частными. Единственная причина, по которой это нужно использовать, - это расширение функции, а 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 гораздо эффективнее использовать оператор сравнения.

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

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

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 или string.indexof в Python.

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

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

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

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

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 "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

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

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

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

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

Выход:

True

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

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

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

Выход:

Substring found!

Нет, никакого 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 ]

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

В 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

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


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

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

import operator

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

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


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

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


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

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

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

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


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

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

if "blah" not in somestring: 
    continue




contains