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', ' ', ' ']