Tôi đang tìm kiếm một string.containshoặc string.indexofphương thức trong Python.

Tôi muốn làm:

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

Bạn có thể sử dụng intoán tử :

if "blah" not in somestring: 
    continue

Nếu đó chỉ là một tìm kiếm chuỗi con, bạn có thể sử dụng string.find("substring").

Bạn không cần phải là một chút cẩn thận với find, indexvà inmặc dù, khi chúng được substring tìm kiếm. Nói cách khác, điều này:

s = "This be a string"
if s.find("is") == -1:
    print("No 'is' here!")
else:
    print("Found 'is' in the string.")

Nó sẽ in Found 'is' in the string.Tương tự, if "is" in s:sẽ đánh giá True. Điều này có thể hoặc không thể là những gì bạn muốn.

Python có một chuỗi chứa phương thức chuỗi con không?

Có, nhưng Python có một toán tử so sánh mà bạn nên sử dụng thay thế, bởi vì ngôn ngữ dự định sử dụng nó và các lập trình viên khác sẽ mong đợi bạn sử dụng nó. Từ khóa inđó, được sử dụng như một toán tử so sánh:

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

Ngược lại (bổ sung), mà câu hỏi ban đầu yêu cầu, là not in:

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

Điều này về mặt ngữ nghĩa giống như not 'foo' in '**foo**'nhưng nó dễ đọc hơn và được cung cấp rõ ràng bằng ngôn ngữ như một sự cải thiện khả năng đọc.

Tránh sử dụng __contains__, findvàindex

Như đã hứa, đây là containsphương pháp:

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

trả lại True. Bạn cũng có thể gọi hàm này từ thể hiện của siêu chuỗi:

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

Nhưng đừng. Các phương thức bắt đầu bằng dấu gạch dưới được coi là riêng tư về mặt ngữ nghĩa. Lý do duy nhất để sử dụng điều này là khi mở rộng invà not inchức năng (ví dụ: nếu phân lớp 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')

và bây giờ:

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

Ngoài ra, tránh các phương thức chuỗi sau:

>>> '**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

Các ngôn ngữ khác có thể không có phương pháp để kiểm tra trực tiếp các chuỗi con và vì vậy bạn sẽ phải sử dụng các loại phương thức này, nhưng với Python, sử dụng intoán tử so sánh sẽ hiệu quả hơn nhiều .

So sánh hiệu suất

Chúng ta có thể so sánh nhiều cách khác nhau để hoàn thành cùng một mục tiêu.

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'))),
}

Và bây giờ chúng ta thấy rằng việc sử dụng innhanh hơn nhiều so với những người khác. Ít thời gian hơn để thực hiện một thao tác tương đương là tốt hơn:

>>> 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}

if needle in haystack:là cách sử dụng bình thường, như @Michael nói - nó phụ thuộc vào intoán tử, dễ đọc hơn và nhanh hơn so với một cuộc gọi phương thức.

Nếu bạn thực sự cần một phương thức thay vì một toán tử (ví dụ để thực hiện một số điều kỳ lạ key=đối với một loại rất đặc biệt ...?), Thì đó sẽ là 'haystack'.__contains__. Nhưng vì ví dụ của bạn là để sử dụng trong một if, tôi đoán bạn không thực sự có nghĩa là những gì bạn nói ;-). Đây không phải là hình thức tốt (cũng không thể đọc, cũng không hiệu quả) để sử dụng trực tiếp các phương pháp đặc biệt - thay vào đó, chúng được sử dụng thông qua các toán tử và nội trang được ủy quyền cho chúng.

in Danh sách và chuỗi Python

Dưới đây là một vài ví dụ hữu ích tự nói về inphương pháp:

"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

["foo" in a for a in ["fo", "o", "foobar"]]
[False, False, True]

Hãy cẩn thận. Danh sách là iterables và inphương thức hoạt động trên iterables, không chỉ chuỗi.

Nếu bạn hài lòng với "blah" in somestringnhưng muốn nó là một cuộc gọi hàm / phương thức, có lẽ bạn có thể làm điều này

import operator

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

Tất cả các toán tử trong Python có thể được tìm thấy ít nhiều trong mô đun toán tử bao gồm in.

Vì vậy, rõ ràng không có gì tương tự để so sánh vector-khôn ngoan. Một cách Python rõ ràng để làm như vậy sẽ là:

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

Bạn có thể sử dụng y.count().

Nó sẽ trả về giá trị nguyên của số lần một chuỗi con xuất hiện trong một chuỗi.

Ví dụ:

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

Đây là câu trả lời của bạn:

if "insert_char_or_string_here" in "insert_string_to_search_here":
    #DOSTUFF

Để kiểm tra nếu nó sai:

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

HOẶC LÀ:

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

Bạn có thể sử dụng các biểu thức thông thường để có được các lần xuất hiện:

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