python字串處理 Python有一個字符串'contains'substring方法嗎?




python字串處理 (12)

if needle in haystack:正常使用,正如@Michael所說 - 它依賴於in運算符,比方法調用更可讀,更快。

如果你真的需要一個方法而不是一個操作符(例如做一些奇怪的key=非常奇怪的那種......?),那就是'haystack'.__contains__ 。 但是因為你的例子是用於if ,我想你並不是真的意思是你說的;-)。 直接使用特殊方法不是好形式(也不可讀,也不高效) - 而是通過委託給它們的運算符和內置函數來使用它們。

我正在尋找Python中的string.containsstring.indexof方法。

我想要做:

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

這是你的答案:

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

顯然,對於矢量方式的比較,沒有類似的東西。 一種明顯的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

Python有一個字符串包含substring方法嗎?

是的,但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 comparison運算符會更有效。

性能比較

我們可以比較實現相同目標的各種方式。

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}

在Python中,有兩種​​簡單的方法可以實現這一點:

Pythonic方式:使用Python的'in'關鍵字 -

in有兩個“參數”,一個在左邊( 子串 ),一個在右邊,如果左邊的參數包含在右邊的參數中,則返回False ,如果不包含,則返回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!

如果你"blah" in somestring感到滿意,但希望它是一個函數調用,你可以這樣做

import operator

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

Python中的所有運算符都可以或多或少地在運算符模塊中找到,包括。


如果它只是一個子字符串搜索,你可以使用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.打印Found 'is' in the string. 同樣, if "is" in s:將評估為True 。 這可能是也可能不是你想要的。


您可以使用in運算符

if "blah" not in somestring: 
    continue

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方法作用於迭代,而不僅僅是字符串。


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

方法1: in運營商中

您可以使用Python的in運算符來檢查子字符串。 它非常簡單直觀。 如果在字符串中找到子字符串,則返回True ,否則返回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和直觀。


使用布爾返回值(即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

不,沒有任何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 ]




contains