parcourir - recherche d'un mot dans une chaine de caractère python




Python a-t-il une chaîne "contient" la méthode de sous-chaîne? (10)

Python a-t-il une chaîne contenant une méthode de sous-chaîne?

Oui, mais Python a un opérateur de comparaison que vous devriez utiliser à la place, car le langage en a l'intention, et les autres programmeurs s'attendent à ce que vous l'utilisiez. Ce mot-clé est in , utilisé comme opérateur de comparaison:

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

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

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

Ceci est sémantiquement identique à not 'foo' in '**foo**' mais il est beaucoup plus lisible et explicitement prévu dans le langage en tant qu'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 du superstring:

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

Mais non. 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 d'étendre la fonctionnalité in et not in (par exemple si 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

D'autres langages peuvent ne pas avoir de méthodes pour tester directement les sous-chaînes et vous devrez donc utiliser ces types de méthodes, mais avec Python, il est beaucoup plus efficace d'utiliser l'opérateur de comparaison.

Comparaisons de performance

Nous pouvons comparer différentes manières 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. Mieux vaut moins de temps pour effectuer une opération équivalente:

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

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

Je veux faire:

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

in chaînes et les listes Python

Voici quelques exemples utiles qui parlent d’eux-mêmes concernant la méthode 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

Caveat. Les listes sont des iterables, et la méthode in agit sur des iterables, pas seulement des chaînes.


En Python, vous pouvez y parvenir de deux manières simples:

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 rightide et sinon, renvoie False .

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

Sortie:

True

La méthode non-Pythonique: Utilisation de str.find de Python:

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!

En gros, vous voulez trouver une sous-chaîne dans une chaîne en python. Il existe deux manières 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 intuitif. Il renverra True si la sous-chaîne a été trouvée dans la chaîne sinon False .

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

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

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

La deuxième méthode consiste à utiliser la méthode str.find() . 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 différente de -1, la sous-chaîne a été trouvée dans la chaîne, sinon. 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 recommanderais d'utiliser la première méthode car elle est plus intuitive et pythonique.


Non, il n'y a pas de 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 ]

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

Vous devez être un peu prudent avec find , index et in bien, car il s'agit de recherches de sous-chaînes. 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 afficherait Found 'is' in the string. De même, if "is" in s: serait évalué à True . Cela peut être ou ne pas être ce que vous voulez.


Si vous recherchez une recherche de mots entiers sans distinction de casse, 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

Une autre façon de déterminer 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

Vous pouvez utiliser l' opérateur in :

if "blah" not in somestring: 
    continue

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

Si vous avez vraiment besoin d'une méthode plutôt que d'un opérateur (par exemple, faire une key= bizarre key= pour un type très particulier ...?), Ce serait 'haystack'.__contains__ . Mais puisque votre exemple est utilisé 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, à la place, par le biais des opérateurs et des fonctions intégrées qui leur déléguent.







contains