Ce n'backticks moyenne de l'interpréteur python: `num`

Je suis en train de jouer autour avec des interprétations de la liste et je suis tombé sur ce petit extrait de code sur un autre site:

return ''.join([`num` for num in xrange(loop_count)])

J'ai passé quelques minutes à essayer de reproduire la fonction (en tapant) avant de réaliser la `num` peu cassât.

Ce n'joignant une déclaration dans ces personnages n'? De ce que je peux voir c'est l'équivalent de str(num). Mais quand je l'ai chronométré:

return ''.join([str(num) for num in xrange(10000000)])

Il faut 4.09 s tandis que:

return ''.join([`num` for num in xrange(10000000)])

prend 2.43 s.

Les deux donnent des résultats identiques, mais l'un est beaucoup plus lent. Ce qui se passe ici?

EDIT: Bizarrement... repr() donne un peu plus lent, les résultats que `num`. 2.99 s vs 2.43 s. À l'aide de Python 2.6 (n'ai pas essayé encore 3.0).

  • Après la lecture de la "un autre du site" dans le skymind.com/~ocrow/python_string, j'ai eu une question similaire, et trouvé cette page. Bonne question et la réponse belle 🙂
InformationsquelleAutor Dominic Bou-Samra | 2009-11-04
  1. 118

    Backticks sont obsolète, alias pour repr(). Ne les utilisez pas plus, la syntaxe a été supprimé en Python 3.0.

    À l'aide de backticks semble être plus rapide que l'utilisation repr(num) ou num.__repr__() dans la version 2.x. Je suppose que c'est parce que plus de recherche dans le dictionnaire est nécessaire dans l'espace de noms global (pour repr), ou dans l'objet de l'espace de noms (pour __repr__), respectivement.

    À l'aide de la dis module prouve mon hypothèse:

    def f1(a):
    return repr(a)

def f2(a):
    return a.__repr__()

def f3(a):
    return `a`

    Démontage montre:

    >>> import dis
>>> dis.dis(f1)
  3           0 LOAD_GLOBAL              0 (repr)
              3 LOAD_FAST                0 (a)
              6 CALL_FUNCTION            1
              9 RETURN_VALUE
>>> dis.dis(f2)
  6           0 LOAD_FAST                0 (a)
              3 LOAD_ATTR                0 (__repr__)
              6 CALL_FUNCTION            0
              9 RETURN_VALUE        
