Question

我想深入理解为什么以下两个生成的操作码是相同的（加载/存储的值除外）。

特别是如何将此'BINARY_MULTIPLY'同时用于str和int？ C（CPython）是否在后台进行类型检查并应用正确的函数，不管值是字符串还是整数？

我们可以说这种机制与鸭子的打字有关吗？

>>> def tata():
...     a = 1
...     b = 1
...     c = a * b
... 
>>> dis.dis(tata)
  2           0 LOAD_CONST               1 (1)
              3 STORE_FAST               0 (a)

  3           6 LOAD_CONST               1 (1)
              9 STORE_FAST               1 (b)

  4          12 LOAD_FAST                0 (a)
             15 LOAD_FAST                1 (b)
             18 BINARY_MULTIPLY     
             19 STORE_FAST               2 (c)
             22 LOAD_CONST               0 (None)
             25 RETURN_VALUE      

>>> def toto():
...     a = "1"
...     b = "1"
...     c = a * b
... 
>>> dis.dis(toto)
  2           0 LOAD_CONST               1 ('1')
              3 STORE_FAST               0 (a)

  3           6 LOAD_CONST               1 ('1')
              9 STORE_FAST               1 (b)

  4          12 LOAD_FAST                0 (a)
             15 LOAD_FAST                1 (b)
             18 BINARY_MULTIPLY     
             19 STORE_FAST               2 (c)
             22 LOAD_CONST               0 (None)
             25 RETURN_VALUE

Answer 1

Python字节码具有极高的水平，并且鉴于该语言极其动态的语义，它不能做太多不同的事情。当您在源代码中指定BINARY_MULTIPLY时，无论操作数的类型如何，都会发出*。确切的操作是在运行时确定的。

这在事后看来很明显：在Python 一般中，类型仅在运行时才知道，并且鉴于其允许的灵活性（例如，通过monkeypatching），您可以确定仅在运行时才做执行的时刻。毫不奇怪，这是CPython这么慢的原因之一。

在特定情况下，例如您的示例中所示，编译器可以在编译时执行类型推断并执行计算，或者至少发出一些（虚构的）更具体的操作码。不幸的是，这会使解释器复杂化，并且在一般情况下并没有太大帮助，因为通常您的计算涉及来自外部的参数，例如：

def square(x):
    return x*x

x可以是任何类型，因此编译时的智能性没有用。

def times5(x):
    return x * 5

即使这里已知5，times5也会根据x（"a"-> "aaaaa"; 2- > 10； 4.5-> 22.5；某些自定义类类型->它取决于运算符重载，仅在运行时才知道）。

您可以使用asm.js方法并找到用于提供类型提示的倾斜方法，但是相反，Python（PyPy）的高性能实现仅使用跟踪JIT方法自行推导了常用的参数类型（在运行代码一段时间后），并生成针对观察到的情况优化的机器代码。

Answer 2

第一个问题的答案是肯定的。 Python（CPython实现）在内部检查操作数的类型，并应用正确的函数，无论值是字符串还是整数。出现这种情况的原因虽然与实现相关，但通常是因为它的优化程度更高（C显然比Python快），并且从某种意义上讲，在确定操作之后推迟类型检查会更加巧妙。原因之一可能是因为1）操作数的数量多于操作数。 2）类型检查（至少在CPython实现中）可以在内部流程中轻松，正确地完成。

第二个问题的答案为否，因为我们无法根据代码/等式/等的其他属性来确定这些对象的类型。我们只是以较低的优先级来做。

还请注意，方程式中字节码顺序的另一个重要方面是，字节码的执行顺序与由相应解析器创建的最终解析树相关。考虑以下示例：

In [4]: dis.dis("a, b, c, d = 4, 5, 7, 0; a + b * c - d")
  1           0 LOAD_CONST               5 ((4, 5, 7, 0))
              3 UNPACK_SEQUENCE          4
              6 STORE_NAME               0 (a)
              9 STORE_NAME               1 (b)
             12 STORE_NAME               2 (c)
             15 STORE_NAME               3 (d)
             18 LOAD_NAME                0 (a)
             21 LOAD_NAME                1 (b)
             24 LOAD_NAME                2 (c)
             27 BINARY_MULTIPLY
             28 BINARY_ADD
             29 LOAD_NAME                3 (d)
             32 BINARY_SUBTRACT
             33 POP_TOP
             34 LOAD_CONST               4 (None)
             37 RETURN_VALUE

Answer 3

这确实与鸭子类型有关，鸭子类型将类型检查或方法有效性/存在检查延迟到调用之前。 python BINARY_MULTIPLY完全执行python表达式lambda x, y: x * y的作用。只要支持__mul__协议，它就与任何类型都没有明确关联。

如果您想知道这在C语言中是如何工作的，python会将操作码委托给PyNumber_Multiply，如果可能的话，它会从__mul__插槽中获取方法（或者如果对象被使用，它会重复执行）是sequence），其中此方法是特定于类型的。换句话说，int，float，str，list的__mul__可能不同。

了解为什么来自不同代码的这些操作码是相同的

3 个答案: