Was bedeuten Backticks für den Python-Interpreter: `num`

Ich spiele mit Listenverständnissen herum und bin auf einer anderen Seite auf diesen kleinen Ausschnitt gestoßen:

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

Ich habe ein paar Minuten damit verbracht, die Funktion zu replizieren (durch Eingabe), bevor ich merkte, dass das `num`Bit sie kaputt machte.

Was bewirkt das Einfügen einer Anweisung in diese Zeichen? Soweit ich sehen kann, entspricht es str (num). Aber als ich es zeitlich festlegte:

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

Es dauert 4,09 Sekunden, während:

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

dauert 2,43s.

Beide liefern identische Ergebnisse, aber eines ist viel langsamer. Was geht hier vor sich?

EDIT: Seltsamerweise ... repr()liefert etwas langsamere Ergebnisse als `num`. 2,99s vs 2,43s. Verwenden von Python 2.6 (habe 3.0 noch nicht ausprobiert).

Backticks sind ein veralteter Alias ​​für repr(). Verwenden Sie sie nicht mehr, die Syntax wurde in Python 3.0 entfernt.

Die Verwendung von Backticks scheint schneller zu sein als die Verwendung von repr(num)oder num.__repr__()in Version 2.x. Ich denke, das liegt daran, dass eine zusätzliche Wörterbuchsuche im globalen Namespace (für repr) bzw. im Namespace des Objekts (für __repr__) erforderlich ist .

Die Verwendung des disModuls beweist meine Annahme:

def f1(a):
    return repr(a)

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

def f3(a):
    return `a`

Demontage zeigt:

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

f1beinhaltet eine globale Suche nach repr, f2eine Attributsuche nach __repr__, während der Backtick-Operator in einem separaten Opcode implementiert ist. Da weder für die Wörterbuchsuche ( LOAD_GLOBAL/ LOAD_ATTR) noch für Funktionsaufrufe ( CALL_FUNCTION) ein Overhead anfällt, sind Backticks schneller.

Ich denke, dass die Python-Leute entschieden haben, dass es repr()sich nicht lohnt , eine separate Low-Level-Operation zu haben, und dass beides repr()und Backticks gegen das Prinzip verstoßen

"Es sollte einen - und vorzugsweise nur einen - offensichtlichen Weg geben, dies zu tun."

Daher wurde die Funktion in Python 3.0 entfernt.

Backtick-Zitate sind im Allgemeinen nicht nützlich und in Python 3 nicht mehr verfügbar.

Für das, was es wert ist, dies:

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

ist für mich etwas schneller als die Backtick-Version. Aber sich darüber Sorgen zu machen, ist wahrscheinlich eine vorzeitige Optimierung.

Ich vermute, dass numdie Methode nicht definiert ist __str__(), also str()muss eine zweite Suche durchgeführt werden __repr__.

Die Backticks suchen direkt nach __repr__. Wenn dies zutrifft, repr()sollten Sie anstelle der Backticks dieselben Ergebnisse erzielen.