method - substring of string python




Python tem uma string 'contains' substring method? (10)

Estou procurando um método string.indexof ou string.indexof no Python.

Eu quero fazer:

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

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

Sim, mas o Python tem um operador de comparação que você deve usar, porque a linguagem pretende usá-lo e outros programadores esperam que você o use. Essa palavra-chave está in , que é usada como um operador de comparação:

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

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

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

Isso é semanticamente o mesmo que not 'foo' in '**foo**' mas é muito mais legível e explicitamente fornecido na linguagem como uma melhoria de legibilidade.

Evite usar __contains__ , find e index

Como prometido, aqui está o método contains :

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

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

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

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

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 operador de comparação.

Comparações de desempenho

Podemos comparar várias formas 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 usar é muito mais rápido que os outros. Menos tempo para fazer 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}

in strings e listas in Python

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

"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

Embargo. As listas são iteráveis ​​e o método in age em iteráveis, não apenas em strings.


Basicamente, você quer encontrar uma substring em uma string em python. Há duas maneiras de procurar por uma substring em uma string no Python.

Método 1: in operador

Você pode usar o operador Python's in para verificar uma substring. É bem simples e intuitivo. Ele retornará True se a substring for encontrada na string else False .

>>> "King" in "King's landing"
True

>>> "Jon Snow" in "King's landing"
False

Método 2: método str.find()

O segundo método é usar o método str.find() . Aqui, chamamos o método .find() na string na qual a substring é encontrada. Passamos a substring para o método find () e verificamos seu valor de retorno. Se seu valor for diferente de -1, a substring foi localizada na string, caso contrário, não. O valor retornado é o índice em que a substring foi encontrada.

>>> some_string = "valar morghulis"

>>> some_string.find("morghulis")
6

>>> some_string.find("dohaeris")
-1

Eu recomendaria que você usasse o primeiro método, pois é mais Pythonico e intuitivo.


Em Python existem duas maneiras simples de conseguir isso:

A maneira Pythonic: Usando o 'em' palavra-chave do Python

in leva dois "argumentos", um à esquerda ( substring ) e um à direita e retorna True se o argumento da esquerda estiver contido no argumento rightside e se não, retorna False .

example_string = "This is an example string"
substring = "example"
print(substring in example_string)

Saída:

True

A maneira não-Pythonica: Usando o str.find do Python:

O método find retorna a posição da string dentro da string ou -1 se não for encontrada. Mas simplesmente verifique se a posição não é -1.

if example_string.find(substring) != -1:
    print('Substring found!')
else:
    print('Substring not found!')

Saída:

Substring found!

Eu vejo que já existem respostas, mas eu quero adicionar meus dois centavos também.

No Python existem funções para fazer isso, mas o método mais simples (e principalmente preferido) é usar a palavra-chave in :

"test" in "testtext"
True

"abc" in "abcdefg"
True

"abc" in "Abc"
False

"ABC" in "abc"
False

"abc" in "def"
False

"abc" in ["abc", "def", "ghi"]
True

Existem alguns métodos de string também:

"xxabcxx".find("abc")
2 #returns the index of the first match

"xxabcxx".find("cde")
-1 #returns -1 if the substring 
#could not be found in the string

# and:

"xxabcxx".index("abc")
2

"xxabcxx".index("cde")
ValueError: substring not found
#raises ValueError...

Sobre o desempenho:

Em geral in é o método em jejum para encontrar uma substring ...

find é um pouco mais rápido que o index

Espero que eu possa ajudar!


Não, não há nenhum string.contains(str) , mas há o operador in :

if substring in someString:
    print "It's there!!!"

Aqui está um exemplo de trabalho mais complexo:

# Print all files with dot in home directory
import commands
(st, output) = commands.getstatusoutput('ls -a ~')
print [f for f in output.split('\n') if '.' in f ]

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

Você precisa ter um pouco de cuidado com find , index e, in entanto, como eles são pesquisas de substring. 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."

Ele iria imprimir Found 'is' in the string. Da mesma forma, if "is" in s: seria avaliado como True . Isso pode ou não ser o que você quer.


Se você está feliz com "blah" in somestring mas quer que seja uma chamada de função, você provavelmente pode fazer isso

import operator

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

Todos os operadores em Python podem ser mais ou menos encontrados no módulo operador, incluindo in .


Você pode usar o operador in :

if "blah" not in somestring: 
    continue

if needle in haystack: é o uso normal, como diz Michael - ele depende do operador in , 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, para fazer alguma key= estranha key= para um tipo muito peculiar ...?), Isso seria 'haystack'.__contains__ . Mas desde que seu exemplo é para uso em um if , eu acho que você realmente não quer dizer o que você diz ;-). Não é boa forma (nem legível, nem eficiente) usar métodos especiais diretamente - eles devem ser usados, ao invés, através dos operadores e builtins que delegam para eles.





contains