Discussion :

[Azerty32]

Bonjour,

Mon problème est simple mais je ne sais pas s'il existe une solution rapide et efficace.
Je souhaite tester la présence de plusieurs mots dans une phrase.

Par exemple :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

phrase = "Ceci est une phrase de test"

Je souhaite tester la présence de "est", "une" et "de" sans avoir à écrire :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
if "est" in phrase and "une" in phrase and "de" in phrase:
   print "OK"

Je ne sais pas si il faut passer par les listes, essayer de découper la phrase, etc...... Merci d'avance pour votre aide !!

[rambc]

Bonjour,
voici une façon de faire :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
#! /usr/bin/env python
#coding=utf-8
 
phrase = "Ceci est une phrase de test."
 
def containAllWord(text, words):
    for oneWord in words:
        if oneWord not in text:
            return False
    return True
 
 
def containAtLeastOneWord(text, words):
    for oneWord in words:
        if oneWord in text:
            return True
    return False
 
 
print ''
print '\tcontainAllWord( "' + phrase + '", ["est", "une", "de"] )'
print str( containAllWord( phrase, ["est", "une", "de"] ) )
print '\tcontainAtLeastOneWord( "' + phrase + '", ["est", "une", "de"] )'
print str( containAtLeastOneWord( phrase, ["est", "une", "de"] ) )
print ''
print '\tcontainAllWord( "' + phrase + '", ["essssst", "unnnne", "de"] )'
print str( containAllWord( phrase, ["essssst", "unnnne", "de"] ) )
print '\tcontainAtLeastOneWord( "' + phrase + '", ["essssst", "unnnne", "de"] )'
print str( containAtLeastOneWord( phrase, ["essssst", "unnnne", "de"] ) )

[rambc]

Un code un peu plus joli côté test :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
#! /usr/bin/env python
#coding=utf-8
 
def containAllWord(text, words):
    for oneWord in words:
        if oneWord not in text:
            return False
    return True
 
def containAtLeastOneWord(text, words):
    for oneWord in words:
        if oneWord in text:
            return True
    return False
 
if __name__ == '__main__':
    tests = [
              ( "Ceci est une phrase de test.", ["est", "une", "de"] ),
              ( "Ceci est une autre phrase de test.", ["essssst", "unnnne", "de"] ),
              ( "Des mots les unsdanslesautres.", ["unsd", "sda"] )
           ]
 
    for oneTest in tests:
        print ''
 
        for oneFunction in [containAllWord, containAtLeastOneWord]:
            print oneFunction.__name__ + '( ' + oneTest[0] + ', ' + str(oneTest[1]) +' )'
            print '\t===> ' + str( oneFunction(oneTest[0], oneTest[1]) )

On obtient :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
containAllWord( Ceci est une phrase de test., ['est', 'une', 'de'] )
	===> True
containAtLeastOneWord( Ceci est une phrase de test., ['est', 'une', 'de'] )
	===> True
 
containAllWord( Ceci est une autre phrase de test., ['essssst', 'unnnne', 'de'] )
	===> False
containAtLeastOneWord( Ceci est une autre phrase de test., ['essssst', 'unnnne', 'de'] )
	===> True
 
containAllWord( Des mots les unsdanslesautres., ['unsd', 'sda'] )
	===> True
containAtLeastOneWord( Des mots les unsdanslesautres., ['unsd', 'sda'] )
	===> True

Le dernier test montre un problème si les mots se chevauchent, et donc aussi si l'on n'a pas exactement le mot en entier.

[rambc]

Le problème disparait en faisant les modifications suivantes :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
def containAllWord(text, words):
    for oneWord in words:
        if oneWord not in text.split():
            return False
    return True
 
def containAtLeastOneWord(text, words):
    for oneWord in words:
        if oneWord in text.split():
            return True
    return False

[eyquem]

Salut,

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
import re
 
ch = """Sans varier moins que le polle articque 
Doit la Dame estre et de cueur pacifique, 
Porter en paix les grans hurtz de Fortune ; 
Se bien luy vient ou malheur l'importune 
N'en soit joyeuse ou plus melencolicque."""
 
les_mots = set(('articque','cueur','hurtz','luy'))
print les_mots
 
if set(re.findall( '|'.join(les_mots),ch))==les_mots:
    print 'zyssontouss'
else:
    print 'y en manque'

[fred1599]

Oh mais il y a encore plein de solutions

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
phrase = "Ceci est une phrase de test"
def control_mot(*args):
    for mots in args:
        if mots in phrase.split():
            print "le mot %s , est dans le texte" %(mots)
        else :
            print "le mot %s , n\'est pas dans le texte" %(mots)

