python équivalent de "#define func() ' ou comment commenter un appel de fonction en python

mon code python est entrelacé avec beaucoup d'appels de fonction utilisé pour (débogage|profil|traçage, etc.)
par exemple:

import logging

logging.root.setLevel(logging.DEBUG)
logging.debug('hello')
j = 0
for i in range(10):
    j += i
    logging.debug('i %d j %d' % (i,j))
print(j)
logging.debug('bye')

je veux #define ces consommer beaucoup de ressources fonctions de code. quelque chose comme le c équivalent

#define logging.debug(val)

oui, je sais que le module de journalisation journalisation niveau de mécanisme peut être utilisé pour masquer mémorisations ci-dessous le niveau du journal. mais, im demandant une manière générale, pour avoir l'interpréteur python sauter fonctions (qui prennent du temps à s'exécuter même si elles ne le faites pas beaucoup)

une idée est de redéfinir les fonctions que je veux commenter dans les vides fonctions:

def lazy(*args): pass
logging.debug = lazy

l'idée ci-dessus encore, appelle une fonction, et peut créer une myriade d'autres problèmes

OriginalL'auteur random guy | 2010-01-05

  1. 17

    Python n'ont pas de préprocesseur, bien que vous pouvez exécuter votre source python par l'intermédiaire d'un préprocesseur pour obtenir le même effet - par exemple sed "/logging.debug/d" débarrassera de tous les enregistrement de débogage de commandes. Ce n'est pas très élégant, mais - vous finirez par avoir besoin d'une sorte de système de construction pour exécuter tous vos modules à travers le préprocesseur et peut-être créer un nouveau répertoire de l'arborescence du traité .py fichiers avant d'exécuter le script principal.

    Sinon, si vous avez mis toutes vos instructions de débogage dans un if __debug__: bloc, ils recevront optimisé lorsque python est exécuté avec l'option-O (optimiser) drapeau.

    En aparté, j'ai vérifié le code avec le dis module pour s'assurer qu'il ne optimisé loin. J'ai découvert que les deux

    if __debug__: doStuff()

    et

    if 0: doStuff()

    sont optimisés, mais 

    if False: doStuff()

    ne l'est pas. C'est parce que de Faux est régulièrement l'objet Python, et vous pouvez en fait cela:

    >>> False = True
>>> if False: print "Illogical, captain"
Illogical, captain

    Qui me semble être une faille dans la langue - j'espère que c'est résolu dans Python 3.

    Edit:

    C'est corrigé dans Python 3: Affectation de la valeur True ou False donne maintenant un SyntaxError.
    Depuis le Vrai et le Faux sont des constantes dans Python 3, cela signifie que if False: doStuff() est maintenant optimisé:

    >>> def f():
