如果只是一个子字符串搜索，则可以使用 .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

使用 in 运算符：

if "blah" not in somestring: 
    continue

注意：这区分大小写。

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

如果你真的需要一种方法而不是一个运算符（例如，为一个非常奇特的分类做一些奇怪的事情......？），那将是“大海捞针”.__contains__。但是，由于您的示例用于 ，我猜您所说的并不是真的;直接使用特殊方法不是好的形式（也不是可读的，也不是有效的）——它们应该通过委托给它们的运算符和内置函数来使用。key=if

Python 有包含子字符串方法的字符串吗？

99% 的用例将使用关键字 ， 进行覆盖，该关键字返回 或 ：inTrueFalse

'substring' in any_string

对于获取索引的用例，请使用（失败时返回 -1，并具有可选的位置参数）：str.find

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

或（类似，但在失败时引发 ValueError）：str.indexfind

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

解释

使用比较运算符，因为in

1. 该语言的用法，以及
2. 其他 Python 程序员会希望您使用它。

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

原来的问题要求的相反（补语）是：not in

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

这在语义上与相同，但它更具可读性，并且在语言中明确规定为可读性改进。not 'foo' in '**foo**'

避免使用__contains__

“contains” 方法实现 的行为。这个例子，in

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

返回。您也可以从超字符串的实例中调用此函数：True

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

但不要。以下划线开头的方法在语义上被视为非公共方法。使用它的唯一原因是在实现或扩展 and 功能时（例如，如果子类化）：innot instr

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

不要使用和测试“包含”findindex

请勿使用以下字符串方法来测试“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

此外，这些不是 的直接替代品。您可能需要处理异常或情况，如果它们返回（因为它们在开头找到了子字符串），则布尔解释是 而不是 .in-10FalseTrue

如果你真的是想说，那就说出来。not 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

因此，我们看到必须单独查找该方法，然后从 Python 虚拟机调用该方法 - 这应该充分解释了差异。.__contains__

这是你的答案：

if "insert_char_or_string_here" in "insert_string_to_search_here":
    #DOSTUFF

要检查它是否为 false：

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

BRW公司

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

因此，显然没有类似的向量比较。一个明显的 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

inPython 字符串和列表

以下是一些有用的示例，这些示例说明了该方法的正确性：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 包

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

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

import operator

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

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

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

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

您可以使用 .y.count()

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

例如：

string.count("bah")   # gives 0
string.count("Hello") # gives 1