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

╰+哭是因爲堅強的太久メ 2024-03-30 09:51 117阅读 0赞

## 问： ##

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

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

我想要做：

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

## 答1: ##

> 一个优秀的自由职业者，应该有对需求敏感和精准需求捕获的能力，而huntsbot.com提供了这个机会

使用 in operator：

if "blah" not in somestring: 
        continue

`在后台，Python 将按顺序使用 __contains__(self, item)、__iter__(self) 和 __getitem__(self, key) 来确定项目是否位于给定的包含中。至少实施其中一种方法以使 in 可用于您的自定义类型。`

`只要确保 somestring 不会是 None。否则你会得到一个 TypeError: argument of type 'NoneType' is not iterable`

`对于字符串，Python in 运算符是否使用 Rabin-Carp 算法？`

`@SamChats 请参阅 stackoverflow.com/questions/18139660/… 以了解实现细节（在 CPython 中；afaik 语言规范在这里没有强制要求任何特定算法）。`

`@Kaz这应该很丑，因为您在思考错误的抽象级别。另一方面，'.so' in filepath.suffixes 非常漂亮，并且明确地说明了您真正想做的事情。`

## 答2: ##

> huntsbot.com汇聚了国内外优秀的初创产品创意，可按收入、分类等筛选，希望这些产品与实践经验能给您带来灵感。

如果它只是一个子字符串搜索，您可以使用 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。这可能是也可能不是您想要的。

`+1 用于突出显示子字符串搜索中涉及的陷阱。显而易见的解决方案是 if ' is ' in s:，它将按（可能）预期的方式返回 False。`

`@aaronasterling 可能很明显，但并不完全正确。如果你有标点符号或者它在开头或结尾怎么办？大写呢？更好的是对 \bis\b （单词边界）进行不区分大小写的正则表达式搜索。`

`为什么这不是 OP 想要的`

`@uh_big_mike_boi 子字符串搜索的问题在于，在此示例中，您要在“This be a string”中查找单词 is。由于 This 中的 is，这将评估为 True。这对于搜索单词的程序来说是不利的，例如发誓过滤器（例如，对“ass”的愚蠢单词检查也会捕获“grass”）。`

## 答3: ##

> 打造属于自己的副业，开启自由职业之旅，从huntsbot.com开始!

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)

解释

使用 in 比较运算符，因为

该语言打算使用它，其他 Python 程序员会期望您使用它。

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

原始问题要求的相反（补充）是not in：

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

这在语义上与 not ‘foo’ in ‘**foo**’ 相同，但它更具可读性，并且在语言中明确提供了可读性改进。

避免使用 **contains**

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

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

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

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

但是不要。以下划线开头的方法在语义上被认为是非公开的。使用它的唯一原因是在实现或扩展 in 和 not 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

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

不要使用以下字符串方法来测试“包含”：

>>> '**foo**'.index('foo')
    2
    >>> '**foo**'.find('foo')
    2
    
    >>> '**oo**'.find('foo')
    -1
    >>> '**oo**'.index('foo')
    
    Traceback (most recent call last):
      File "", line 1, in 
        '**oo**'.index('foo')
    ValueError: substring not found

其他语言可能没有直接测试子字符串的方法，因此您必须使用这些类型的方法，但对于 Python，使用 in 比较运算符效率更高。

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

如果你真的是说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

所以我们看到 .**contains** 方法必须单独查找，然后从 Python 虚拟机中调用 - 这应该足以解释差异。

`为什么要避免 str.index 和 str.find？您还会如何建议某人找到子字符串的索引，而不仅仅是它是否存在？ （或者您的意思是避免使用它们代替 contains - 所以不要使用 s.find(ss) != -1 而不是 ss in s？）`

`正是如此，尽管通过优雅地使用 re 模块可以更好地解决使用这些方法背后的意图。在我编写的任何代码中，我还没有找到 str.index 或 str.find 的用途。`

`请将您的答案扩展到反对使用 str.count 的建议 (string.count(something) != 0)。 颤抖`

`这是对 Python 中普遍需求的一个很好的回答。感谢您提供一些详细的解释！`

`@burningfennec 我在上述答案的末尾解决了您的后续问题。`

## 答4: ##

> huntsbot.com汇聚了国内外优秀的初创产品创意，可按收入、分类等筛选，希望这些产品与实践经验能给您带来灵感。

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

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

`比方法调用快多少？`

## 答5: ##

> huntsbot.com提供全网独家一站式外包任务、远程工作、创意产品分享与订阅服务!

在 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 包

Here’s an answer that shows how it works.

## 答6: ##

> HuntsBot周刊–不定时分享成功产品案例，学习他们如何成功建立自己的副业–huntsbot.com

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

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

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

## 答7: ##

> huntsbot.com聚合了超过10+全球外包任务平台的外包需求，寻找外包任务与机会变的简单与高效。

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

`那是因为有无数种方法可以从原子变量创建产品。您可以将它们填充到一个元组、一个列表（它们是笛卡尔积的形式并且带有一个隐含的顺序），或者它们可以是一个类的命名属性（没有先验顺序）或字典值，或者它们可以是文件一个目录，或者其他什么。每当您可以在“容器”或“上下文”中唯一标识（iter 或 getitem）某物时，您就可以将该“容器”视为一种向量并在其上定义二进制操作。 en.wikipedia.org/wiki/…`

`不值得将 in 与列表一起使用，因为它对元素进行线性扫描并且比较慢。改用一个集合，尤其是在要重复进行成员资格测试的情况下。`

## 答8: ##

> huntsbot.com全球7大洲远程工作机会，探索不一样的工作方式

您可以使用 y.count()。

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

例如：

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

`当您只想检查字符串是否存在时，计算字符串的成本很高......`

`2010 年原始帖子中存在的方法，所以我最终编辑了它们，并得到了社区的共识（请参阅元帖子 meta.stackoverflow.com/questions/385063/…）`

`不。我的观点是“为什么要回答与 9 年前其他人完全相同的问题”？`

`因为我正在管理该网站...我在 meta meta.stackoverflow.com/questions/385063/… 上提出了问题`

`几乎可以肯定右移不是你想要在这里做的。`

## 答9: ##

> 与HuntsBot一起，探索全球自由职业机会–huntsbot.com

这是你的答案：

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

`PEP 8 更喜欢“如果 x 不在 y 中”而不是“如果 x 在 y 中”。`

## 答10: ##

> huntsbot.com聚合了超过10+全球外包任务平台的外包需求，寻找外包任务与机会变的简单与高效。

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

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

原文链接：[https://www.huntsbot.com/qa/JAvj/does-python-have-a-string-contains-substring-method?lang=zh\_CN&from=csdn][https_www.huntsbot.com_qa_JAvj_does-python-have-a-string-contains-substring-method_lang_zh_CN_from_csdn]

> huntsbot.com聚合了超过10+全球外包任务平台的外包需求，寻找外包任务与机会变的简单与高效。

[https_www.huntsbot.com_qa_JAvj_does-python-have-a-string-contains-substring-method_lang_zh_CN_from_csdn]: https://www.huntsbot.com/qa/JAvj/does-python-have-a-string-contains-substring-method?lang=zh_CN&from=csdn