O Python possui um método de "substring"?

Estou procurando o string.indexof ou string.indexof no Python.

Eu quero fazer:

 if not somestring.contains("blah"): continue 
3355
09 авг. definido por Blankman 09 ago. 2010-08-09 05:52 '10 at 5:52 am 2010-08-09 05:52
@ 19 respostas

Você pode usar o operador in :

 if "blah" not in somestring: continue 
5043
09 авг. Resposta dada por Michael Mrozek 09 ago 2010-08-09 05:56 '10 às 5:56 em 2010-08-09 05:56

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

Você precisa ser um pouco cuidadoso com find , index e in , embora eles sejam executados com uma substring. Em outras palavras, isso é:

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

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

525
09 авг. a resposta é dada por eldarerathis 09 ago. 2010-08-09 05:55 '10 às 5:55 2010-08-09 05:55

if needle in haystack: - isso é normal, como diz Michael - ele depende do operador in , que é mais legível e mais rápido do que chamar o 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 ...?), Será 'haystack'.__contains__ . Mas desde que o seu exemplo é destinado para uso em if , eu acho que você realmente não quer dizer o que você diz ;-). Esta não é uma boa forma (nem legível nem eficiente) de usar métodos especiais diretamente - eles devem ser usados ​​em vez de operadores e funções internas que são delegadas a eles.

143
09 авг. Resposta dada por Alex Martelli 09 ago 2010-08-09 06:19 '10 às 6:19 AM 2010-08-09 06:19

Essencialmente, 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 in para testar a substring. É bastante simples e intuitivo. Ele retornará True se a substring for encontrada na string, caso contrário, False .

 >>> "King" in "King landing" True >>> "Jon Snow" in "King landing" False 

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

O segundo método é usar str.find() . Aqui nós chamamos o método .find() para a string na qual a substring deve ser 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 de retorno é o índice em que a substring é encontrada.

 >>> some_string = "valar morghulis" >>> some_string.find("morghulis") 6 >>> some_string.find("dohaeris") -1 

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

130
26 мая '15 в 20:46 2015-05-26 20:46 a resposta é dada por Rahul Gupta 26 de maio de '15 às 20:46 2015-05-26 20:46

Existe uma string no Python que contém um método de substring?

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

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

O oposto (adição) que a pergunta original pede not in está not in :

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

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

Evite usar __contains__ , find e index

Como prometido, aqui contains método:

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

retorna True . Você também pode chamar essa função de uma instância de superline:

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

Mas não faça isso. Os métodos que começam com um sublinhado são considerados semanticamente privados. A única razão para isso é estender o in e not in funções (por exemplo, quando 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 

Evite também 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 não possuem métodos para testar diretamente substrings, então você terá que usar esses tipos de métodos, mas com Python é muito mais eficiente usar o operador de comparação.

Comparação de desempenho

Podemos comparar maneiras diferentes 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 in muito mais rápido que outros. Menos tempo para executar 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} 
116
26 нояб. a resposta é dada por Aaron Hall em 26 de novembro. 2014-11-26 01:33 '14 às 1:33 2014-11-26 01:33

Não, não há string.contains(str) método string.contains(str) , mas há um operador in :

 if substring in someString: print "It 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 ] 
68
30 сент. A resposta é dada por Bohdan 30 de setembro 2013-09-30 21:59 '13 às 9:59 pm 2013-09-30 21:59

in strings e listas in Python

Aqui estão alguns exemplos úteis que falam sozinhos 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 

Advertência As listas são iteráveis ​​e o método in age na iteração, não apenas em strings.

36
28 апр. Responder firelynx 28 abr. 2017-04-28 21:52 '17 às 21:52, 2017-04-28 21:52

Assim, parece não haver nada como isso para uma comparação vetorial. A maneira óbvia para o Python fazer isso seria o seguinte:

 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 
26
17 июля '15 в 16:19 2015-07-17 16:19 a resposta é dada Ufos 17 de julho de '15 às 16:19 2015-07-17 16:19

