1
votes

trouver un nom avec des caractères supplémentaires entre dans une chaîne python

J'écris un code simple pour trouver 'bonjour' dans une chaîne même si d'autres caractères se trouvent entre ses caractères, par exemple : hpepllpoo . Mais il y a quelques problèmes.

Mon code est:

```NO```

Pour certaines chaînes par exemple kdjhslfjhshhhheeellllllooooosadsf print YES c'est vrai. Mais il y a un problème. Par exemple, ma chaîne est: helhcludoo

Le résultat est

import re
x = raw_input()

if re.match(r'.*h+e+ll+o+.*',x):
    print ('YES')
else:
    print('NO')

mais je veux le faire correspondre et imprimer YES .

python python-3.x regex

4 commentaires

h + correspond à plusieurs h s, et non à h suivis d'autres lettres.

vous avez besoin de h. * e. * ll. * o quelque chose comme ça

Vous avez la balise python-3.x pour votre question mais utilisez la fonction raw_input dans votre code. Cette fonction est en Python 2 mais pas en 3. Quelle version voulez-vous vraiment? Et pensez-vous que la version de Python est importante pour cette question?

@NimaAnsari Certaines des réponses fournies vous ont-elles été utiles ?

4 Réponses :

0
votes

Vous pouvez faire:

In [2112]: re.search(r'h.*e(?:.*l){2}.*o', 'kdjhslfjhshhhheeellllllooooosadsf')                                                                                                                             
Out[2112]: <re.Match object; span=(3, 28), match='hslfjhshhhheeellllllooooo'>

In [2113]: re.search(r'h.*e(?:.*l){2}.*o', 'helhcludoo')                                                                                                                                                    
Out[2113]: <re.Match object; span=(0, 10), match='helhcludoo'>

Cela correspond essentiellement à zéro ou plusieurs caractères (. * ) entre les caractères souhaités.

{num} est un raccourci pour écrire des motifs répétitifs successifs; ici, par (?:. * l) {2} nous faisons correspondre 2 modèles successifs de . * (mis dans le groupe non capturé (?: ) ). Donc, vous pouvez également écrire:

h.*?e(?:.*?l){2}.*?o

Une autre chose est, vous pouvez utiliser . *? pour avoir la correspondance non gourmande qui doit correspondre la sous-chaîne la plus courte en premier, plutôt que de faire correspondre avidement la plus longue avec . * et d'effectuer un suivi.

h.*e.*l.*l.*o

Exemple:

h.*e(?:.*l){2}.*o

Dans votre expression régulière, vous avez utilisé + qui est censé correspondre à un ou plusieurs des jetons précédents, donc par exemple e + correspond à un ou plusieurs e ; donc votre Regex ne correspondra évidemment pas à la sous-chaîne souhaitée.

0 commentaires

0
votes

Comme l'a dit @ Jean-François Fabre, vous avez besoin d'une expression régulière: r'h.*e.*l.*l.*o.*'

Voici l'implémentation avec des cas de test pour rechercher bonjour dans une chaîne donnée:

import re

def check_hello(x):
    if re.search(r'h.*e.*l.*l.*o.*',x):
        return 'YES'
    return 'NO'

case1 = "kdjhslfjhshhhheeellllllooooosadsf"
case2 = "helhcludoo"
case3 = "nothing here"
case4 = "in between hello here"

assert check_hello(case1) == "YES"
assert check_hello(case2) == "YES"
assert check_hello(case3) == "NO"
assert check_hello(case4) == "YES"

0 commentaires

1
votes

Une autre façon pourrait être d'utiliser une classe caractère annulé pour correspondre à un caractère tel que h , puis ne correspond pas au caractère suivant e 0 fois [^ e] * , puis correspond au caractère suivant e code>.

En utilisant re.match , vous pouvez utiliser:

YES for helhcludoo
YES for kdjhslfjhshhhheeellllllooooosadsf
NO for test helo

  Si vous ne voulez pas faire correspondre les sauts de ligne, vous pouvez utiliser  \ n  dans la classe de caractères annulée. 
   Démo Regex  |  Démo Python  
  Par exemple: 
 strings = [
    "helhcludoo",
    "kdjhslfjhshhhheeellllllooooosadsf",
    "test helo"
]

for x in strings:
    if re.match(r'.*?h[^e]*e[^l]*l[^l]*l[^o]*o',x):
        print ('YES for %s' % x)
    else:
        print ('NO for %s' % x)
  Cela imprimera: 
 .*?h[^e]*e[^l]*l[^l]*l[^o]*o

0 commentaires

0
votes

Je propose une autre solution, n'utilisant pas d'expressions régulières. De cette façon, vous pouvez donner n'importe quel mot à rechercher.

def check(x, word):
     if not word:
         return "YES"

     for c in x:
         if c == word[0]:
             word = word[1:]
             if not word:
                 return "YES"
     return "NO"

case1 = "kdjhslfjhshhhheeellllllooooosadsf"
case2 = "helhcludoo"
case3 = "nothing here"
case4 = "in between hello here"

assert check(case1, "hello") == "YES"
assert check(case2, "hello") == "YES"
assert check(case3, "hello") == "NO"
assert check(case4, "hello") == "YES"

0 commentaires