我正在寻找Python中的string.contains或string.indexof方法。

我想做的是:

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

当前回答

如果只是子字符串搜索,可以使用string.find(“substring”)。

在查找、索引和插入时,您确实需要稍微小心一些,因为它们是子字符串搜索。换句话说,这:

s = "This be a string"
if s.find("is") == -1:
    print("No 'is' here!")
else:
    print("Found 'is' in the string.")

它将在字符串中打印Found“is”。类似地,如果s中的“is”将求值为True。这可能是你想要的,也可能不是你想要的。

其他回答

在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
>>> ["foo" in a for a in ["fo", "o", "foobar"]]
[False, False, True]

警告列表是可迭代的,in方法作用于可迭代的对象,而不仅仅是字符串。

如果您想以更模糊的方式比较字符串以衡量它们的“相似性”,请考虑使用Levenshtein包

下面是一个说明其工作原理的答案。

if needle in haystack:这是正常的用法,正如@Michael所说——它依赖于in运算符,比方法调用更可读、更快。

如果你真的需要一个方法而不是一个运算符(例如,为一个非常特殊的排序做一些奇怪的键…?),那就是“干草堆”__包含_。但是,既然你的例子是在if中使用的,我想你并不是真的想说什么;-)。直接使用特殊方法不是一种好的形式(既不可读,也不高效)——它们应该通过委托给它们的运算符和内置函数来使用。

以下是您的答案:

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

OR:

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

Python是否有包含字符串的子字符串方法?

99%的用例将使用关键字in覆盖,该关键字返回True或False:

'substring' in any_string

对于获取索引的用例,使用str.find(失败时返回-1,并具有可选的位置参数):

start = 0
stop = len(any_string)
any_string.find('substring', start, stop)

或str.index(类似find,但失败时引发ValueError):

start = 100 
end = 1000
any_string.index('substring', start, end)

解释

使用比较运算符,因为

语言意图使用,以及其他Python程序员会希望您使用它。

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

原问题要求的相反(补语)不在:

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

这在语义上与“**foo**”中的“foo”相同,但它更具可读性,并在语言中明确提供,以提高可读性。

避免使用__contains__

“contains”方法实现中的行为,

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

返回True。您也可以从超弦的实例调用此函数:

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

但不要。以下划线开头的方法在语义上被认为是非公共的。使用此选项的唯一原因是在实现或扩展in而不是in功能时(例如,如果将str子类化):

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

不要使用查找和索引来测试“包含”

不要使用以下字符串方法测试“contains”:

>>> '**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 comparison运算符更有效。

此外,这些不是in的直接替换。您可能需要处理异常或-1情况,如果它们返回0(因为它们在开头找到了子字符串),则布尔解释为False而不是True。

如果你真的不是any_string.startswith(substring),那就说出来。

性能比较

我们可以比较实现同一目标的各种方式。

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}

如果in使用__contains__,那么in如何比__contains_更快?

这是一个很好的后续问题。

让我们使用感兴趣的方法来分解函数:

>>> from dis import dis
>>> dis(lambda: 'a' in 'b')
  1           0 LOAD_CONST               1 ('a')
              2 LOAD_CONST               2 ('b')
              4 COMPARE_OP               6 (in)
              6 RETURN_VALUE
>>> dis(lambda: 'b'.__contains__('a'))
  1           0 LOAD_CONST               1 ('b')
              2 LOAD_METHOD              0 (__contains__)
              4 LOAD_CONST               2 ('a')
              6 CALL_METHOD              1
              8 RETURN_VALUE

所以我们看到__contains__方法必须单独查找,然后从Python虚拟机调用-这应该可以充分解释差异。

如果只是子字符串搜索,可以使用string.find(“substring”)。

在查找、索引和插入时,您确实需要稍微小心一些,因为它们是子字符串搜索。换句话说,这:

s = "This be a string"
if s.find("is") == -1:
    print("No 'is' here!")
else:
    print("Found 'is' in the string.")

它将在字符串中打印Found“is”。类似地,如果s中的“is”将求值为True。这可能是你想要的,也可能不是你想要的。