control_mot("est", "une", "de", "k")

le mot est , est dans le texte
le mot une , est dans le texte
le mot de , est dans le texte
le mot k , n'est pas dans le texte

[wiztricks]

Salut,
Si d'aventure derrière votre question assez banale vous avez de vraies questions de traitement du langage naturel, allez faire un tour du côté de NLTK
C'est "top gun"
- W

[Azerty32]

Super !!
C'est tout bon.
Merci beaucoup à tous pour votre aide !!!

[nardo47]

Salut

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#! /usr/bin/env python
#coding=utf-8
 
phrase = "Ceci est une phrase de test."
 
def containAllWord(text, words):
    for oneWord in words:
        if oneWord not in text:
            return False
    return True
 
 
def containAtLeastOneWord(text, words):
    for oneWord in words:
        if oneWord in text:
            return True
    return False

C'est marrant, je l'aurais fait comme ça:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
 
def containsAllWords(text, words):
    return all(word in text for word in words)
 
def containsAnyWords(text, words):
    return any(word in text for word in words)

(Certes, je pinaille... pinaillons encore + : pourquoi mettre ça dans des fonctions ?)

Après, l'appel à split est bien mais il va manquer des choses.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
 
>>> "Ceci est un test.".split()
['Ceci', 'est', 'un', 'test.']
>>> 'test' in "Ceci est un test.".split()
False

Cela dit, je n'ai pas (encore) jeté un coup d'oeil à NLTK, qui résoudra sûrement ce problème.

Merci à wiztricks pour le lien et bonne lecture aux autres.

[rambc]

C'est marrant, je l'aurais fait comme ça:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
 
def containsAllWords(text, words):
    return all(word in text for word in words)
 
def containsAnyWords(text, words):
    return any(word in text for word in words)

Certes, je pinaille...

Non tu as raison. Merci pour cette précision. Je zappe tout le temps les deux fonctions all et any.

... pinaillons encore + : pourquoi mettre ça dans des fonctions ?

C'est pour la lisibilité du code tout simplement. Ceci est inutile pour de petit code mais pour des "vrais" projets, j'ai pris cette habitude.

[rambc]

Après, l'appel à split est bien mais il va manquer des choses.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
 
>>> "Ceci est un test.".split()
['Ceci', 'est', 'un', 'test.']
>>> 'test' in "Ceci est un test.".split()
False

On peut "patcher" comme suit :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
#! /usr/bin/env python3
 
import string
 
CHARACTERS_TO_KEEP = [x for x in string.ascii_uppercase] + \
                     [
# A
                      'À', 'Á', 'Â', 'Ã', 'Ä', 'Å', 'Æ',
# C
                      'Ç',
# E
                      'È', 'É', 'Ê', 'Ë',
# I
                      'Ì', 'Í', 'Î', 'Ï',
# N
                      'Ñ',
# O
                      'Ò', 'Ó', 'Ô', 'Õ', 'Ö',
# U
                      'Ù', 'Ú', 'Û', 'Ü',
# Y
                      'Ý', 'Ÿ'
                     ]
 
 
def cleanExotic(text):
    answer = ''
    for oneChar in text:
        if oneChar.upper() in CHARACTERS_TO_KEEP:
            answer += oneChar
    return answer
 
def splitCustom(text):
    answer = []
 
    for onePiece in text.split():
        answer.append( cleanExotic(onePiece) )
 
    return answer
 
def containAllWord(text, words):
    return all( oneWord in splitCustom(text) for oneWord in words )
 
def containAtLeastOneWord(text, words):
    return any( oneWord in splitCustom(text) for oneWord in words  )
 
if __name__ == '__main__':
    tests = [
              ( """Ceci est une
                phrase de       test.""", ["est", "une", "de"] ),
              ( "Ceci est une autre phrase de test.", ["es", "une", "de"] ),
              ( "Des mots les unsdanslesautres.", ["unsd", "sda"] ),
              ( "Ceci est une autre phrase de test.", ["test"] )
           ]
 
    for oneTest in tests:
        print('')
 
        for oneFunction in [containAllWord, containAtLeastOneWord]:
            print( oneFunction.__name__ + '( """' + oneTest[0] + '""", ' + str(oneTest[1]) +' )',
                   '\t===> ' + str( oneFunction(oneTest[0], oneTest[1]) ),
                   sep = '\n' )

Pas très joli mais on ne peut pas programmer proprement et regarder la marche au championnat d'Europe.

Question subsidiaire : les regex prennent-elles en compte les accents ?

