Python 是否有字符串“包含”子字符串方法？

Question

这个问题的答案是社区的努力。 编辑现有答案以改进这篇文章。 它目前不接受新的答案或互动。

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

我想要做：

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

Answer 1

您可以使用in运算符：

if "blah" not in somestring: 
    continue

Answer 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 。 这可能是也可能不是您想要的。

Answer 3

Python 有字符串包含子字符串的方法吗？<\/h2><\/blockquote>

将使用关键字in<\/code>覆盖99%<\/strong>的用例，该关键字返回True<\/code>或False<\/code> ：

 'substring' in any_string<\/code><\/pre>
对于获取索引的用例，请使用str.find<\/code> （失败时返回 -1，并具有可选的位置参数）：
 start = 0 stop = len(any_string) any_string.find('substring', start, stop)<\/code><\/pre>
或str.index<\/code> （类似于find<\/code>但在失败时引发 ValueError ）：
 start = 100 end = 1000 any_string.index('substring', start, end)<\/code><\/pre>
解释<\/h2>
使用in<\/code>比较运算符，因为
 
                
 
                 
该语言打算使用它，并且<\/li>
 
                 
其他 Python 程序员会希望您使用它。<\/li><\/ol>
 >>> 'foo' in '**foo**' True<\/code><\/pre>
原始问题要求的相反（补充） not in<\/code> ：
 >>> 'foo' not in '**foo**' # returns False False<\/code><\/pre>
这在语义上与not 'foo' in '**foo**'<\/code>相同，但它更具可读性，并且作为可读性改进在语言中明确提供。
避免使用__contains__<\/code><\/h2>
 “包含”方法实现了in<\/code>的行为。这个例子，
 str.__contains__('**foo**', 'foo')<\/code><\/pre>
返回True<\/code> 。您还可以从超字符串的实例中调用此函数：
 '**foo**'.__contains__('foo')<\/code><\/pre>
但是不要。以下划线开头的方法在语义上被认为是非公开的。使用它的唯一原因是在实现或扩展in<\/code>和not in<\/code>功能时（例如，如果子类化str<\/code> ）：
 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')<\/code><\/pre>
现在：
 >>> 'substring' in ns testing if "substring" in "a string with a substring inside" True<\/code><\/pre>
不要使用find<\/code>和index<\/code>来测试“包含”<\/h2>
不要使用以下字符串方法来测试“包含”：
 >>> '**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<\/code><\/pre>
其他语言可能没有直接测试子字符串的方法，因此您必须使用这些类型的方法，但是对于 Python，使用in<\/code>比较运算符效率更高。
此外，这些都不落于替代in<\/code> 。您可能必须处理异常或-1<\/code>情况，如果它们返回0<\/code> （因为它们在开头找到了子字符串），则布尔解释为False<\/code>而不是True<\/code> 。
如果你的意思not any_string.startswith(substring)<\/code>那就说出来。
性能比较<\/h2>
我们可以比较实现同一目标的各种方法。
 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'))), }<\/code><\/pre>
现在我们看到使用in<\/code>比其他的要快得多。做等效操作的时间越少越好：
 >>> 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}<\/code><\/pre>
如何能in<\/code>快于__contains__<\/code>如果in<\/code>使用__contains__<\/code> ？<\/h3>
这是一个很好的后续问题。
让我们用感兴趣的方法反汇编函数：
 >>> 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<\/code><\/pre>
所以我们看到.__contains__<\/code>方法必须单独查找，然后从 Python 虚拟机调用 - 这应该足以解释差异。
"
 
                

Answer 4

if needle in haystack:是正常使用，正如@Michael 所说——它依赖于in运算符，比方法调用更具可读性和更快。

如果你真的需要一个方法而不是一个运算符（例如，为一个非常奇特的排序做一些奇怪的key= ......？），那就是'haystack'.__contains__ 。 但是由于您的示例用于if ，我想您并不是真正的意思；-)。 直接使用特殊方法不是一种好的形式（既不可读，也不高效）——它们应该通过委托给它们的运算符和内置函数来使用。

Answer 5

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

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

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

这是一个显示其工作原理的答案。

Answer 6

如果您"blah" in somestring感到满意，但希望它是一个函数/方法调用，您可以这样做

import operator

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

Python 中的所有运算符或多或少都可以在运算符模块中找到，包括in 。

Answer 7

所以显然向量比较没有任何相似之处。 一个明显的 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

Answer 8

您可以使用y.count() 。

它将返回子字符串在字符串中出现的次数的整数值。

例如：

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

Answer 9

这是你的答案：

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

Answer 10

您可以使用正则表达式来获取出现次数：

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