我正在寻找Python中的string.contains或string.indexof方法。
我想做的是:
if not somestring.contains("blah"):
continue
我正在寻找Python中的string.contains或string.indexof方法。
我想做的是:
if not somestring.contains("blah"):
continue
当前回答
使用in运算符:
if "blah" not in somestring:
continue
其他回答
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)
解释
使用比较运算符,因为
语言意图使用,以及其他Python程序员会希望您使用它。
>>> 'foo' in '**foo**'
True
原问题要求的相反(补语)不在:
>>> 'foo' not in '**foo**' # returns False
False
这在语义上与“**foo**”中的“foo”相同,但它更具可读性,并在语言中明确提供,以提高可读性。
避免使用__contains__
“contains”方法实现中的行为,
str.__contains__('**foo**', 'foo')
返回True。您也可以从超弦的实例调用此函数:
'**foo**'.__contains__('foo')
但不要。以下划线开头的方法在语义上被认为是非公共的。使用此选项的唯一原因是在实现或扩展in而不是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
不要使用查找和索引来测试“包含”
不要使用以下字符串方法测试“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 comparison运算符更有效。
此外,这些不是in的直接替换。您可能需要处理异常或-1情况,如果它们返回0(因为它们在开头找到了子字符串),则布尔解释为False而不是True。
如果你真的不是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虚拟机调用-这应该可以充分解释差异。
如果您对某个字符串中的“blah”感到满意,但希望它是一个函数/方法调用,那么您可能可以这样做
import operator
if not operator.contains(somestring, "blah"):
continue
Python中的所有运算符或多或少都可以在运算符模块中找到,包括中的。
如果只是子字符串搜索,可以使用string.find(“substring”)。
在查找、索引和插入时,您确实需要稍微小心一些,因为它们是子字符串搜索。换句话说,这:
s = "This be a string"
if s.find("is") == -1:
print("No 'is' here!")
else:
print("Found 'is' in the string.")
它将在字符串中打印Found“is”。类似地,如果s中的“is”将求值为True。这可能是你想要的,也可能不是你想要的。
使用in运算符:
if "blah" not in somestring:
continue
所以很明显,矢量比较没有类似的东西。一种明显的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