[rambc]

Question subsidiaire : les regex prennent-elles en compte les accents ?

Il suffit d'essayer avec le code d'equyem et cela marche.

Par contre ce code possède l'inconvénient de considérer bon un mot contenu dans un autre.

[rambc]

Si d'aventure derrière votre question assez banale vous avez de vraies questions de traitement du langage naturel, allez faire un tour du côté de NLTK

Merci pour ce lien.

En espérant qu'un support pour Python3 soit prévu...

[fred1599]

Après, l'appel à split est bien mais il va manquer des choses.

Alors je vais prendre en compte la ponctuation

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
import string
ponctuation=string.punctuation
def parse(texte, *args):
    for p in ponctuation: texte=texte.replace(p, '')
    for mot in args:
        if mot in texte.split(): print "le mot %s, est dans le texte" %(mot)
        else : print "le mot %s, n'est pas dans le texte" %(mot)

parse("Ceci est un test.", "est","une", "de", "test")

le mot est, est dans le texte
le mot une, n'est pas dans le texte
le mot de, n'est pas dans le texte
le mot test, est dans le texte

[nardo47]

... pinaillons encore + : pourquoi mettre ça dans des fonctions ?

C'est pour la lisibilité du code tout simplement. Ceci est inutile pour de petit code mais pour des "vrais" projets, j'ai pris cette habitude.

Ma question était purement réthorique, je suis tout à fait d'accord avec toi, j'ai même du mal à m'arrêter, des fois.

<mode maviequelleestintéressante on>
Par exemple, j'ai, dans mon toolbox perso, une fonction qui me renvoie le premier élément d'un itérable (liste, générateur, etc.), une qui me renvoie le dernier élément d'un itérable, une qui me renvoie tout sauf le premier élément et une qui me renvoie tout sauf le dernier (ceux qui ont déjà touché à Haskell et à d'autres langages fonctionnels reconnaîtront first, last, head et tail).
Aucun intérêt sur une liste (c'est même + long), mais je trouve que ça rend le code + lisible et moins dépendant du type de données.
<mode maviequelleestintéressante off>

----

Attention au code suivant !

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
 
# fred1599.py
import string
ponctuation=string.punctuation
def parse(texte, *args):
    for p in ponctuation: texte=texte.replace(p, '')
    for mot in args:
        if mot in texte.split(): print "le mot %s, est dans le texte" %(mot)
        else : print "le mot %s, n'est pas dans le texte" %(mot)

Je prends ma casquette d'oracle et j'annonce, sans tester, la catastrophe suivante :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
 
>>> from fred1599 import parse
>>> parse('ponctuation = string.punctuation', 'string')
le mot string, n'est pas dans le texte

Par contre, 'string' sera trouvé dans le texte 'ponctuation=string.punctuation'... Ouh, que c'est vicieux !

Je laisse la correction et l'explication comme exercice pour le lecteur (j'ai toujours rêvé d'écrire ça !)

[rambc]

Par exemple, j'ai, dans mon toolbox perso, une fonction qui me renvoie le premier élément d'un itérable (liste, générateur, etc.), une qui me renvoie le dernier élément d'un itérable, une qui me renvoie tout sauf le premier élément et une qui me renvoie tout sauf le dernier (ceux qui ont déjà touché à Haskell et à d'autres langages fonctionnels reconnaîtront first, last, head et tail).

Je vois qu'il y a plus atteint que moi...

Je prends ma casquette d'oracle et j'annonce, sans tester, la catastrophe suivante :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
 
>>> from fred1599 import parse
>>> parse('ponctuation = string.punctuation', 'string')
le mot string, n'est pas dans le texte

Ceci m'amène au patch suivant :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
#! /usr/bin/env python3
 
import string
 
CHARACTERS_TO_KEEP = [x for x in string.ascii_uppercase] + \
                     [
# A
                      'À', 'Á', 'Â', 'Ã', 'Ä', 'Å', 'Æ',
# C
                      'Ç',
# E
                      'È', 'É', 'Ê', 'Ë',
# I
                      'Ì', 'Í', 'Î', 'Ï',
# N
                      'Ñ',
# O
                      'Ò', 'Ó', 'Ô', 'Õ', 'Ö', 'Œ', 
# U
                      'Ù', 'Ú', 'Û', 'Ü',
# Y
                      'Ý', 'Ÿ'
                     ]
 
 
def cleanExotic(text):
    answer = ''
    for oneChar in text:
        if oneChar.upper() in CHARACTERS_TO_KEEP:
            answer += oneChar
        else:
            answer += ' '
    return answer
 
