什么是`1 ..__ truediv__`？ Python有一个......（“点点”）表示法语法吗？

时间：2017-04-19 06:15:59

标签： python python-3.x syntax operators python-2.x

我最近遇到了一种我以前从未见过的语法，当我学习python时，在大多数教程中都没有..符号，它看起来像这样：

f = 1..__truediv__ # or 1..__div__ for python 2

print(f(8)) # prints 0.125

我认为它完全相同（当然除了它更长）：

f = lambda x: (1).__truediv__(x)
print(f(8)) # prints 0.125 or 1//8

但我的问题是：

  • 怎么做呢？
  • 这两个点实际上意味着什么？
  • 如何在更复杂的陈述中使用它（如果可能）？

这可能会在将来为我节省很多代码......：）

4 个答案:

答案 0 :(得分：212)

你拥有的是float字面值而没有尾随零，然后你可以访问__truediv__方法。它本身不是一个运营商;第一个点是浮点值的一部分，第二个点是访问对象属性和方法的点运算符。

您可以通过执行以下操作达到相同的目标。

>>> f = 1.
>>> f
1.0
>>> f.__floordiv__
<method-wrapper '__floordiv__' of float object at 0x7f9fb4dc1a20>

另一个例子

>>> 1..__add__(2.)
3.0

这里我们添加1.0到2.0，显然会产生3.0。

答案 1 :(得分：73)

这个问题已经得到了充分的回答（即@Paul Rooney的回答），但也可以验证这些答案的正确性。

让我回顾一下现有的答案：..不是单一的语法元素！

您可以查看源代码的"tokenized"。这些标记表示代码的解释方式：

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

因此字符串1.被解释为数字，第二个.是OP（运算符，在这种情况下是＆＃34; get属性＆＃34;运算符）和{{1是方法名称。所以这只是访问float __truediv__的{​​{1}}方法。

查看生成的字节码的另一种方法是 disassemble它。这实际上显示了执行某些代码时执行的指令：

__truediv__

基本上说的一样。它会加载常量1.0的属性>>> 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 。

关于你的问题

  

如何在更复杂的陈述中使用它（如果可能的话）？

即使它可能，你也不应该编写这样的代码，只是因为它不清楚代码在做什么。所以请不要在更复杂的陈述中使用它。我甚至会走得太远以至于你不应该这样使用它，简单的＆＃34;语句，至少你应该使用括号来分隔指令：

__truediv__

这肯定会更具可读性 - 但有些内容如下：

1.0

会更好！

使用f = (1.).__truediv__ 的方法也会保留python's data model（from functools import partial from operator import truediv f = partial(truediv, 1.0) 方法不会！），这可以通过这个小片段进行演示：

partial

这是因为1..__truediv__未对>>> 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 进行评估，但使用1. / (1+2j) - float.__truediv__可确保在正常操作返回complex.__rtruediv__时调用反向操作但是当你直接对operator.truediv进行操作时，你不会有这些后备。这种＆＃34;预期行为的丧失＆＃34;这是你（通常）不应该直接使用魔法的主要原因。

答案 2 :(得分：40)

起初两个点可能有点尴尬：

f = 1..__truediv__ # or 1..__div__ for python 2

但它与写作相同：

f = 1.0.__truediv__ # or 1.0.__div__ for python 2

因为float文字可以用三种形式书写：

normal_float = 1.0
short_float = 1.  # == 1.0
prefixed_float = .1  # == 0.1

答案 3 :(得分：11)

  

什么是f = 1..__truediv__？

f是一个值为1的float上的绑定特殊方法。具体地，

1.0 / x
在Python 3中，

调用：

(1.0).__truediv__(x)

证据：

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

和

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

如果我们这样做：

f = one.__truediv__

我们保留一个绑定到该绑定方法的名称

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

如果我们在紧密的循环中进行虚线查找，这可以节省一点时间。

解析抽象语法树（AST）

我们可以看到解析表达式的AST告诉我们我们在浮点数__truediv__上得到1.0属性：

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

您可以从以下方式获得相同的结果函数：

f = float(1).__truediv__

或者

f = (1.0).__truediv__

推导

我们也可以通过演绎到达那里。

让我们建立它。

1本身就是int：

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

1，它是浮动后的一段时间：

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

下一个点本身就是一个SyntaxError，但它在float的实例上开始点缀查找：

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

没有人提到这个 - 现在这是浮动的{strong>“绑定方法”，1.0：

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

我们可以更可读地完成相同的功能：

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

效果

divide_one_by函数的缺点是它需要另一个Python堆栈帧，使其比绑定方法慢一点：

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

当然，如果你可以使用普通文字，那就更快了：

>>> def f_3():
...     for x in range(1, 11):
...         1.0/x
...         
>>> timeit.repeat(f_3)
[2.1224895628296281, 2.1219930218637728, 2.1280188256941983]
相关问题
最新问题