Python a-t-il une méthode de soustraitance '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
la source

14 ответов

vous pouvez utiliser le in opérateur :

if "blah" not in somestring: 
    continue
4586
répondu Michael Mrozek 2015-11-12 02:30:17
la source

si ce n'est qu'une recherche par soustraction, vous pouvez utiliser string.find("substring") .

vous devez être un peu prudent avec find , index , et in cependant, car ils sont des recherches de substrat. 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, if "is" in s: serait évalué à True . Cela peut ou peut ne pas être ce que vous voulez.

484
répondu eldarerathis 2017-05-26 21:03:43
la source

if needle in haystack: est l'usage normal, comme le dit @Michael -- Il s'appuie 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 au lieu d'un opérateur (par exemple pour faire quelque chose de bizarre key= pour un type très particulier...?), ce serait 'haystack'.__contains__ . Mais puisque votre exemple est pour une utilisation dans un if , je suppose que vous ne pensez pas vraiment ce que vous dites;-). Il n'est pas bon forme (ni lisible, ni efficace) pour utiliser des méthodes spéciales directement -- elles sont destinées à être utilisées, à la place, à travers les opérateurs et les builtins qui leur sont délégués.

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

en gros, vous voulez trouver un substrat dans une chaîne en python. Il y a deux façons de rechercher un substrat dans une chaîne en Python.

Méthode 1: in opérateur

vous pouvez utiliser l'opérateur in de Python pour vérifier la présence d'un substrat. C'est assez simple et intuitive. Il retournera True si le substrat a été trouvé 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 la méthode str.find() . Ici, nous appelons la méthode .find() sur la chaîne dans laquelle se trouve le substrat. Nous passons la chaîne à la méthode find () et vérifions sa valeur de retour. Si sa valeur est autre que -1, le substrat a été trouvé dans la chaîne, sinon pas. La valeur retournée est l'indice où le substrat a été trouvé.

>>> some_string = "valar morghulis"

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

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

I vous recommandons d'utiliser la première méthode, car elle est plus Pythonic et intuitive.

105
répondu Rahul Gupta 2017-05-26 21:09:05
la source

est-ce que Python a une chaîne de caractères contenant une méthode de substring?

Oui, mais Python a un opérateur de comparaison que vous devriez utiliser à la place, parce que le langage veut son usage, et d'autres programmeurs s'attendront à 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 c'est beaucoup plus lisible et explicitement prévu dans la langue comme une amélioration de lisibilité.

éviter d'utiliser __contains__ , find , et index

comme promis, voici la méthode contains :

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

renvoie True . Vous pouvez aussi appeler cette fonction à partir de l'exemple de la superstring:

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

mais non. Les méthodes qui commencent par des underscores sont considérées 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 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

aussi, éviter les méthodes de chaîne de caractères 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 langues peuvent n'avoir aucune méthode pour testez directement les substrats, 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 in .

comparaisons de Performances

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'utilisation de in est beaucoup plus rapide que les autres. Moins de temps pour effectuer 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 19:24:48
la source

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 21:05:50
la source

in Python les chaînes et les listes

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

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 21:09:58
la source

donc apparemment il n'y a rien de semblable 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 11:49:22
la source

une autre façon de savoir si une chaîne contient quelques caractères ou non avec la valeur de retour booléenne (i.e. True or '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 21:04:59
la source

en Python il y a deux façons simples de réaliser ceci:

La Pythonic façon: à l'Aide de Python", " Mot-

in prend deux "arguments", un à gauche ( substring ) et un à droite, et retourne True si l'argument de gauche est contenu dans l'argument de droite et si non,il retourne False .

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

sortie:

True

Le non-Pythonic façon: à l'Aide de Python str.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 21:58:56
la source

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

import operator

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

tous les opérateurs en Python se trouvent plus ou moins dans le module opérateur incluant in .

8
répondu Jeffrey04 2018-03-29 11:20:03
la source

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 17:18:35
la source

si vous recherchez des mots entiers insensibles à la casse, plutôt qu'un substrat contenu 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 10:02:52
la source

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

en Python il y a des fonctions pour faire cela 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 y a aussi 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...

à Propos de la performance:

en général in est la méthode à jeun pour trouver un substring...

find est légèrement plus rapide que index


j'Espère que je pourrais vous aider!

4
répondu Fipsi 2018-06-18 19:45:15
la source

Autres questions sur python string contains substring