Qu'est - `1..__truediv__` ? Python ont une .. (“dot dot”) de la notation de syntaxe?

La question est déjà suffisamment répondu (c'est à dire @Paul Rooneys réponse), mais il est également possible de vérifier l'exactitude de ces réponses.

Permettez-moi de récapituler les questions /réponses: Le .. n'est pas un seul élément syntaxique!

Vous pouvez vérifier le code source est "segmentées". Ces jetons représentent la façon dont le code est interprété:

>>> 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__'),
 ...]

La chaîne 1. est interprétée comme un numéro, le deuxième . est une OP (opérateur, dans ce cas, l'attribut" opérateur) et le __truediv__ est le nom de la méthode. Donc, c'est juste accès à la __truediv__ méthode du flotteur 1.0.

Une autre façon de visualiser le bytecode généré est de disassembler il. Cette montre, en réalité, les instructions qui sont exécutées lorsque le code est exécuté:

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

Qui dit essentiellement la même. Il charge l'attribut __truediv__ de la constante de 1.0.

---

Concernant votre question

Et comment pouvez-vous l'utiliser dans un environnement plus complexe déclaration (si possible)?

Même s'il est possible que vous ne devrait jamais écrire du code comme ça, tout simplement parce qu'il ne sait pas ce que fait le code. Donc merci de ne pas l'utiliser dans plus d'instructions complexes. J'irais même plus loin que vous ne devriez pas l'utiliser dans la "simple" états, au moins, vous devez utiliser des parenthèses pour séparer les instructions:

f = (1.).__truediv__

ce serait vraiment plus lisible - mais quelque chose le long des lignes de:

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

serait encore mieux!

L'approche à l'aide partial préserve également python du modèle de données (le 1..__truediv__ approche ne fonctionne pas!) ce qui peut être démontrée par ce petit extrait:

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

C'est parce que 1. /(1+2j) n'est pas évalué par float.__truediv__ mais avec complex.__rtruediv__ - operator.truediv fait en sorte que l'opération inverse est appelée lorsque le fonctionnement normal des retours NotImplemented mais vous n'avez pas ces réserves, quand vous travaillez sur __truediv__ directement. Cette perte de "comportement attendu" est la principale raison pour laquelle vous avez (normalement) ne doivent pas utiliser les méthodes magiques directement.

Qu'est-ce que f = 1..__truediv__?

f est une limite de la méthode spéciale sur un flotteur avec une valeur de un. Plus précisément,

1.0 / x

en Python 3, invoque:

(1.0).__truediv__(x)

Preuve:

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

et:

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

Si nous n':

f = one.__truediv__

Nous conservons un nom lié à celui de la méthode liée

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

Si nous faisions cela parsemé de recherche dans une boucle serrée, cela pourrait sauver un peu de temps.

Analyse de l'Arbre de Syntaxe Abstraite (AST)

Nous pouvons voir que l'analyse de l'AST, l'expression nous dit que nous sommes le __truediv__ attribut sur le nombre à virgule flottante, 1.0:

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

Vous pourriez obtenir la même fonction à partir de:

f = float(1).__truediv__

Ou

f = (1.0).__truediv__

Déduction

On peut aussi y aller par déduction.

Nous allons le construire.

1 par lui-même est un int:

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

1 avec une période après c'est un float:

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

Le prochain point par lui-même serait une SyntaxError, mais il commence un pointillé de recherche sur l'instance du flotteur:

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

Personne n'a mentionné cette - C'est maintenant une "lié " méthode" sur le flotteur, 1.0:

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

Nous pourrions accomplir la même fonction beaucoup plus lisible:

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

Performance

La baisse de la divide_one_by fonction est qu'elle nécessite un autre Python cadre de la pile, le rendant légèrement plus lente que la méthode liée:

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

Bien sûr, si vous pouvez simplement utiliser de la plaine des littéraux, c'est encore plus rapide:

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