Question Est-ce que Python a une chaîne de caractères 'contains'?


je recherche un string.contains ou string.indexof méthode en Python.

Je veux faire:

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

2871
2017-08-09 02:52


origine


Réponses:


Vous pouvez utiliser le in opérateur:

if "blah" not in somestring: 
    continue

4348
2017-08-09 02:56



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 cependant, comme ils sont des recherches de sous-chaîne. 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."

Cela imprimerait Found 'is' in the string. De même, if "is" in s: évaluerait à True. Cela peut ou peut ne pas être ce que vous voulez.


458
2017-08-09 02:55



if needle in haystack: est l'utilisation normale, comme le dit @Michael - il 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 étrange key= pour un genre très particulier ...?), ce serait 'haystack'.__contains__. Mais puisque votre exemple est pour une utilisation 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, plutôt, à travers les opérateurs et les builtins qui leur délèguent.


123
2017-08-09 03:19



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 le Python in opérateur pour vérifier une sous-chaîne. C'est assez simple et intuitif. Il reviendra True si la sous-chaîne a été trouvée dans la chaîne d'autres 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 le .find() méthode 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, pas. 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.


98
2018-05-26 17:46



Est-ce que Python a 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 a l'intention de l'utiliser, et d'autres programmeurs s'attendent à ce que vous l'utilisiez. Ce mot-clé est in, qui est utilisé comme un 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 il est beaucoup plus lisible et explicitement prévu dans le langage comme une amélioration de la lisibilité.

Évitez d'utiliser __contains__, find, et index

Comme promis, voici la contains méthode:

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

résultats True. Vous pouvez également appeler cette fonction depuis l'instance de la super-chaîne:

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

Mais ne le fais pas. Les méthodes commençant par des traits de soulignement sont considérées comme sémantiquement privées. La seule raison d'utiliser cela est lors de l'extension du in et not in fonctionnalité (par exemple si sous-classe 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 donc vous devrez utiliser ces types de méthodes, mais avec Python, il est beaucoup plus efficace d'utiliser le inopérateur de comparaison.

Comparaisons de performance

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

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'aide in est beaucoup plus rapide que les autres. Moins de temps pour faire une opération équivalente est mieux:

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

89
2017-11-25 22:33



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

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 ]

61
2017-09-30 18:59



in Chaînes et listes Python

Voici quelques exemples utiles 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

Caveat. Les listes sont itérables, et les in La méthode agit sur les itérations, pas seulement sur les chaînes.


31
2018-04-28 18:52



Donc, apparemment, il n'y a rien de similaire pour la comparaison vectorielle. Un moyen évident pour Python de le faire 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
2017-07-17 13:19



Une autre façon de trouver si une chaîne contient quelques caractères ou non avec la valeur de retour booléenne (c.-à-d. True ou "Faux":

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
2017-07-28 12:32