Was ist `1..__truediv__` ? Funktioniert die Python haben einen .. ("dot dot") - notation-syntax?

Ist die Frage schon ausreichend beantwortet (d.h. @Paul Rooneys Antwort), aber es ist auch möglich, überprüfen Sie die Richtigkeit der Antworten.

Lassen Sie mich zum Schluss den vorhandenen Antworten: .. ist nicht eine einzige syntax-element!

Können Sie überprüfen, wie der source-code ist "tokenized". Diese Token stellen, wie der code interpretiert wird:

>>> from tokenize import tokenize
>>> from io import BytesIO

>>> s = "1..__truediv__"
>>> list(tokenize(BytesIO(s.encode('utf-8')).readline))
[...
 TokenInfo(type=2 (NUMBER), string='1.', start=(1, 0), end=(1, 2), line='1..__truediv__'),
 TokenInfo(type=53 (OP), string='.', start=(1, 2), end=(1, 3), line='1..__truediv__'),
 TokenInfo(type=1 (NAME), string='__truediv__', start=(1, 3), end=(1, 14), line='1..__truediv__'),
 ...]

Also der string 1. wird interpretiert als die Anzahl, die zweiten . ist eine OP (ein operator, in diesem Fall die "get attribute" - operator) und die __truediv__ ist der name der Methode. Dies ist also nur der Zugriff auf die __truediv__ Methode der float 1.0.

Andere Art der Betrachtung der erzeugte bytecode ist disassemble es. Dies zeigt eigentlich die Anweisungen, die ausgeführt werden, wenn ein code ausgeführt wird:

>>> import dis

>>> def f():
...     return 1..__truediv__

>>> dis.dis(f)
  4           0 LOAD_CONST               1 (1.0)
              3 LOAD_ATTR                0 (__truediv__)
              6 RETURN_VALUE

Die sagt im Grunde das gleiche. Es lädt das Attribut __truediv__ von der ständigen 1.0.

Bezüglich Ihrer Frage

Und wie können Sie es in eine komplexere Erklärung (wenn möglich)?

Obwohl es möglich ist, sollten Sie nie code schreiben, der mag, einfach weil es nicht klar ist, was der code tut. Also bitte nicht verwenden es in komplexeren Aussagen. Ich würde sogar so weit gehen, dass Sie sollten nicht verwenden es bei so "einfachen" Aussagen, zumindest sollten Sie Klammern zum trennen der Anleitung:

f = (1.).__truediv__

dies wäre definitiv mehr lesbar, aber etwas entlang der Linien von:

from functools import partial
from operator import truediv
f = partial(truediv, 1.0)

wäre noch besser!

Ansatz mit partial bewahrt auch python-Datenmodell (die 1..__truediv__ Ansatz nicht!) denen nachgewiesen werden kann, durch dieses kleine snippet:

>>> f1 = 1..__truediv__
>>> f2 = partial(truediv, 1.)

>>> f2(1+2j)  # reciprocal of complex number - works
(0.2-0.4j)
>>> f2('a')   # reciprocal of string should raise an exception
TypeError: unsupported operand type(s) for /: 'float' and 'str'

>>> f1(1+2j)  # reciprocal of complex number - works but gives an unexpected result
NotImplemented
>>> f1('a')   # reciprocal of string should raise an exception but it doesn't
NotImplemented

Dies ist, weil 1. /(1+2j) wird nicht ausgewertet durch float.__truediv__ aber mit complex.__rtruediv__ - operator.truediv stellt sicher, dass der reverse-Betrieb wird aufgerufen, wenn auf den normalen Betrieb zurück NotImplemented aber Sie haben nicht diese fallbacks arbeiten wenn Sie auf __truediv__ direkt. Dieser Verlust des "erwarteten Verhalten" ist der Hauptgrund, warum man (normalerweise) sollte keine Magie benutzen Methoden direkt.

Was ist f = 1..__truediv__?

f ist eine gebundene speziellen Methode auf einen float mit einem Wert von eins. Insbesondere

1.0 / x

in Python 3, ruft:

(1.0).__truediv__(x)

Beweis:

class Float(float):
    def __truediv__(self, other):
        print('__truediv__ called')
        return super(Float, self).__truediv__(other)

und:

>>> one = Float(1)
>>> one/2
__truediv__ called
0.5

Wenn wir das tun:

f = one.__truediv__

Behalten wir uns einen Namen gebunden, die gebundene Methode

>>> f(2)
__truediv__ called
0.5
>>> f(3)
__truediv__ called
0.3333333333333333

Wenn wir Taten das, gepunktete Suche in einer engen Schleife, dies könnte sparen Sie ein wenig Zeit.

Parsen des Abstract-Syntax-Tree (AST)

Können wir sehen, dass analysieren des AST für den Ausdruck sagt uns, dass wir immer die __truediv__ - Attribut auf die floating-point-Zahl, 1.0:

>>> import ast
>>> ast.dump(ast.parse('1..__truediv__').body[0])
"Expr(value=Attribute(value=Num(n=1.0), attr='__truediv__', ctx=Load()))"

Können Sie die gleiche Funktion aus:

f = float(1).__truediv__

Oder

f = (1.0).__truediv__

Abzug

Können wir uns auch dort, nach Abzug.

Let ' s build it up.

1 selbst ist ein int:

>>> 1
1
>>> type(1)
<type 'int'>

1 mit einem Punkt nach ist es ein float:

>>> 1.
1.0
>>> type(1.)
<type 'float'>

Den nächsten Punkt alleine wäre ein SyntaxError, aber es beginnt eine gepunktete lookup auf die Instanz des Schwimmers:

>>> 1..__truediv__
<method-wrapper '__truediv__' of float object at 0x0D1C7BF0>

Sonst niemand hat erwähnt, dass dieses - Das ist jetzt ein "bound-Methode" auf den Schwimmer, 1.0:

>>> f = 1..__truediv__
>>> f
<method-wrapper '__truediv__' of float object at 0x127F3CD8>
>>> f(2)
0.5
>>> f(3)
0.33333333333333331

Konnten wir erfüllen die gleiche Funktion, die viel mehr lesbar:

>>> def divide_one_by(x):
...     return 1.0/x
...     
>>> divide_one_by(2)
0.5
>>> divide_one_by(3)
0.33333333333333331

Leistung

Den Nachteil der divide_one_by Funktion ist, dass es erfordert eine andere Python-stack-frame, so dass es etwas langsamer ist als die gebundene Methode:

>>> def f_1():
...     for x in range(1, 11):
...         f(x)
...         
>>> def f_2():
...     for x in range(1, 11):
...         divide_one_by(x)
...         
>>> timeit.repeat(f_1)
[2.5495760687176485, 2.5585621018805469, 2.5411816588331888]
>>> timeit.repeat(f_2)
[3.479687248616699, 3.46196088706062, 3.473726342237768]

Natürlich, wenn Sie nur mit normal-Literale, das ist noch schneller:

>>> def f_3():
...     for x in range(1, 11):
...         1.0/x
...         
>>> timeit.repeat(f_3)
[2.1224895628296281, 2.1219930218637728, 2.1280188256941983]