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

Question

. Edit existing answers to improve this post. It is not currently accepting new answers or interactions.

I'm looking for a string.contains or string.indexof method in Python.

I want to do:

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

Answer 1

You can use the in operator :

if "blah" not in somestring: 
    continue

Answer 2

If it's just a substring search you can use string.find("substring") .

You do have to be a little careful with find , index , and in though, as they are substring searches. In other words, this:

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

It would print Found 'is' in the string. Similarly, if "is" in s: would evaluate to True . This may or may not be what you want.

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: is the normal use, as @Michael says -- it relies on the in operator, more readable and faster than a method call.

If you truly need a method instead of an operator (eg to do some weird key= for a very peculiar sort...?), that would be 'haystack'.__contains__ . But since your example is for use in an if , I guess you don't really mean what you say;-). It's not good form (nor readable, nor efficient) to use special methods directly -- they're meant to be used, instead, through the operators and builtins that delegate to them.

Answer 5

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

Caveat. Lists are iterables, and the in method acts on iterables, not just strings.

If you want to compare strings in a more fuzzy way to measure how "alike" they are, consider using the Levenshtein package

Here's an answer that shows how it works.

Answer 6

If you are happy with "blah" in somestring but want it to be a function/method call, you can probably do this

import operator

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

All operators in Python can be more or less found in the operator module including in .

Answer 7

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

Answer 8

You can use y.count() .

It will return the integer value of the number of times a sub string appears in a string.

For example:

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

Answer 9

Here is your answer:

if "insert_char_or_string_here" in "insert_string_to_search_here":
    #DOSTUFF

For checking if it is false:

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

Answer 10

You can use regular expressions to get the occurrences:

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