Vous êtes ici : Accueil / Forums & ML / Forums Python / Forum général Python / Optimisation d'expressions régulières

Optimisation d'expressions régulières

Remonter à Forum général Python
  • Optimisation d'expressions régulières

    Envoyé par akhaise le 26 Mars 2006 à 11:46
    Bonjour,

    J'utilise le logiciel Kodos pour générer et tester les expressions régulières dont j'ai besoin.
    Seulement, Kodos propose plusieurs solutions et je désirerais savoir laquelle il est préférable d'utiliser lorsque l'on utilise cette expression régulière à de nombreuses reprises (de l'ordre de 10000 fois).

    Voici un exemple de code généré, j'ai la possibilité 3 méthodes :
    import re

    # common variables

    rawstr = r"""<.*?>"""
    embedded_rawstr = r"""<.*?>"""
    matchstr = """Exemple"""

    # method 1: using a compile object
    compile_obj = re.compile(rawstr)
    match_obj = compile_obj.search(matchstr)

    # method 2: using search function (w/ external flags)
    match_obj = re.search(rawstr, matchstr)

    # method 3: using search function (w/ embedded flags)
    match_obj = re.search(embedded_rawstr, matchstr)

    Quel est votre avis?
    • Re: Optimisation d'expressions régulières

      Envoyé par akhaise le 27 Mars 2006 à 22:10
      Merci pour votre aide. ;)
      J'ai finalement utilisé un objet compilé (méthode 1) et j'ai testé avec le module timeit.
      Petite question : comment tester avec timeit les méthodes d'un objet? J'ai essayé mais j'obtiens "ImportError: cannot import name fonctionExemple"?
      J'ai codé moi-même et il apparaît que l'expression régulière est sensiblement meilleure.
    • Re: Optimisation d'expressions régulières

      Envoyé par tarek le 28 Mars 2006 à 01:45
      a tu dois importer le nom, en deuxième paramètre quand tu créé Timer().
      Mais je trouve timeit un peu lourd à cause de ça justement.

      Pour tester les méthodes d'une classe tu peux sortir un peu du cadre de timeit et par exemple utiliser un decorator qui mesure le temps d'exécution d'une focntion ou
      méthode avec time.time():


      >>> last_measure = 0
      >>> import time
      >>> def timeit(function):
      ... def capsule(*arg, **kw):
      ... start = time.time()
      ... try:
      ... return function(*arg, **kw)
      ... finally:
      ... global last_measure
      ... last_measure = time.time() - start
      ... return capsule
      ...
      >>> @timeit
      ... def test(temps):
      ... time.sleep(temps)
      ...
      >>> test(1)
      >>> last_measure
      0.99944210052490234
      >>> test(1.2)
      >>> last_measure
      1.1992747783660889


      si tu a mon livre ( "Programmation Python" ) j'y explique aussi comment
      faire ces mesures indépendamment du matériel, avec les PyStones
    • Re: Optimisation d'expressions régulières

      Envoyé par maxoudamour le 11 Avril 2006 à 16:50
      Ce bout de code marche aussi pour donner le temps d'exécution d'un programme, d'une fonction voir d'un transfert, et bien d'autre...

      ti=time.clock() #ti=temps initial : démarrage de l'horloge
      .
      .
      .
      tf=time.clock() # tf=temps final : arrêt de l'horloge

      print t=tf-ti # affichage de la durée
    • Re: Optimisation d'expressions régulières

      Envoyé par tarek le 26 Mars 2006 à 13:00
      Bonjour,

      Dans ton exemple, embedded_rawstr et rawstr sont pareils,
      donc aucune différence entre #2 et #3.

      Quant à #1, compiler une expression régulière permet d'accélerer les appels à search, lorsqu'ils sont fait plusieurs fois, puisque re.search procède à cette compilation avant de lancer la recherche.
    • Re: Optimisation d'expressions régulières

      Envoyé par ogrisel le 26 Mars 2006 à 22:32
      De maniere générale, pour comparer la rapidité de plusieurs bouts de code qui font la meme chose, il faut utiliser le module timeit dispo dans python depuis la version 2.3 :

      http://docs.python.org/lib/module-timeit.html
    • Re: Optimisation d'expressions régulières

      Envoyé par haypo le 27 Mars 2006 à 10:57
      Pour un exemple aussi simple (recherche "<" et ">"), essaye aussi de le coder à la main pour voir si ce n'est pas rapide avec les fonctions Python classiques.

      Haypo
Rendu par Ploneboard