it-swarm.dev

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

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

Je veux faire:

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

Vous pouvez utiliser l'opérateur in :

if "blah" not in somestring: 
    continue
5155
Michael Mrozek

S'il s'agit simplement d'une recherche dans une sous-chaîne, vous pouvez utiliser string.find("substring").

Cependant, vous devez être un peu prudent avec find, index et in 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."

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.

534
eldarerathis

if needle in haystack: est l'utilisation normale, comme @Michael le dit - il 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 un key= étrange pour un type très particulier ...?), Ce serait 'haystack'.__contains__ . Mais puisque votre exemple est destiné à être utilisé dans une 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.

148
Alex Martelli

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 else 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 ce n'est pas le cas. 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.

137
Rahul Gupta

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), demandé dans la question initiale, est not in:

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

Sémantiquement, c'est identique à not 'foo' in '**foo**' mais c'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 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 les fonctionnalités in et not in (par exemple, si vous sous-classez 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 langues 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 in.

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 nous voyons maintenant que l'utilisation de in est beaucoup plus rapide que les autres . Moins de temps pour effectuer une opération équivalente, c'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}
120
Aaron Hall

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 ]
70
Bohdan

in Chaînes et listes Python

Voici quelques exemples utiles 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 sur des chaînes.

38
firelynx

Donc, apparemment, il n'y a rien de semblable pour une 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
28
Ufos

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
22
Harish Reddy

Si vous êtes satisfait de "blah" in somestring mais que vous voulez que ce soit un appel de fonction, vous pouvez probablement le faire.

import operator

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

Tous les opérateurs de Python se trouvent plus ou moins dans le module opérateur , y compris in.

15
Jeffrey04

En Python, il existe deux manières simples d'y parvenir:

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

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

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

Sortie:

True

La manière non-Pythonic: 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!
14
Inconnu

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

En Python, il existe des fonctions pour le faire, mais la méthode la plus simple (et généralement préférée) consiste à 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 quelques 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...

A propos de la performance:

En général, in est la méthode la plus rapide pour trouver une sous-chaîne ... 

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

12
Fipsi

Voici votre réponse:

if "insert_char_or_string_here" in "insert_string_to_search_here":
    #DOSTUFF

Pour vérifier si c'est faux:

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
12
ytpillai

Il existe quatre manières les plus simples de déterminer la sous-chaîne et le début de la sous-chaîne.

Le premier est via l’opérateurin: de Python:

someString = "Polly is drinking Coca-Cola."

"Coca-Cola" in someString
# Result: True

"Pepsi" in someString
# Result: False

La deuxième façon consiste à utiliser la méthodefind()de la chaîne.

Contrairement à l'opérateurinévalué en tant que valeur boolean , la méthodefindrenvoie un entier . Cet entier est l'index du début d'une sous-chaîne si cette sous-chaîne existe, sinon -1 est renvoyé. Voici comment ça fonctionne:

someString = "Polly is drinking Coca-Cola."

someString.find("is")
# Result: 6

someString.find("Pepsi")
# Result: -1

someString.find("Polly")
# Result: 0

Vous pouvez également spécifier des index de début et de fin pour limiter votre recherche. Par exemple:

someString = "Polly is drinking Coca-Cola."

someString.find("is", 5, 10)
# Result: 6

someString.find("Polly", 15, 20)
# Result: -1

Troisième. Et, bien sûr, vous pouvez utiliserif...is notstatement (cela fonctionne en Python 2.7 et 3.6):

someString = "Polly is drinking Coca-Cola."
substring = "drinking"

if someString.find(substring) is not -1:
    print("Cool! Python found the desired substring!")
else:
    print("Python didn't find the desired substring!")

# Result: "Cool! Python found the desired substring!"

Quatre. Utilisez la méthodeindex(). C'est presque la même chose que la méthode find().

someString = "Polly is drinking Coca-Cola."
x = someString.index("drinking")
print(x)

# Result: 9

J'espère que cela t'aides.

11
ARGeo

Si vous recherchez une recherche de mots entiers qui ne respecte pas la 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
11
Jamie Bull

Comme dit précédemment, vous pouvez utiliser l'opérateur in comme ceci:

>>> to_search_in = "String to search in"
>>> to_search = "search"
>>> print(to_search in to_search_in)
True
>>> print(to_search_in.find(to_search))
10

Aussi, vous pouvez utiliser des expressions régulières pour obtenir les occurrences:

>>> import re
>>> print(re.findall(r'( |t)', to_search_in)) # searches for t or space
['t', ' ', 't', ' ', ' ']
1
Muskovets

Il y a beaucoup de réponses. 

Mais utiliser count peut aussi être utile.

Exemple:

strblah = 'I have blah in me'
if strblah.count('blah') > 0:
    print('Yes: substring found')
0
Naidu