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

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

Sin embargo, debes tener un poco de cuidado con find, index y in, 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. De manera similar, if "is" in s: evaluaría a True. Esto puede o no ser lo que quieres.

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

Si realmente necesitas un método en lugar de un operador (por ejemplo, para hacer algún key= extraño para un tipo muy peculiar ...), eso sería 'haystack'.__contains__ . Pero como su ejemplo es para usar en una 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 los componentes integrados que delegan en ellos.

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 usar el operador in de Python para verificar una subcadena. Es bastante simple e intuitivo. Se devolverá 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: 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.

¿Python tiene una cadena que contiene el 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 esperan que lo uses. Esa palabra clave es in, que se usa como un operador de comparación:

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

El opuesto (complemento) que pide la pregunta original es 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 está explícitamente provisto en el lenguaje como una mejora de legibilidad.

Evite utilizar __contains__, find y index

Como se prometió, 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 extienden las funciones in y not in (por ejemplo, si se subclasifica 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 in.

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

No, no hay ningún método 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 ]

in Python cadenas y listas

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

Otra forma de averiguar si una cadena contiene algunos caracteres o no con el valor de retorno booleano (es decir, True o `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

Si está satisfecho con "blah" in somestring pero quiere 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 incluyendo in.

En Python hay dos maneras simples de lograr esto:

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

in toma dos "argumentos", uno a la izquierda ( substring ) y uno a la derecha, y devuelve True si el argumento de la izquierda está contenido dentro del argumento de los derechos 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: utilizando str.find de Python:

El método 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, in es el método más rápido para encontrar una subcadena ... 

find es ligeramente más rápido que index.

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

Hay cuatro formas más simples de averiguar qué subcadena es y dónde comienza la subcadena.

El primero es a través del operador in de Python:

someString = "Polly is drinking Coca-Cola."

"Coca-Cola" in someString
# Result: True

"Pepsi" in someString
# Result: False

La segunda forma es usar el método find() de la cadena.

A diferencia del operador in que se evalúa como un valor booleano, el método find devuelve un entero. Este entero es el índice del comienzo de una subcadena si esta subcadena existe, de lo contrario se devuelve -1. Así es como funciona:

someString = "Polly is drinking Coca-Cola."

someString.find("is")
# Result: 6

someString.find("Pepsi")
# Result: -1

someString.find("Polly")
# Result: 0

También puede especificar los índices de inicio y finalización para limitar su búsqueda. Por ejemplo:

someString = "Polly is drinking Coca-Cola."

someString.find("is", 5, 10)
# Result: 6

someString.find("Polly", 15, 20)
# Result: -1

Tercero. Y, por supuesto, puede usar la instrucción if...is not (funciona en Python 2.7 y 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!"

Cuatro Use el método index(). Es casi lo mismo que el método find().

someString = "Polly is drinking Coca-Cola."
x = someString.index("drinking")
print(x)

# Result: 9

Espero que esto ayude.

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

Puedes usar algunos métodos:

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

1 es una expresión booleana, lo que significa que devolverá un estado Verdadero de Falso Dependiendo de si la condición se cumple o no.

P.ej:

string = "Hello world"

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

2 devolverá el valor entero de la cantidad de veces que aparece una cadena secundaria en una cadena.

P.ej:

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

3 devolverá el valor de índice de la posición inicial de las cadenas secundarias dadas. Esto también devolverá -1 si no se puede encontrar una cadena secundaria.

P.ej:

string.find("Hello")  >>0
string.find("foo")  >>-1

Como se dijo anteriormente, puede usar el operador in así:

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

También puedes usar expresiones regulares para obtener las ocurrencias:

>>> import re
>>> print(re.findall(r'( |t)', to_search_in)) # searches for t or space
['t', ' ', 't', ' ', ' ']

Hay muchas respuestas. 

Pero usar count también puede ser útil.

ejemplo:

strblah = 'I have blah in me'
if strblah.count('blah') > 0:
    print('Yes: substring found')