Estou procurando um método string.containsou string.indexofem Python.

Eu quero fazer:

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

Você pode usar o inoperador :

if "blah" not in somestring: 
    continue

Se for apenas uma pesquisa de substring, você pode usar string.find("substring").

Você tem que ser um pouco cuidadoso com find, indexe, inno entanto, como eles são substring pesquisas. Em outras palavras, isso:

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

Seria imprimir Found 'is' in the string.Da mesma forma, if "is" in s:avaliaria para True. Isso pode ou não ser o que você deseja.

O Python possui uma string que contém o método de substring?

Sim, mas o Python possui um operador de comparação que você deve usar, porque a linguagem pretende seu uso, e outros programadores esperam que você o use. Essa palavra-chave é inusada como um operador de comparação:

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

O oposto (complemento), que a pergunta original pede, é not in:

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

É semanticamente o mesmo, not 'foo' in '**foo**'mas é muito mais legível e explicitamente previsto no idioma como uma melhoria de legibilidade.

Evitar o uso __contains__, findeindex

Como prometido, aqui está o containsmétodo:

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

retorna True. Você também pode chamar esta função a partir da instância da supercorda:

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

Mas não. Os métodos que começam com sublinhados são considerados semanticamente privados. A única razão para usar isso é ao estender a funcionalidade ine not in(por exemplo, se estiver subclassificando 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')

e agora:

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

Além disso, evite os seguintes métodos de string:

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

Outras linguagens podem não ter métodos para testar diretamente substrings e, portanto, você teria que usar esses tipos de métodos, mas com o Python, é muito mais eficiente usar o inoperador de comparação.

Comparações de desempenho

Podemos comparar várias maneiras de alcançar o mesmo objetivo.

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

E agora vemos que o uso iné muito mais rápido que os outros. Menos tempo para realizar uma operação equivalente é melhor:

>>> 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:é o uso normal, como o @Michael diz - depende do inoperador, mais legível e mais rápido que uma chamada de método.

Se você realmente precisa de um método em vez de um operador (por exemplo, fazer algo estranho key=para um tipo muito peculiar ...?), Isso seria 'haystack'.__contains__. Mas como seu exemplo é para uso em um if, acho que você não está realmente falando sério ;-). Não é uma boa forma (nem legível, nem eficiente) usar métodos especiais diretamente - eles devem ser usados, em vez disso, através dos operadores e componentes internos que os delegam.

in Strings e listas Python

Aqui estão alguns exemplos úteis que falam por si sobre o inmétodo:

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

Embargo. Listas são iteráveis, e o inmétodo atua em iterables, não apenas em strings.

Se você está satisfeito, "blah" in somestringmas deseja que seja uma chamada de função / método, provavelmente poderá fazer isso

import operator

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

Todos os operadores no Python podem ser mais ou menos encontrados no módulo do operador inclusive in.

Então, aparentemente, não há nada semelhante para a comparação vetorial. Uma maneira óbvia de Python para fazer isso seria:

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

Você pode usar y.count().

Ele retornará o valor inteiro do número de vezes que uma sub string aparecerá em uma string.

Por exemplo:

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

Aqui está a sua resposta:

if "insert_char_or_string_here" in "insert_string_to_search_here":
    #DOSTUFF

Para verificar se é falso:

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

OU:

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

Você pode usar expressões regulares para obter as ocorrências:

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