Вопрос: У Python есть метод подстроки «содержит»?


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

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

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

2762


источник


Ответы:


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

if "blah" not in somestring: 
    continue

4181



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


434



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

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


121



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

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

Вы можете использовать Python's 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

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


88



У 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}

83



No, there isn't any string.contains(str) method, but there is the in operator:

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

Here is a more complex working example:

# 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 ]

59



in Python strings and lists

Here are a few useful examples that speak for themselves concerning the in method:

"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. Lists are iterables, and the in method acts on iterables, not just strings.


30



So apparently there is nothing similar for vector-wise comparison. An obvious Python way to do so would be:

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

20



Another way to find whether a string contains a few characters or not with the Boolean return value (i.e. True or `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



In Python there are two simple ways you can achieve this:

The Pythonic way: Using Python's 'in' Keyword-

in takes two "arguments", one on the left(substring) and one on the right, and returns True if the left argument is contained within the rightside argument and if not,it returns False.

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

Output:

True

The non-Pythonic way: Using Python's str.find:

The find method returns the position of the string within the string or -1 if it's not found. But simply check if the position is not -1.

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

Output:

Substring found!

10