string funciones - ¿Python tiene una cadena 'contiene' método de subcadena?




especiales find (13)

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

Quiero hacer:

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

Answers

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

Si realmente necesita un método en lugar de un operador (p. Ej., Para hacer alguna key= extraña key= para un tipo muy peculiar ...), eso sería 'haystack'.__contains__ . Pero como su ejemplo es para usar en un if , supongo que realmente no quiere decir lo que dice ;-). No es una buena forma (ni legible, ni eficiente) usar métodos especiales directamente; están destinados a ser usados, en cambio, a través de los operadores y componentes integrados que delegan en ellos.


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

Sí, pero Python tiene un operador de comparación que deberías usar en su lugar, porque el lenguaje pretende su uso y otros programadores esperarán que lo uses. Esa palabra clave está in , que se utiliza como un operador de comparación:

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

Lo opuesto (complemento), que la pregunta original pide, not in está not in :

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

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

Evite usar __contains__ , find e index

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

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

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

'**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 la funcionalidad in y not in funcionalidad (por ejemplo, si se subclase en 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 idiomas no tengan métodos para probar las subcadenas directamente, por lo que tendría que usar este tipo de métodos, pero con Python, es mucho más eficiente usar el operador 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 usar 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}

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

Debe tener un poco de cuidado con la find , el index y, 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."

Se imprimiría Found 'is' in the string. De manera similar, if "is" in s: se evaluaría como True . Esto puede o no ser lo que quieres.


in cadenas y listas de Python

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

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


En Python hay dos formas simples de lograr esto:

La forma Pythonic: Uso de Python 'in' Keyword-

toma dos "argumentos", uno a la izquierda ( subcadena ) y otro a la derecha, y devuelve True si el argumento de la izquierda está contenido dentro del argumento del lado del derecho y, si no, devuelve False .

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

Salida:

True

La forma no pitónica: usando str.find de Python:

El método de find 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!

Veo que ya hay respuestas, pero también quiero agregar mis dos centavos.

En Python hay funciones para hacer esto, pero el método más simple (y en su mayoría preferido) es usar la palabra clave 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

También hay algunos métodos de cadena:

"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 el rendimiento:

En general, es el método en ayunas para encontrar una subcadena ...

find es un poco más rápido que el index

Espero poder ayudar!


No, no hay ningún string.contains(str) , pero existe el operador in :

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 ]

Otra forma de averiguar 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

Si está satisfecho con "blah" in somestring pero desea que sea una llamada de función, probablemente pueda hacer esto

import operator

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

Todos los operadores en Python se pueden encontrar más o menos en el módulo del operador incluido in .


Puede utilizar el operador in :

if "blah" not in somestring: 
    continue

Aquí está tu respuesta:

if "insert_char_or_string_here" in "insert_string_to_search_here":
    #DOSTUFF

Para comprobar 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

Si está buscando una búsqueda que no distinga entre mayúsculas y minúsculas para palabras completas, en lugar de una subcadena contenida dentro de otra palabra:

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

Solución alternativa utilizando Regex:

bool contains = Regex.IsMatch("StRiNG to search", "string", RegexOptions.IgnoreCase);

darse cuenta

Como @cHao ha señalado en su comentario, hay situaciones que harán que esta solución arroje resultados incorrectos. Asegúrese de saber lo que está haciendo antes de implementar esta solución al azar.





python string substring contains