Python a-t-il une méthode de sous-chaîne string 'contains'?

Je cherche une méthode string.contains ou string.indexof en Python.

Je veux faire:

if not somestring.contains("blah"):
   continue
3047
demandé sur Peter Mortensen 2010-08-09 06:52:50

14 réponses

Vous pouvez utiliser le in opérateur:

if "blah" not in somestring: 
    continue
4586
répondu Michael Mrozek 2015-11-11 23:30:17

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.

484
répondu eldarerathis 2017-05-26 18:03:43

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.

129
répondu Alex Martelli 2015-06-20 04:07:17

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.

105
répondu Rahul Gupta 2017-05-26 18:09:05

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}
98
répondu Aaron Hall 2017-11-02 16:24:48

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 ]
62
répondu Bohdan 2017-05-26 18:05:50

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.

31
répondu firelynx 2017-05-26 18:09:58

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
21
répondu Ufos 2016-04-06 08:49:22

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
17
répondu Harish Reddy 2017-05-26 18:04:59

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!
9
répondu Inconnu 2016-11-20 18:58:56

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

8
répondu Jeffrey04 2018-03-29 08:20:03

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
8
répondu ytpillai 2018-05-03 14:18:35

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
5
répondu Jamie Bull 2018-07-28 07:02:52

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!

4
répondu Fipsi 2018-06-18 16:45:15