提问



我在Python中寻找string.containsstring.indexof方法。


我想要做:


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

最佳参考


您可以使用in运算符:[82]


if "blah" not in somestring: 
    continue

其它参考1


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

其它参考2


if needle in haystack:是正常使用,正如@Michael所说 - 它依赖于in运算符,比方法调用更可读和更快。[83]


如果你真的需要一个方法而不是一个算子(例如做一些奇怪的key=非常奇怪的那种......?),那就是'haystack'.__contains__。但是因为你的例子是用于if,我猜你并不真正意味着你所说的;-)。直接使用特殊方法不是好形式(也不可读,也不高效) - 他们意味着要通过委托给他们的运营商和内置人员来使用。[84]

其它参考3


基本上,您希望在python中的字符串中查找子字符串。有两种方法可以在Python中搜索字符串中的子字符串。


方法1:in运算符


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


>>> "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和直观。

其它参考4



  

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}



其它参考5


不,没有任何string.contains(str)方法,但有in运算符:


if substring in someString:
    print "It's there!!!"


这是一个更复杂的工作示例:


# Print all files with dot in home directory
import commands
(st, output) = commands.getstatusoutput('ls -a ~')
print [f for f in output.split('\n') if '.' in f ]

其它参考6


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


警告。列表是可迭代的,in方法作用于迭代,而不仅仅是字符串。

其它参考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

其它参考8


使用布尔返回值(即True或False查找字符串是否包含几个字符的另一种方法:


str1 = "This be a string"
find_this = "tr"
if find_this in str1:
    print find_this, " is been found in ", str1
else:
    print find_this, " is not found in ", str1

其它参考9


在Python中,有两种简单的方法可以实现这一点:


Pythonic方式:在关键字 - 中使用Python


in有两个参数,一个在左边( substring ),一个在右边,如果左边的参数包含在右边的参数中,则返回True不,它返回False


example_string = "This is an example string"
substring = "example"
print(substring in example_string)


输出:


True


非Pythonic方式:使用Python的str.find:


find方法返回字符串中字符串的位置,如果未找到则返回-1。但只需检查位置是否为-1。


if example_string.find(substring) != -1:
    print('Substring found!')
else:
    print('Substring not found!')


输出:


Substring found!

其它参考10


这是你的答案:


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

其它参考11


如果你对"blah" in somestring感到满意,但希望它是一个函数调用,你可以这样做


import operator

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


Python中的所有运算符都可以或多或少地在运算符模块中找到,包括in[85]

其它参考12


我看到已有答案,但我想加上我的两分钱。


在Python中有一些函数可以做到这一点,但最简单(也是最受欢迎)的方法是使用关键字
in:


"test" in "testtext"
True

"abc" in "abcdefg"
True

"abc" in "Abc"
False

"ABC" in "abc"
False

"abc" in "def"
False

"abc" in ["abc", "def", "ghi"]
True





还有一些字符串方法:


"xxabcxx".find("abc")
2 #returns the index of the first match

"xxabcxx".find("cde")
-1 #returns -1 if the substring 
#could not be found in the string

# and:

"xxabcxx".index("abc")
2

"xxabcxx".index("cde")
ValueError: substring not found
#raises ValueError...


关于表现:


一般来说in是找到子串的禁食方法......


find略快于index





希望我能帮忙!

其它参考13


如果您正在寻找对整个单词不区分大小写的搜索,而不是另一个单词中包含的子字符串:


import string

s = 'This is my text example'
if 'is' not in (word.lower() 
    for split_char in string.punctuation + string.whitespace 
    for word in s.split(split_char)):
    # do something