def containAllWord(text, words):
    return all( oneWord in cleanExotic(text).split() for oneWord in words )
 
def containAtLeastOneWord(text, words):
    return any( oneWord in cleanExotic(text).split() for oneWord in words  )
 
if __name__ == '__main__':
    tests = [
              ( """Ceci est une
                phrase de       test.""", ["est", "une", "de"] ),
              ( "Ceci est une autre phrase de test.", ["es", "une", "de"] ),
              ( "Des mots les unsdanslesautres.", ["unsd", "sda"] ),
              ( "Ceci est une autre phrase de test.", ["test"] ),
              ( "ponctuation = string.punctuation", ["string"]),
              ( "ponctuation=string.punctuation", ["string"])
           ]
 
    for oneTest in tests:
        print('')
 
        for oneFunction in [containAllWord, containAtLeastOneWord]:
            print( oneFunction.__name__ + '( """' + oneTest[0] + '""", ' + str(oneTest[1]) +' )',
                   '\t===> ' + str( oneFunction(oneTest[0], oneTest[1]) ),
                   sep = '\n' )

La méthode de fred1599 possède un inconvénient puisqu'on a : string.punctuation ==> !"#$%&'()*+,-./:;<=>?@[\]^_`{|}~ . Donc il manquera des caractères exotiques comme par exemple ×.

Quant à ma dernière méthode, elle est peu élégante car il faut rentrer à la main les caractères accentués ou les contractions 'Œ' et 'Æ'. Existe-t-il un moyen simple d'avoir toutes les lettres d'une langue ?

[fred1599]

Je prends ma casquette d'oracle et j'annonce, sans tester, la catastrophe suivante :

Je m'en doutais, j'ai hésité en le faisant vite fait, il y a juste à remplacer '' par ' ' dans la fonction replace.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
def parse(texte, *args):
    for p in ponctuation: texte=texte.replace(p, ' ')
    for mot in args:
        if mot in texte.split(): print "le mot %s, est dans le texte" %(mot)
        else : print "le mot %s, n'est pas dans le texte" %(mot)

Pour les lettres exotiques apparemment dans le sujet, il n'en n'est pas question.

[Azerty32]

all et any !!
Ah bah voila ! Exactement ce que je cherchais pour faire un code encore + compact !
Merci !

[nardo47]

Existe-t-il un moyen simple d'avoir toutes les lettres d'une langue ?

Le package locale me semblait porteur, mais en fait non.

Je propose :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
 
import string
 
to_erase = set(string.printable) - set(string.digits) - set(string.ascii_letters)

...
...
...

Vu que ça me rappelait quelque chose, j'ai testé ça :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
 
>>> import string
>>> spam1 = ''.join(set(string.printable) - set(string.digits) - set(string.ascii_letters))
>>> spam2 = string.punctuation + string.whitespace
>>> all(x in spam2 for x in spam1)
True
>>> all(x in spam1 for x in spam2)
True

Tout ceci pour dire que je n'ai pas la réponse à ta question (ça, c'est du post utile, coco!)

...
...
...

A la réflexion, vu qu'il faudra aussi gérer l'encodage des caractères exotiques, je préfère mettre comme limitation "ASCII only".
Du moins, tant que je n'ai pas lu NLTK.

Sinon, pour répondre à une question du PO, je conseille de faire une fonction qui ne gère pas que les chaînes de caractère, ça peut toujours servir.
Ce que je veux dire, c'est que les traitements "remplacer les caractères de ponctuation" et "splitter le texte en liste de mots", je ne les ferais pas dans la fonction, mais dans son appelant, histoire de profiter du typage dynamique au maximum.
En même temps, ça permet juste de génériciser l'expression avec all, ce qui me semble être un comportement de psychopathe, à la réflexion.

On peut même se passer de fonction et faire pleins de petites genexp partout !

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
 
>>> text = 'Ceci est une phrase de test hyper-bateau.'
>>> words = 'est une de bateau'.split()
>>> from string import punctuation
>>> # La, j'avoue que je pousse un peu.
>>> text = ''.join(' ' if x in punctuation else x for x in text)
>>> text = text.split()
>>> all(word in text for word in words)
True

[wiztricks]

Salut
re.locale sur \w devrait 'matcher' les mots écrits dans la locale courante, non?
exemple:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
>>> import locale, re
>>> locale.setlocale(locale.LC_ALL, '')
>>> print re.findall('\w+', u'être comme çà' , re.LOCALE)
[u'\xeatre', u'comme', u'\xe7\xe0']

- W