>>> dis.dis(f3)
  9           0 LOAD_FAST                0 (a)
              3 UNARY_CONVERT       
              4 RETURN_VALUE

    f1 implique un mondial de recherche pour repr, f2 un attribut de recherche pour __repr__, alors que le backtick opérateur est mis en œuvre dans un autre opcode. Depuis il n'y a pas de frais généraux pour la recherche dans le dictionnaire ( LOAD_GLOBAL /LOAD_ATTR ), ni pour les appels de fonction (CALL_FUNCTION), backticks sont plus rapides.

    Je suppose que le Python personnes ont décidé qu'ayant un faible niveau de fonctionnement pour repr() n'est pas la peine, et que les deux repr() et backticks, viole le principe de

    "Il devrait y avoir un, et de préférence seulement une façon évidente de le faire"

    de sorte que la fonctionnalité a été supprimée en Python 3.0.

    • Je voulais savoir, comment vous pouvez remplacer les backticks avec une fonction d'appel, mais il semble qu'il n'est pas possible, ou est-il?
    • Utilisation repr() au lieu de backticks. Backticks sont amortis sur une syntaxe pour repr() viennent 3.0. Je préfère le look de backticks plutôt que d'appeler une AUTRE fonction.
    • La raison backticks sont dépréciées est aussi en raison du caractère lui-même; il peut être difficile de taper (sur certains claviers), difficile de voir ce qu'il est, difficile de s'imprimer correctement en Python livres. Etc.
    • Merci pour cette remarque. C'est probablement la raison principale de l'abandon backticks, voir Guidos déclaration dans les archives des listes de diffusion: mail.python.org/pipermail/python-ideas/2007-January/000054.html
    • La question de départ, cela a été posté parce que je ne pouvais pas vraiment trouver de backticks sur mon clavier 😉 en Dessous de la tilde il semble après recherche sur google.
    • Pourquoi there is no overhead for dictionary lookup nor for function calls est vrai?
    • voir la sortie de dis, il montre comment Python implémente les fonctions en interne. LOAD_GLOBAL signifie qu'il y a une recherche dans le dictionnaire, au niveau mondial, pour la fonction repr, qui est appelée par la suite. LOAD_ATTR est une recherche dans le dictionnaire pour l'attribut __repr__ qui est aussi appelé. Les deux n'est pas nécessaire pour les backticks version, où il existe un opcode UNARY_CONVERT sans LOAD_* et CALL_FUNCTION. Donc le code qui fait ce que repr() n'est atteint plus directement, et l'ensemble de la fonction effectue mieux.

    InformationsquelleAutor Ferdinand Beyer
  2. 9

    Backtick échappement n'est généralement pas utile et disparu en Python 3.

    Pour ce que ça vaut, c':

    ''.join(map(repr, xrange(10000000)))

    est légèrement plus rapide que la backtick version pour moi. Mais se soucier de ce qui est probablement prématuré de l'optimisation.

    • Pourquoi aller un pas en arrière et utiliser la carte au lieu de la liste/itérateur interprétations?
    • En fait, timeit les rendements des résultats plus rapides pour ''.join(map(repr, xrange(0, 1000000))) que pour ''.join([repr(i) for i in xrange(0, 1000000)]) (encore pire pour ''.join( (repr(i) for i in xrange(0, 1000000)) )). C'est un peu décevant 😉
    • bobince du résultat n'est pas surprenant pour moi. Comme règle de base, les boucles implicites en Python sont plus rapides qu'explicite ceux, souvent considérablement plus rapide. map est implémenté en C, à l'aide d'une boucle C, qui est beaucoup plus rapide qu'une boucle Python exécuté dans la machine virtuelle.
    • Pas surpris non plus, c'est juste trop mauvais pour les interprétations de la liste réputation (avec 30% de touché dans cet exemple). Mais je préfère avoir clairement que l'éclair vitesse code, sauf si c'est vraiment important, donc pas de gros problème ici. Cela étant dit, la carte() fonction ne me paraissent pas claires, LC sont parfois surfaite.
    • map semble parfaitement clair et concis pour moi, et je ne sais même pas Python.
    • J'enseigne Python, et pense toujours que map est parfaitement clair, mais je ne l'utiliserais une compréhension dans la pratique, parce que ce n'est pas la peine de cognement d'autres développeurs. Certaines choses valent la peine de la friction, ce n'est pas le cas.
    • Si ce n'était pas être évalué immédiatement, alors je vais utiliser un de la compréhension; mais il semble juste comme inutile gonfler lorsque toutes les valeurs doivent être utilisées immédiatement dans ce cas particulier. Cela étant dit, il y a beaucoup de cas d'utilisation pour les interprétations de la liste; ce n'est tout simplement pas l'un d'eux.
    • Bon point. Ce code spécifique n'genre de mendier l'utilisation de map.
    • ce n'est pas implicite/explicite des boucles, c'est parce que dans le cas de la carte, il n'y a qu'une seule dict recherche pour "repr", tandis que dans la compréhension de liste cas, mondial de recherche parfois dominer la vitesse.

    InformationsquelleAutor bobince
  3. 1

    Ma conjecture est que num ne définit pas la méthode __str__(), donc str() a le faire une deuxième recherche pour __repr__.

    Les backticks regarder directement pour __repr__. Si cela est vrai, alors l'utilisation de repr() au lieu de les backticks devrait vous donner les mêmes résultats.

    InformationsquelleAutor Aaron Digulla