una - separar palabra en letras python




¿Python tiene una cadena 'contiene' método de subcadena? (10)

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

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

Quiero hacer:

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

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.


Así que aparentemente no hay nada similar para la comparación vectorial. Una manera obvia de hacerlo con Python 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

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

Puede utilizar el operador in de Python para comprobar si hay una subcadena. Es bastante simple e intuitivo. Devolverá True si la subcadena se encontró en la cadena de lo contrario False .

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

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

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

El segundo método es usar el método str.find() . Aquí, llamamos al método .find() en la cadena en la que se encuentra 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 que uses el primer método, ya que es más pitónico e intuitivo.


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

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 .


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!


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.





contains