Szukam metody string.containslub string.indexofjęzyka Python.

Chcę zrobić:

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

Możesz użyć inoperatora :

if "blah" not in somestring: 
    continue

Jeśli jest to tylko wyszukiwanie podciągów, możesz użyć string.find("substring").

Trzeba być trochę ostrożny z find, indexi inchoć są one podciąg wyszukiwania. Innymi słowy, to:

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

Wypisałby się Found 'is' in the string.podobnie, if "is" in s:oceniałby True. To może być lub nie być to, czego chcesz.

Czy Python ma ciąg zawierający metodę podciągów?

Tak, ale Python ma operator porównania, którego należy użyć zamiast tego, ponieważ język zamierza go używać, a inni programiści oczekują, że będziesz go używać. To słowo kluczowe jest inużywane jako operator porównania:

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

Przeciwnie (uzupełnienie), o które prosi pierwotne pytanie, jest not in:

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

Jest to semantycznie to samo, not 'foo' in '**foo**'ale o wiele bardziej czytelne i wyraźnie przewidziane w języku jako poprawa czytelności.

Unikaj używania __contains__, findorazindex

Zgodnie z obietnicą, oto containsmetoda:

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

zwraca True. Możesz także wywołać tę funkcję z instancji superstringu:

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

Ale nie rób tego. Metody rozpoczynające się od podkreślenia są uważane za semantycznie prywatne. Jedynym powodem, dla którego można to wykorzystać, jest rozszerzenie funkcji ini not in(np. W przypadku podklasy 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')

i teraz:

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

Unikaj również następujących metod ciągu:

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

Inne języki mogą nie mieć żadnych metod bezpośredniego testowania podciągów, więc musisz użyć tego rodzaju metod, ale w Pythonie znacznie bardziej wydajne jest użycie inoperatora porównania.

Porównanie wydajności

Możemy porównać różne sposoby osiągnięcia tego samego celu.

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

A teraz widzimy, że używanie injest znacznie szybsze niż inne. Im mniej czasu na wykonanie równoważnej operacji, tym lepiej:

>>> 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:jest normalnym zastosowaniem, jak mówi @Michael - zależy od inoperatora, jest bardziej czytelny i szybszy niż wywołanie metody.

Jeśli naprawdę potrzebujesz metody zamiast operatora (np. Aby zrobić coś dziwnego key=dla bardzo osobliwego rodzaju ...?), Byłoby to możliwe 'haystack'.__contains__. Ale ponieważ twój przykład jest przeznaczony do użycia if, myślę, że tak naprawdę nie masz na myśli tego, co mówisz ;-). Nie jest dobrą formą (ani czytelną, ani wydajną) używanie specjalnych metod bezpośrednio - są one przeznaczone do użycia przez operatorów i wbudowane w nie funkcje, które je delegują.

in Ciągi i listy w języku Python

Oto kilka przydatnych przykładów, które mówią same za siebie w odniesieniu do inmetody:

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

Zastrzeżenie Listy są iterowalne, a inmetoda działa na iterowalne, a nie tylko na ciągi znaków.

Jeśli jesteś zadowolony, "blah" in somestringale chcesz, aby było to wywołanie funkcji / metody, prawdopodobnie możesz to zrobić

import operator

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

Wszystkich operatorów w Pythonie można mniej więcej znaleźć w module operatora, w tym in.

Najwyraźniej więc nie ma nic podobnego w porównaniu wektorowym. Oczywistym sposobem na zrobienie tego byłoby:

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

Możesz użyć y.count().

Zwraca wartość całkowitą liczby przypadków, gdy podciąć pojawia się w ciągu.

Na przykład:

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

Oto twoja odpowiedź:

if "insert_char_or_string_here" in "insert_string_to_search_here":
    #DOSTUFF

Aby sprawdzić, czy jest to fałsz:

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

LUB:

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

Możesz użyć wyrażeń regularnych, aby uzyskać wystąpienia:

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