Qu'est-ce que les backticks signifient pour l'interpréteur python: `num`

Question

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 l' `num` été de le casser.

Ce n'joignant une déclaration dans ces personnages? 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 considérant ce qui suit:

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).

Answer 1

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 d' 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 ( repr), ou dans l'objet de l'espace de noms ( __repr__), respectivement.

EDIT: à l'Aide de l' 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, ni pour les appels de fonction, backticks sont plus rapides.

Je suppose que le Python personnes ont décidé qu'ayant un faible niveau de fonctionnement pour l' 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.

Answer 2

Les guillemets inversés ne sont généralement pas utiles et ont disparu dans Python 3.

Pour ce que ça vaut, ça:

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

est légèrement plus rapide que la version backtick pour moi. Mais s’inquiéter de cela est probablement une optimisation prématurée.

Answer 3

Mon hypothèse est que num ne définit pas la méthode __str__() , donc str() doit effectuer une seconde recherche pour __repr__ .

Les backticks recherchent directement __repr__ . Si cela est vrai, alors utiliser repr() au lieu des backticks devrait vous donner les mêmes résultats.