Python - Vérifier si Word est dans une chaîne

Je travaille avec Python v2 et j'essaie de savoir si vous pouvez dire si un mot est dans une chaîne.

J'ai trouvé des informations sur l'identification du mot dans la chaîne - en utilisant .find, mais y a-t-il un moyen de faire une instruction IF. J'aimerais avoir quelque chose comme ce qui suit:

if string.find(word):
    print 'success'

Merci pour toute aide.

Qu'est-ce qui ne va pas chez:

if word in mystring: 
   print 'success'

if 'seek' in 'those who seek shall find':
    print('Success!')

mais gardez à l'esprit que cela correspond à une séquence de caractères, pas nécessairement à un mot entier - par exemple, 'word' in 'swordsmith'est True. Si vous ne voulez faire correspondre que des mots entiers, vous devez utiliser des expressions régulières:

import re

def findWholeWord(w):
    return re.compile(r'\b({0})\b'.format(w), flags=re.IGNORECASE).search

findWholeWord('seek')('those who seek shall find')    # -> <match object>
findWholeWord('word')('swordsmith')                   # -> None

Si vous voulez savoir si un mot entier se trouve dans une liste de mots séparés par des espaces, utilisez simplement:

def contains_word(s, w):
    return (' ' + w + ' ') in (' ' + s + ' ')

contains_word('the quick brown fox', 'brown')  # True
contains_word('the quick brown fox', 'row')    # False

Cette méthode élégante est également la plus rapide. Par rapport aux approches de Hugh Bothwell et daSong:

>python -m timeit -s "def contains_word(s, w): return (' ' + w + ' ') in (' ' + s + ' ')" "contains_word('the quick brown fox', 'brown')"
1000000 loops, best of 3: 0.351 usec per loop

>python -m timeit -s "import re" -s "def contains_word(s, w): return re.compile(r'\b({0})\b'.format(w), flags=re.IGNORECASE).search(s)" "contains_word('the quick brown fox', 'brown')"
100000 loops, best of 3: 2.38 usec per loop

>python -m timeit -s "def contains_word(s, w): return s.startswith(w + ' ') or s.endswith(' ' + w) or s.find(' ' + w + ' ') != -1" "contains_word('the quick brown fox', 'brown')"
1000000 loops, best of 3: 1.13 usec per loop

Edit: Une légère variante de cette idée pour Python 3.6+, tout aussi rapide:

def contains_word(s, w):
    return f' {w} ' in f' {s} '

find renvoie un entier représentant l'index de l'endroit où l'élément de recherche a été trouvé. S'il n'est pas trouvé, il renvoie -1.

haystack = 'asdf'

haystack.find('a') # result: 0
haystack.find('s') # result: 1
haystack.find('g') # result: -1

if haystack.find(needle) >= 0:
  print 'Needle found.'
else:
  print 'Needle not found.'

Vous pouvez diviser la chaîne en mots et vérifier la liste des résultats.

if word in string.split():
    print 'success'

Cette petite fonction compare tous les mots recherchés dans un texte donné. Si tous les mots de recherche se trouvent dans le texte, renvoie la longueur de la recherche ou Falseautre.

Prend également en charge la recherche de chaînes Unicode.

def find_words(text, search):
    """Find exact words"""
    dText   = text.split()
    dSearch = search.split()

    found_word = 0

    for text_word in dText:
        for search_word in dSearch:
            if search_word == text_word:
                found_word += 1

    if found_word == len(dSearch):
        return lenSearch
    else:
        return False

usage:

find_words('çelik güray ankara', 'güray ankara')

Si la correspondance d'une séquence de caractères n'est pas suffisante et que vous devez faire correspondre des mots entiers, voici une fonction simple qui fait le travail. Il ajoute essentiellement des espaces si nécessaire et recherche cela dans la chaîne:

def smart_find(haystack, needle):
    if haystack.startswith(needle+" "):
        return True
    if haystack.endswith(" "+needle):
        return True
    if haystack.find(" "+needle+" ") != -1:
        return True
    return False

Cela suppose que les virgules et autres ponctuations ont déjà été supprimées.

Comme vous demandez un mot et non une chaîne, je voudrais vous présenter une solution qui n'est pas sensible aux préfixes / suffixes et ignore la casse:

#!/usr/bin/env python

import re


def is_word_in_text(word, text):
    """
    Check if a word is in a text.

    Parameters
    ----------
    word : str
    text : str

    Returns
    -------
    bool : True if word is in text, otherwise False.

    Examples
    --------
    >>> is_word_in_text("Python", "python is awesome.")
    True

    >>> is_word_in_text("Python", "camelCase is pythonic.")
    False

    >>> is_word_in_text("Python", "At the end is Python")
    True
    """
    pattern = r'(^|[^\w]){}([^\w]|$)'.format(word)
    pattern = re.compile(pattern, re.IGNORECASE)
    matches = re.search(pattern, text)
    return bool(matches)


if __name__ == '__main__':
    import doctest
    doctest.testmod()

Si vos mots peuvent contenir des caractères spéciaux d'expression régulière (tels que +), vous devezre.escape(word)

Méthode avancée pour vérifier le mot exact, que nous devons trouver dans une longue chaîne:

import re
text = "This text was of edited by Rock"
#try this string also
#text = "This text was officially edited by Rock" 
for m in re.finditer(r"\bof\b", text):
    if m.group(0):
        print "Present"
    else:
        print "Absent"

L'utilisation de regex est une solution, mais c'est trop compliqué dans ce cas.

Vous pouvez simplement diviser le texte en liste de mots. Utilisez la méthode split ( separator , num ) pour cela. Il renvoie une liste de tous les mots de la chaîne, en utilisant le séparateur comme séparateur. Si le séparateur n'est pas spécifié, il se divise sur tous les espaces (vous pouvez éventuellement limiter le nombre de divisions à num ).

list_of_words = mystring.split()
if word in list_of_words:
    print 'success'

Cela ne fonctionnera pas pour les chaînes avec des virgules, etc. Par exemple:

mystring = "One,two and three"
# will split into ["One,two", "and", "three"]

Si vous souhaitez également fractionner toutes les virgules, etc., utilisez un argument de séparation comme celui-ci:

# whitespace_chars = " \t\n\r\f" - space, tab, newline, return, formfeed
list_of_words = mystring.split( \t\n\r\f,.;!?'\"()")
if word in list_of_words:
    print 'success'

Vous pouvez simplement ajouter un espace avant et après "mot".

x = raw_input("Type your word: ")
if " word " in x:
    print "Yes"
elif " word " not in x:
    print "Nope"

De cette façon, il recherche l'espace avant et après "mot".

>>> Type your word: Swordsmith
>>> Nope
>>> Type your word:  word 
>>> Yes