Я'ищу метод string.contains
или string.indexof
в Python.
Я хочу сделать:
if not somestring.contains("blah"):
continue
Вы можете использовать оператор in
:
if "blah" not in somestring:
continue
Если это просто поиск подстроки, вы можете использовать string.find("substring")
.
Однако с find
, index
и in
нужно быть немного осторожным, поскольку они являются подстрочным поиском. Другими словами, это:
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
. Это может быть или не быть тем, что вам нужно.
Как говорит @Michael, if needle in haystack:
- это обычное использование - оно опирается на оператор in
, более читабельный и быстрый, чем вызов метода.
Если вам действительно нужен метод вместо оператора (например, чтобы сделать какой-то странный key=
для очень необычного сорта...?), это будет 'haystack'.__contains__
. Но поскольку ваш пример предназначен для использования в if
, я думаю, вы не совсем то имеете в виду, что говорите;-). Это не очень хорошая форма (не читабельная и не эффективная) использовать специальные методы напрямую - они должны использоваться через операторы и встроенные модули, которые делегируют их.
ли в Python есть строка содержит подстроку метод?
Да, но в Python есть оператор сравнения, который следует использовать вместо них, потому что язык предполагает его использование, и другие программисты будут ожидать вас, чтобы использовать его. Ключевое слово "в", который используется как оператор сравнения:
>>> 'foo' in '**foo**'
True
Наоборот (дополнения), которые первоначально заданного вопроса, это не в
:
>>> 'foo' not in '**foo**' # returns False
False
Это семантически же, как не 'фу' в 'фу', но это'ы гораздо более читабельным и не предусмотрено прямо в язык как улучшение читаемости.
__содержит__
, найти
, и индекс
Как и обещал, здесь'ы содержит
метод:
str.__contains__('**foo**', 'foo')
возвращает true
. Вы также можете вызвать эту функцию из экземпляра суперструн:
'**foo**'.__contains__('foo')
Но Дон'т. Методы, которые начинаются с подчеркивания, считаются семантически частная. Единственная причина, чтобы использовать это при удлинении В
и не в
функциональность (например, если наследование ул.``):
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, гораздо эффективнее использовать в
оператор сравнения.
Мы можем сравнивать различные способы решения одной и той же цели.
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'))),
}
И теперь мы видим, что использование в
гораздо быстрее, чем другие.
Меньше времени, чтобы сделать такую же операцию, лучше:
>>> 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}
в <!--
Каждый любит хороший пользуюсь. Здесь'с помощью панды и matplotlib:
import pandas
import matplotlib.pyplot as plt
s = pandas.Series(list(perf_dict.values()), index=list(perf_dict.keys()))
s.plot('bar')
plt.show()
-->
Вот несколько полезных примеров, которые говорят сами за себя О в
метод:
"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
Нюанс. Списки, итераторы, и в
метод действует на итераторы, а не только строки.
Так что, видимо, нет ничего похожего на вектор-мудрое сравнение. Очевидная на 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
Если вы не довольны в "мля" в somestring
но хочу, чтобы это была функция/метод вызов, вы можете, вероятно, сделать это
import operator
if not operator.contains(somestring, "blah"):
continue
Все операторы в Python могут быть более или менее нашли в [модуль] оператор1, в том числе "в".
Вы можете использовать г.граф()
.
Он будет возвращать целочисленное значение количества раз появляется суб строку в строку.
Например:
string.count("bah") >> 0
string.count("Hello") >> 1
Вот ваш ответ:
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
Вы можете использовать регулярные выражения, чтобы получить экземпляры:
>>> import re
>>> print(re.findall(r'( |t)', to_search_in)) # searches for t or space
['t', ' ', 't', ' ', ' ']