Si c'est juste une recherche de sous-chaîne, vous pouvez utiliser string.find("substring").

, Vous devez être un peu prudent avec find, index, et in bien, comme ils sont sous-chaîne de recherche. En d'autres termes, ceci:

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

Il imprimerait Found 'is' in the string. de même, {[6] } évaluerait à True. Cela peut ou peut ne pas être ce que vous voulez.

if needle in haystack: est-ce que l'utilisation normale, comme le dit @Michael-elle repose sur le in opérateur, plus lisible et plus rapide qu'un appel de méthode.

Si vous avez vraiment besoin d'une méthode au lieu d'un opérateur (par exemple pour faire un peu bizarre key= pour un genre très particulier...?), qui serait 'haystack'.__contains__. Mais puisque votre exemple est à utiliser dans un if, je suppose que vous ne voulez pas vraiment dire ce que vous dites; -). Ce n'est pas une bonne forme (ni lisible, ni efficace) d'utiliser directement des méthodes spéciales - elles sont destinées à être utilisées, au lieu de cela, à travers les opérateurs et les builtins qui leur déléguent.

Fondamentalement, vous voulez trouver une sous-chaîne dans une chaîne en python. Il y a deux façons de rechercher une sous-chaîne dans une chaîne en Python.

Méthode 1: in opérateur

Vous pouvez utiliser l'opérateur in de Python pour rechercher une sous-chaîne. C'est assez simple et intuitive. Il retournera True si la sous-chaîne a été trouvée dans la chaîne else False.

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

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

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

La deuxième méthode consiste à utiliser le str.find() méthode. Ici, nous appelons la méthode .find() sur la chaîne dans laquelle la sous-chaîne doit être trouvée. Nous passons la sous-chaîne à la méthode find () et vérifions sa valeur de retour. Si sa valeur est -1, la chaîne a été trouvée dans la chaîne, pas autrement. La valeur renvoyée est l'index où la sous-chaîne a été trouvée.

>>> some_string = "valar morghulis"

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

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

Je vous recommande d'utiliser la première méthode car elle est plus pythonique et intuitive.

Python a-t-il une méthode string contains substring?

Oui, mais Python a un opérateur de comparaison que vous devriez utiliser à la place, car le langage entend son utilisation, et d'autres programmeurs s'attendront à ce que vous l'utilisiez. Ce mot-clé est in, qui est utilisé comme opérateur de comparaison:

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

Le contraire (complément), que la question initiale demande, est not in:

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

C'est sémantiquement le même que not 'foo' in '**foo**', mais c'est beaucoup plus lisible et explicitement prévu dans la langue comme une amélioration de la lisibilité.

Évitez d'utiliser __contains__, find, et index

Comme promis, voici la méthode contains:

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

Renvoie True. Vous pouvez également appeler cette fonction à partir de l'instance de la superstring:

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

Mais ne le faites pas.les méthodes qui commencent par des traits de soulignement sont considérées comme sémantiquement privées. La seule raison d'utiliser ceci est lors de l'extension des fonctionnalités in et not in (par exemple si le sous-classement 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')

Et maintenant:

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

Évitez également les méthodes de chaîne suivantes:

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

Les autres langages peuvent n'avoir aucune méthode pour tester directement les sous-chaînes, et vous devriez donc utiliser ces types de méthodes, mais avec Python, il est beaucoup plus efficace d'utiliser l'opérateur de comparaison in.

Comparaisons de performances

Nous pouvons comparer différentes façons d'atteindre le même objectif.

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'))),
}

Et maintenant, nous voyons que l'utilisation de in est beaucoup plus rapide que les autres. Moins de temps pour faire une opération équivalente est préférable:

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

Non, il n'y a pas de méthode string.contains(str), mais il y a l'opérateur in:

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

Voici un exemple de travail plus complexe:

# 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 chaînes et listes Python

Voici quelques exemples qui parlent d'eux-mêmes concernant la in méthode:

"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

Mise en garde. Les listes sont itérables, et la méthode in agit sur les itérables, pas seulement sur les chaînes.

Donc apparemment, il n'y a rien de similaire pour la comparaison vectorielle. Une façon évidente de le faire en Python serait:

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

Une autre façon de savoir si une chaîne contient quelques caractères ou non avec la valeur de retour booléenne (c'est-à-dire 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

En Python, il existe deux façons simples d'y parvenir:

La manière pythonique: utiliser le mot-clé 'in' de Python -

in prend deux "arguments", un à gauche (sous-chaîne ) et un à droite, et renvoie True si l'argument de gauche est contenu dans l'argument de droite et sinon, il renvoie False.

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

Sortie:

True

La manière non-pythonique: utiliser le str de Python.trouver:

La méthode find renvoie la position de la chaîne dans la chaîne ou -1 si elle n'est pas trouvée. Mais vérifiez simplement si la position n'est pas -1.

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

Sortie:

Substring found!

, Si vous êtes heureux avec "blah" in somestring, mais qu'elle soit un appel de fonction, vous pouvez probablement faire ce

import operator

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

Tous les opérateurs en Python peuvent être plus ou moins trouvés dans le module opérateur y compris in.

Voici votre réponse:

if "insert_char_or_string_here" in "insert_string_to_search_here":
    #DOSTUFF

Pour vérifier si elle est fausse:

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

Si vous cherchez une recherche insensible à la casse pour des mots entiers, plutôt qu'une sous-chaîne contenue dans un autre mot:

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

Je vois qu'il y a déjà des réponses mais je veux aussi ajouter mes deux cents.

En Python, il y a des fonctions pour le faire, mais la méthode la plus simple (et la plupart du temps préférée) est d'utiliser le mot-clé 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

Il existe également des méthodes de chaîne:

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

Sur la performance:

En général in est la méthode à jeun pour trouver une sous-chaîne...

find est légèrement plus rapide que le index

J'espère pouvoir aider!