...     if False: print( "illogical")
... 
>>> dis.dis(f)
  2           0 LOAD_CONST               0 (None) 
              3 RETURN_VALUE
    Il fonctionne de la même en Python 3.
    ajoutant si 0: | si debug: | si la variable: + optimisation, que ce soit par le biais d'un script ou d'un bon éditeur peut être la meilleure idée (mieux que ajoutant le # qui ne gère pas le multi-ligne consolidés). peut-être que python n'est pas parfait, après tout
    une belle python virus permettrait d'injecter de la ligne "False,True=True,False" dans le code. de merveilleuses choses peuvent arriver

    OriginalL'auteur Dave Kirby

  2. 2

    Bien que je pense que la question est parfaitement claire et valide (malgré les nombreuses réponses qui suggèrent le contraire), la réponse courte est "il n'y a pas de support en Python".

    La seule solution autre que la préprocesseur suggestion serait d'utiliser certains le bytecode de piratage. Je ne vais même pas commencer à imaginer comment cela devrait fonctionner dans les conditions de l'API de haut niveau, mais à un faible niveau que l'on pouvait imaginer l'examen de code d'objets pour certaines séquences d'instructions et de les réécrire pour les éliminer.

    Regardez, par exemple, les deux fonctions suivantes:

    >>> def func():
...    if debug:  # analogous to if __debug__:
...       foo
>>> dis.dis(func)
  2           0 LOAD_GLOBAL              0 (debug)
              3 JUMP_IF_FALSE            8 (to 14)
              6 POP_TOP

  3           7 LOAD_GLOBAL              1 (foo)
             10 POP_TOP
             11 JUMP_FORWARD             1 (to 15)
        >>   14 POP_TOP
        >>   15 LOAD_CONST               0 (None)
             18 RETURN_VALUE

    Ici vous pouvez numériser la LOAD_GLOBAL de debug, et de l'éliminer et de tout jusqu'à la JUMP_IF_FALSE cible.

    Celui-ci est le plus traditionnel de style C fonction debug() qui obtient bien effacé par un préprocesseur:

    >>> def func2():
...    debug('bar', baz)
>>> dis.dis(func2)
  2           0 LOAD_GLOBAL              0 (debug)
              3 LOAD_CONST               1 ('bar')
              6 LOAD_GLOBAL              1 (baz)
              9 CALL_FUNCTION            2
             12 POP_TOP
             13 LOAD_CONST               0 (None)
             16 RETURN_VALUE

    Ici, vous devriez regarder pour LOAD_GLOBAL de debug et essuyez tout jusqu'à la correspondante CALL_FUNCTION.

    Bien sûr, ces deux descriptions de ce que vous ne sont beaucoup plus simple que ce que vous auriez vraiment besoin de tous, mais le plus simpliste, les modes d'utilisation, mais je pense que ce serait faisable. Ferait un joli projet, si personne n'est déjà fait.

    OriginalL'auteur Peter Hansen

  3. 1

    Bien, vous pouvez toujours mettre en place votre propre préprocesseur simple qui fait le tour. Ou, mieux encore, vous pouvez en utiliser une déjà existante. Dire http://code.google.com/p/preprocess/

    Il y a aussi code.google.com/p/pypreprocessor.

    OriginalL'auteur Tomas Brambora

  4. 0

    Utiliser un module d'étendue variable?

    from config_module import debug_flag

    et l'utilisation de cette "variable" à la porte d'accès à la fonction d'enregistrement(s). Vous construire vous-même un logging module qui utilise le debug_flag à la porte de la fonctionnalité de journalisation.

    si je dois ajouter un contrôle avant chaque appel de fonction?
    guy: plus Sale que c'est déjà le cas avec toutes ces instructions de débogage??
    pas de je dois changer tous les appels à l'enregistrement de ma classe wrapper?
    le débogage est l'exemple le plus commun, je pense off. mais la magie de la fonction im requérant est bon pour d'autres choses comme de l'activer/désactiver des fonctionnalités
    guy: non, pas vraiment: il suffit d'utiliser le module pour configurer la fonctionnalité de journalisation basé sur la debug_flag.

    OriginalL'auteur jldupont

  5. 0

    Je pense que complètement aboiding l'appel à une fonction n'est pas possible, comme Python fonctionne d'une manière différente que C. Le #define prend place dans la pré-compilateur, avant que le code est compilé. En Python, il n'y a pas une telle chose.

    Si vous souhaitez supprimer complètement l'appel de débogage dans un environnement de travail, je pense que la seule façon, si vraiment changer le code avant l'exécution. Avec un script précédent pour l'exécution, vous pouvez commenter/décommenter les lignes de débogage.

    Quelque chose comme ceci:

    Fichier logging.py

    #Main module
def log():
    print 'logging'

def main():
    log()
    print 'Hello'
    log()

    Fichier call_log.py

    import re
#To log or not to log, that's the question
log = True

#Change the loging
with open('logging.py') as f:
    new_data = []
    for line in f:
       if not log and re.match(r'\s*log.*', line):
         #Comment
         line = '#' + line
       if log and re.match(r'#\s*log.*', line):
         #Uncomment
         line = line[1:]
       new_data.append(line)

#Save file with adequate log level
with open('logging.py', 'w') as f:
   f.write(''.join(new_data))


#Call the module
import logging
logging.main()

    Bien sûr, il a ses problèmes, spécialement si il y a beaucoup de modules et sont complexes, mais il pourrait être utilisable si vous devez absolument éviter l'appel à une fonction.

    OriginalL'auteur Khelben

  6. 0

    Avant de le faire, avez-vous profilé de manière à vérifier que l'enregistrement est fait en prenant une quantité importante de temps? Vous pouvez trouver que vous passez plus de temps à essayer de supprimer les appels que vous enregistrez.

    Prochaine, avez-vous essayé quelque chose comme Psyco? Si vous avez des choses mis en place afin de journalisation est désactivée, Psyco peut être en mesure d'optimiser loin la plupart des généraux de l'appel de la fonction de journalisation, en remarquant qu'il retournera toujours sans action.

    Si vous trouvez toujours la journalisation de prendre une quantité appréciable de temps, vous pouvez voulez regarder primordial de la fonction d'enregistrement à l'intérieur de critique des boucles, peut-être par la liaison d'une variable locale, soit de la fonction d'enregistrement ou un mannequin de fonction appropriée (ou en vérifiant qu'Aucun avant de l'appeler).

    je n'ai pas fait moi-même clair. j'ai utilisé le module de journalisation et de la performance comme un exemple. il y a d'autres raisons de vouloir commenter les fonctions, par exemple, lors de l'élimination d'une fonction à partir du code

    OriginalL'auteur Andrew Aylett

  7. 0

    définir une fonction qui ne fait rien, c'est à dire

    def nuzzing(*args, **kwargs): pass

    Puis vient de la surcharge de toutes les fonctions dont vous voulez vous débarrasser de votre fonction, ala

    logging.debug = nuzzing
    ma question initiale comprend une variante de cette solution
    Ouais, mais en laissant votre espace réservé à l'appel de la fonction elle-même de manière récursive, en vous laissant la porte ouverte pour l'immédiat, la méchanceté ( max appel de la profondeur de la pile de dépassement ). La récente disponible compilateur est assez intelligent pour réduire toute fonction qui n'est passer pour un noop de toute façon, de sorte que tous les appels sont effectivement commenté. Je n'imagine pas que vous allez trouver une meilleure solution.

    OriginalL'auteur richo

  8. 0

    J'aime bien le "si __debug_" solution sauf que le mettre en face de chaque appel est un peu distrait et laid. J'ai eu ce même problème et l'a résolu par l'écriture d'un script qui analyse automatiquement vos fichiers source et remplace la journalisation des états avec des pass annuels (et commentée des copies de l'enregistrement des déclarations). Il peut également annuler cette conversion.

    Je l'utilise quand je déployer le nouveau code pour un environnement de production où il y a beaucoup de journalisation des déclarations qui je n'ai pas besoin dans un environnement de production et ils sont d'affecter les performances.

    Vous pouvez trouver le script ici: http://dound.com/2010/02/python-logging-performance/

    OriginalL'auteur David Underhill

  9. -1

    Vous ne pouvez pas sauter appels de fonction. Vous pouvez redéfinir ces vides si, par exemple, par la création d'un autre objet connexion qui fournit la même interface, mais avec des fonctions vide.

    Mais de loin le plus propre approche consiste à ignorer le faible degré de priorité des messages de journal (comme vous l'avez suggéré):

    logging.root.setLevel(logging.CRITICAL)
    je n'ai pas fait moi-même clair. je suis à la recherche d'un objectif général de python hack 'commentaire' des appels de fonction. c'est, je veux le " a commenté fonctions de ne pas même être appelé. votre suggestion n'élimine pas l'appel à la fonction de journalisation.debug(). la fonction est appelée, et un peu de traitement. c'est ce que je veux éviter
    Tu t'es fait clair, mais je ne pense pas que c'est pythonic à faire ce que vous avez demandé.

    OriginalL'auteur user238424