Saya mencari string.containsatau string.indexofmetode dengan Python.

Aku ingin melakukan:

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

Anda dapat menggunakan inoperator :

if "blah" not in somestring: 
    continue

Jika itu hanya pencarian substring yang dapat Anda gunakan string.find("substring").

Anda harus sedikit berhati-hati dengan find, index, dan inmeskipun, seperti yang substring pencarian. Dengan kata lain, ini:

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

Itu akan mencetak sama Found 'is' in the string., if "is" in s:akan mengevaluasi True. Ini mungkin atau mungkin bukan yang Anda inginkan.

Apakah Python memiliki string yang berisi metode substring?

Ya, tetapi Python memiliki operator pembanding yang harus Anda gunakan sebagai gantinya, karena bahasa tersebut bermaksud penggunaannya, dan programmer lain akan mengharapkan Anda untuk menggunakannya. Kata kunci itu in, yang digunakan sebagai operator perbandingan:

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

Sebaliknya (komplemen), yang ditanyakan oleh pertanyaan asli, adalah not in:

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

Ini semantik sama dengan not 'foo' in '**foo**'tetapi jauh lebih mudah dibaca dan secara eksplisit disediakan dalam bahasa sebagai peningkatan keterbacaan.

Hindari menggunakan __contains__, finddanindex

Seperti yang dijanjikan, inilah containscaranya:

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

kembali True. Anda juga dapat memanggil fungsi ini dari instance superstring:

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

Tapi jangan. Metode yang dimulai dengan garis bawah dianggap semantik pribadi. Satu-satunya alasan untuk menggunakan ini adalah ketika memperluas indan not infungsionalitas (mis. Jika subclassing 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')

dan sekarang:

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

Selain itu, hindari metode string berikut:

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

Bahasa lain mungkin tidak memiliki metode untuk menguji langsung untuk substring, dan Anda harus menggunakan jenis metode ini, tetapi dengan Python, jauh lebih efisien untuk menggunakan inoperator pembanding.

Perbandingan kinerja

Kita dapat membandingkan berbagai cara untuk mencapai tujuan yang sama.

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

Dan sekarang kita melihat bahwa menggunakan injauh lebih cepat daripada yang lain. Lebih sedikit waktu untuk melakukan operasi yang setara lebih baik:

>>> 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:adalah penggunaan normal, seperti yang dikatakan @Michael - ini bergantung pada inoperator, lebih mudah dibaca dan lebih cepat daripada pemanggilan metode.

Jika Anda benar-benar membutuhkan metode alih-alih operator (mis. Untuk melakukan sesuatu yang aneh key=untuk jenis yang sangat aneh ...?), Itu mungkin 'haystack'.__contains__. Tapi karena contoh Anda adalah untuk digunakan dalam if, saya kira Anda tidak benar-benar bermaksud apa yang Anda katakan ;-). Ini bukan bentuk yang baik (atau dapat dibaca, atau efisien) untuk menggunakan metode khusus secara langsung - mereka seharusnya digunakan, sebagai gantinya, melalui operator dan builtin yang mendelegasikan kepada mereka.

in String dan daftar Python

Berikut adalah beberapa contoh berguna yang berbicara sendiri tentang inmetode ini:

"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]

Peringatan. Daftar adalah iterables, dan inmetode ini bekerja pada iterables, bukan hanya string.

Jika Anda senang "blah" in somestringtetapi menginginkannya menjadi panggilan fungsi / metode, Anda mungkin dapat melakukan ini

import operator

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

Semua operator di Python dapat lebih atau kurang ditemukan dalam modul operator termasuk in.

Jadi rupanya tidak ada yang serupa untuk perbandingan bijaksana. Cara Python yang jelas untuk melakukannya adalah:

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

Anda bisa menggunakannya y.count().

Ini akan mengembalikan nilai integer dari berapa kali sebuah sub string muncul dalam sebuah string.

Sebagai contoh:

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

Inilah jawaban Anda:

if "insert_char_or_string_here" in "insert_string_to_search_here":
    #DOSTUFF

Untuk memeriksa apakah itu salah:

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

ATAU:

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

Anda dapat menggunakan ekspresi reguler untuk mendapatkan kemunculan:

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