Python有字符串容器吗?子字符串方法?


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

我想做的是:

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

您可以使用in操作符:

1
2
if"blah" not in somestring:
    continue
相关讨论

如果只是子字符串搜索，可以使用string.find("substring")。

但是对于find、index和in，您必须要小心一点，因为它们是子字符串搜索。换句话说，就是:

1
2
3
4
5
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__。但是，由于您的示例用于if中，我猜您说的并不是真正的意思;-)。直接使用特殊方法不是一种好的形式(既不便于阅读，也不高效)——它们应该通过委托给它们的操作符和内置程序来使用。

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

方法1:in操作符

可以使用Python的in操作符检查子字符串。它非常简单直观。如果在else False字符串中找到子字符串，则返回True。

1
2
3
4
5
>>>"King" in"King's landing"
True

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

方法2:str.find()方法

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

1
2
3
4
5
6
7
>>> some_string ="valar morghulis"

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

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

我建议您使用第一种方法，因为它更符合python和直觉。

Does Python have a string contains substring method?

是的，但是Python有一个您应该使用的比较操作符，因为该语言打算使用它，而其他程序员希望您使用它。这个关键字是in，它被用作比较运算符:

1
2
>>> 'foo' in '**foo**'
True

反义词(补语)是原问题要求的，是not in:

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

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

避免使用__contains__、find和index

正如所承诺的，下面是contains方法:

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

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

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

但不要。以下划线开头的方法在语义上被认为是私有的。使用它的唯一原因是当扩展in和not in功能时(例如，如果子类化str):

1
2
3
4
5
6
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')

现在:

1
2
3
>>> 'substring' in ns
testing if"substring" in"a string with a substring inside"
True

此外，避免以下字符串方法:

1
2
3
4
5
6
7
8
9
10
11
12
13
>>> '**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比较操作符要有效得多。

性能比较

我们可以比较实现同一目标的不同方法。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
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比其他方法快得多。做相同操作的时间越短越好:

1
2
3
4
5
6
7
8
9
>>> 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}
相关讨论

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

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

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

1
2
3
4
5
# Print all files with dot in home directory
import commands
(st, output) = commands.getstatusoutput('ls -a ~')
print [f for f in output.split('
') if '.' in f ]
相关讨论

in Python字符串和列表

下面是一些关于in方法的有用例子:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
"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方法作用于迭代器，而不仅仅是字符串。

相关讨论

显然，向量比较没有相似之处。一个明显的Python方法是:

1
2
3
4
5
6
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
相关讨论

另一种方法来查找一个字符串是否包含几个字符与布尔返回值(即True或' False):

1
2
3
4
5
6
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
相关讨论

我知道已经有答案了，但我也想补充一下我的观点。

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
"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

也有一些字符串方法:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
"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。

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

Python方法:使用Python的'in'关键字-

in接受两个"参数"，一个在左边(子字符串)，一个在右边，如果左边的参数包含在右边的参数中，则返回True;如果不包含，则返回False。

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

输出:

1
True

非Python方法:使用Python的str.find:

find方法返回字符串在字符串中的位置，如果没有找到，则返回-1。但只要检查一下位置是不是-1。

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

输出:

1
Substring found!
相关讨论

如果您对"blah" in somestring很满意，但是希望它是一个函数调用，那么您可以这样做

1
2
3
4
import operator

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

Python中的所有运算符或多或少都可以在包括in在内的运算符模块中找到。

有四种最简单的方法可以找出子字符串是什么以及子字符串从哪里开始。

The first one is via the Python’s in operator:

1
2
3
4
5
6
7
someString ="Polly is drinking Coca-Cola."

"Coca-Cola" in someString
# Result: True

"Pepsi" in someString
# Result: False

Second way is to use the string’s find() method.

与in运算符被计算为布尔值不同，find方法返回一个整数。如果该子字符串存在，则该整数是子字符串开头的索引，否则返回-1。它是这样工作的:

1
2
3
4
5
6
7
8
9
10
someString ="Polly is drinking Coca-Cola."

someString.find("is")
# Result: 6

someString.find("Pepsi")
# Result: -1

someString.find("Polly")
# Result: 0

还可以指定开始和结束索引来限制搜索。例如:

1
2
3
4
5
6
7
someString ="Polly is drinking Coca-Cola."

someString.find("is", 5, 10)
# Result: 6

someString.find("Polly", 15, 20)
# Result: -1

Third. And, of course, you can use if...is not statement (it works in Python 2.7 and 3.6):

1
2
3
4
5
6
7
8
9
someString ="Polly is drinking Coca-Cola."
substring ="drinking"

if someString.find(substring) is not -1:
    print("Cool! Python found the desired substring!")
else:
    print("Python didn't find the desired substring!")

# Result:"Cool! Python found the desired substring!"

Four. Use the index() method. It's almost the same as the find() method.

1
2
3
4
5
someString ="Polly is drinking Coca-Cola."
x = someString.index("drinking")
print(x)

# Result: 9

希望这个有帮助。

这是你的答案:

1
2
if"insert_char_or_string_here" in"insert_string_to_search_here":
    #DOSTUFF

检查是否为假:

1
2
if not"insert_char_or_string_here" in"insert_string_to_search_here":
    #DOSTUFF

或者:

1
2
if"insert_char_or_string_here" not in"insert_string_to_search_here":
    #DOSTUFF

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

1
2
3
4
5
6
7
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
相关讨论

你可以使用一些方法:

if x in y:y.count()y.find()

1是一个布尔表达式，这意味着它将返回True或False状态取决于是否满足条件。

例句:

1
2
3
4
string ="Hello world"

if"Hello" in string: >>True
if"Python" in string: >>False

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

例句:

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

3将返回给定子字符串初始位置的索引值。如果找不到子字符串，也将返回-1。

例句:

1
2
string.find("Hello")  >>0
string.find("foo")  >>-1

如前所述，您可以像这样使用in操作符:

1
2
3
4
5
6
>>> to_search_in ="String to search in"
>>> to_search ="search"
>>> print(to_search in to_search_in)
True
>>> print(to_search_in.find(to_search))
10

您还可以使用正则表达式来获取发生的情况:

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