Python是否有一个字符串’contains’substring方法?

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

我想要做:

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


您可以使用in操作员

if "blah" not in somestring: 
    continue

如果它只是一个子字符串搜索,你可以使用string.find("substring")

你必须与小心一点findindexin虽然,因为它们是字符串搜索。换句话说,这个:

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


if needle in haystack:是@Michael所说的正常用法 – 它依赖于in操作符,比方法调用更具可读性和更快速度。

如果你确实需要一种方法而不是操作员(例如,key=为了一种非常奇怪的方式做一些奇怪的事情?),那就是了'haystack'.__contains__。但是因为你的例子是用在an中的if,所以我猜你并不是真的说你在说什么;-)。它不是直接使用特殊方法的好形式(也不可读,也不是有效的) – 它们是用来代替通过委托给它们的运算符和内建函数的。


基本上,你想在Python中的字符串中找到一个子字符串。有两种方法可以在Python中搜索字符串中的子字符串。

方法1:in运营商

您可以使用Python的in运算符来检查子字符串。它非常简单直观。True如果在字符串else中找到子字符串,它将返回False

>>> "King" in "King's landing"
True

>>> "Jon Snow" in "King's landing"
False

方法2:str.find()方法

第二种方法是使用该str.find()方法。在这里,我们.find()在要找到子字符串的字符串上调用该方法。我们将子字符串传递给find()方法并检查其返回值。如果它的值不是-1,则在字符串中找到子字符串,否则不会。返回的值是找到子字符串的索引。

>>> some_string = "valar morghulis"

>>> some_string.find("morghulis")
6

>>> some_string.find("dohaeris")
-1

我建议你使用第一种方法,因为它更加Pythonic和直观。


Python有一个包含子串方法的字符串吗?

是的,但是Python有一个你应该用的比较运算符,因为这个语言意图使用它,其他程序员会希望你使用它。该关键字是in作为比较运算符使用的:

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

原始问题要求的相反(补充)是not in

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

这在语义上是相同的,not 'foo' in '**foo**'但它更易于阅读,并且在语言中明确提供了可读性改进。

避免使用__contains__findindex

如所承诺的,这里是contains方法:

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

返回True。你也可以从超字符串的实例中调用这个函数:

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

但是不要。以下划线开头的方法被认为是语义私有的。使用这个的唯一原因是扩展innot in功能(例如,如果子类str):

class NoisyString(str):
    def __contains__(self, other):
        print('testing if "{0}" in "{1}"'.format(other, 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 "<pyshell#40>", line 1, in <module>
    '**oo**'.index('foo')
ValueError: substring not found

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

性能比较

我们可以比较实现相同目标的各种方式。

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}

添加评论

友情链接:蝴蝶教程