Outra maneira de descobrir se uma string contém vários caracteres ou não com um valor de retorno de Boolean (ou seja, True ou 'False):

 str1 = "This be a string" find_this = "tr" if find_this in str1: print find_this, " is been found in ", str1 else: print find_this, " is not found in ", str1 
20
28 июля '11 в 15:32 2011-07-28 15:32 a resposta é dada por Harish Reddy 28 de julho, '11 at 15:32 2011-07-28 15:32

Se você está satisfeito 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 .

14
28 марта '18 в 12:59 2018-03-28 12:59 a resposta é dada por Jeffrey04 em 28 de março '18 às 12:59 pm 2018-03-28 12:59

Há duas maneiras fáceis de fazer isso no Python:

Caminho Pythonic: Usando Python 'in' Keyword -

in leva dois "argumentos", um à esquerda (substring) e um à direita e retorna True se o argumento da esquerda estiver no argumento de direitos e, caso contrário, retorna False .

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

Conclusão:

 True 

Método não-pitônico: usando o Python str.find:

O método find retorna a posição de uma string em uma string, ou -1 se ela não for encontrada. Mas basta verificar se a posição é -1.

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

Conclusão:

 Substring found! 
12
20 нояб. a resposta é dada por Inconnu Nov 20 2016-11-20 21:58 '16 às 21:58 2016-11-20 21:58

Aqui está 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 
11
26 мая '15 в 1:50 2015-05-26 01:50 resposta é dada por ytpillai 26 de maio de '15 às 1:50 am 2015-05-26 01:50

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

O Python tem funções para isso, mas o método mais simples (e mais 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 também vários métodos de string:

 "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 caminho mais rápido para encontrar uma substring ...

find um pouco mais rápido que o index .

10
16 июня '18 в 15:02 2018-06-16 15:02 a resposta é dada por Fipsi em 16 de junho de 18 às 15:02 2018-06-16 15:02

Se você estiver procurando por uma pesquisa que não diferencia maiúsculas de minúsculas, em vez de uma substring contida em outra palavra:

 import string s = 'This is my text example' if 'is' not in (word.lower() for split_char in string.punctuation + string.whitespace for word in s.split(split_char)): # do something 
10
13 янв. A resposta é dada por Jamie Bull 13 de janeiro 2018-01-13 18:32 18 às 18:32 2018-01-13 18:32

Existem quatro maneiras mais simples de descobrir o que é uma substring e onde a substring começa.

Primeiro através do Python in operador:

 someString = "Polly is drinking Coca-Cola." "Coca-Cola" in someString # Result: True "Pepsi" in someString # Result: False 

A segunda maneira é usar o método find() para strings.

Ao contrário do operador in, que é avaliado como um valor lógico , o método find retorna um inteiro . Esse inteiro é o índice do início da subseqüência se essa subseqüência existir, caso contrário, -1 . Veja como isso funciona:

 someString = "Polly is drinking Coca-Cola." someString.find("is") # Result: 6 someString.find("Pepsi") # Result: -1 someString.find("Polly") # Result: 0 

Você também pode especificar os índices inicial e final para limitar a pesquisa. Por exemplo:

 someString = "Polly is drinking Coca-Cola." someString.find("is", 5, 10) # Result: 6 someString.find("Polly", 15, 20) # Result: -1 

No terceiro. E, claro, você pode usar if...is not Statement (funciona no Python 2.7 e 3.6):

 someString = "Polly is drinking Coca-Cola." substring = "drinking" if someString.find(substring) is not -1: print("Cool! Python found the desired substring!") else: print("Python didn't find the desired substring!") # Result: "Cool! Python found the desired substring!" 

Quatro. Use o método index() . Isso é quase o mesmo que o método find() .

 someString = "Polly is drinking Coca-Cola." x = someString.index("drinking") print(x) # Result: 9 

Espero que isso ajude.

6
25 дек. resposta dada por ARGeo 25 dez 2018-12-25 18:35 '18 às 6:35 pm 2018-12-25 18:35

Como já mencionado, você pode usar o operador in seguinte maneira:

 >>> to_search_in = "String to search in" >>> to_search = "search" >>> print(to_search in to_search_in) True >>> print(to_search_in.find(to_search)) 10 

Você também pode usar expressões regulares para obter as entradas:

 >>> import re >>> print(re.findall(r'( |t)', to_search_in)) # searches for t or space ['t', ' ', 't', ' ', ' '] 
1
23 нояб. A resposta é dada Muskovets 23 de novembro 2018-11-23 10:15 '18 às 10h15 . 2018-11-23 10:15

Contando substrings em uma string

 a = "Hello, what your name?" if a.count("what's"): print("Found") else: print("Not found") 
0
02 дек. Responder RAMunna 02 dez 2017-12-02 23:12 '17 às 11:12 2017-12-02 23:12

Existem muitas respostas.

Mas usando count pode ser conveniente.

exemplo:

 strblah = 'I have blah in me' if strblah.count('blah') > 0: print('Yes: substring found') 
0
23 янв. A resposta é dada por Naidu em 23 de janeiro. 2019-01-23 22:58 19 às 22:58 2019-01-23 22:58

Você pode usar vários métodos:

  1. if x in y:
  2. y.count()
  3. y.find()

1 é uma expressão lógica, o que significa que retornará o estado Verdadeiro de Falso, dependendo de a condição ser verdadeira ou não.

Por exemplo:

 string = "Hello world" if "Hello" in string: >>True if "Python" in string: >>False 

2 retorna o valor inteiro do número de vezes que a substring aparece na string.

Por exemplo:

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

3 retorna o valor de índice da posição inicial das substrings especificadas. Isso também retornará -1 se a substring não for encontrada.

Por exemplo:

 string.find("Hello") >>0 string.find("foo") >>-1 
0
06 февр. A resposta é dada por Brandon Bailey 06 de fevereiro 2019-02-06 14:06 '19 às 2:06 pm 2019-02-06 14:06

Outras perguntas sobre a tags do ou Faça uma pergunta