Pregunta ¿Tiene Python un método de subcadena 'contains' de cadena?


Estoy buscando string.contains o string.indexof método en Python.

Quiero hacer:

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

2871
2017-08-09 02:52


origen


Respuestas:


Puedes usar el in operador:

if "blah" not in somestring: 
    continue

4348
2017-08-09 02:56



Si solo se trata de una búsqueda de subcadenas, puede usar string.find("substring").

Tienes que ser un poco cuidadoso con find, indexy in sin embargo, ya que son búsquedas de subcadenas. En otras palabras, esto:

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

Imprimiría Found 'is' in the string. Similar, if "is" in s: evaluaría a True. Esto puede o no ser lo que quieres.


458
2017-08-09 02:55



if needle in haystack: es el uso normal, como dice @Michael, depende del in operador, más legible y más rápido que una llamada a método.

Si realmente necesita un método en lugar de un operador (por ejemplo, para hacer un poco extraño key= para un tipo muy peculiar ...?), eso sería 'haystack'.__contains__. Pero dado que su ejemplo es para usarlo en if, Supongo que realmente no quieres decir lo que dices ;-). No es una buena forma (ni legible, ni eficiente) utilizar métodos especiales directamente; están destinados a ser utilizados, en cambio, a través de los operadores y builtins que los delegan.


123
2017-08-09 03:19



Básicamente, quieres encontrar una subcadena en una cadena en python. Hay dos formas de buscar una subcadena en una cadena en Python.

Método 1: in operador

Puedes usar el Python in operador para verificar una subcadena. Es bastante simple e intuitivo. Regresará True si la subcadena se encontró en la cadena else False.

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

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

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

El segundo método es usar el str.find() método. Aquí, llamamos al .find() método en la cadena en la cual se debe encontrar la subcadena. Pasamos la subcadena al método find () y verificamos su valor de retorno. Si su valor es distinto de -1, la subcadena se encontró en la cadena, de lo contrario no. El valor devuelto es el índice donde se encontró la subcadena.

>>> some_string = "valar morghulis"

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

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

Te recomendaría usar el primer método, ya que es más pitónico e intuitivo.


98
2018-05-26 17:46



¿Python tiene una cadena que contiene el método de subcadena?

Sí, pero Python tiene un operador de comparación que debe usar en su lugar, porque el lenguaje pretende su uso, y otros programadores esperan que usted lo use. Esa palabra clave es in, que se usa como operador de comparación:

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

Lo opuesto (complemento) que pide la pregunta original es not in:

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

Esto es semánticamente lo mismo que not 'foo' in '**foo**' pero es mucho más legible y explícitamente previsto en el lenguaje como una mejora de legibilidad.

Evitar el uso de __contains__, findy index

Según lo prometido, aquí está el contains método:

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

devoluciones True. También puede llamar a esta función desde la instancia de la supercuerda:

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

Pero no lo hagas Los métodos que comienzan con guiones bajos se consideran semánticamente privados. La única razón para usar esto es cuando se extiende el in y not in funcionalidad (por ejemplo, si subclases 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')

y ahora:

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

Además, evite los siguientes métodos de cadena:

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

Es posible que otros lenguajes no tengan métodos para probar directamente las subcadenas, por lo que tendrías que usar estos tipos de métodos, pero con Python, es mucho más eficiente usar el inoperador de comparación.

Comparaciones de rendimiento

Podemos comparar varias formas de lograr el mismo 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'))),
}

Y ahora vemos que usando in es mucho más rápido que los demás. Menos tiempo para hacer una operación equivalente es mejor:

>>> 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}

89
2017-11-25 22:33



No, no hay ningún string.contains(str) método, pero está el in operador:

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

Aquí hay un ejemplo de trabajo más complejo:

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

61
2017-09-30 18:59



in Cadenas de Python y listas

Aquí hay algunos ejemplos útiles que hablan por sí mismos sobre la in mé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

Advertencia. Las listas son iterables, y el in el método actúa sobre los iterables, no solo sobre las cadenas.


31
2018-04-28 18:52



Entonces, aparentemente, no hay nada similar para una comparación vectorial. Una forma obvia de Python para hacerlo sería:

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

21
2017-07-17 13:19



Otra forma de determinar si una cadena contiene algunos caracteres o no con el valor de retorno booleano (es decir, True o `Falso):

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

17
2017-07-28 12:32



En Python hay dos formas simples de lograr esto:

La forma Pythonic: usando la palabra clave 'in' de Python-

in toma dos "argumentos", uno a la izquierda (subcadena) y uno a la derecha, y regresa True si el argumento de la izquierda está dentro del argumento de la derecha y si no, regresa False.

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

Salida:

True

La forma no pitonica: usando la habilidad str.find de Python:

los find método devuelve la posición de la cadena dentro de la cadena o -1 si no se encuentra. Pero simplemente verifica si la posición no es -1.

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

Salida:

Substring found!

9
2017-11-20 18:58



Aquí está tu respuesta:

if "insert_char_or_string_here" in "insert_string_to_search_here":
    #DOSTUFF

Para verificar si es falso:

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

O:

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

8
2018-05-25 22:50