为什么Python 3中的复指数如此之快？

Question

There's a fair amount of weirdness that I've observed recently when playing around with timeit and Python's exponents recently.

First, knowing that math.sin(1) == (e**1j).imag, I was curious about their relative speeds. Here is what I found:

>>> timeit('sin(1)', 'from math import sin')
0.12068345113220857

>>> timeit('(e**1j).imag', 'from math import e')
0.27201285586511403

>>> timeit('exp(1j).imag', 'from cmath import exp')
0.25259275173584683

>>> timeit('(2.718281828459045**1j).imag')
0.04272853350335026

This is bizarre to me. Why is using the number itself and ** so much faster than anything else? Why is it faster than sin? I know it's not due to the import; I ruled that out separably. Also consider:

>>> (2.718281828459045**1j).imag
0.8414709848078965

>>> sin(1)
0.8414709848078965

So, it is giving the correct answers.

I decided to dig a bit deeper, and found that .imag is the real culprit of the slowness of (2.718281828459045**1j).imag . In fact,

>>> timeit('2.718281828459045**1j')
0.013987474140321865

It doesn't seem to be anything specific to 1j; I can use 2j or 0.95j and get the same speed. Additionally, it's even as fast as complex and regular multiplication!

>>> timeit('1*1j')
0.01617102287718808

>>> timeit('1*1')
0.016536898499907693

I am thoroughly confused. How can it be so much faster than sin, when it's doing at least as much work (and also calculating cos)? How can it be as fast as integer multiplication? I suspect part of this is due to noise from the overhead of timeit (there's gotta be a loop somewhere), but even that doesn't explain everything. I would appreciate any help with understanding.

Answer 1

You can explain your observation by looking at the bytecode generated by CPython using the dis module. Lets take a look.

********************************************************************************
from match import sin; sin(1)
  1           0 LOAD_CONST               0 (0)
              2 LOAD_CONST               1 (('sin',))
              4 IMPORT_NAME              0 (match)
              6 IMPORT_FROM              1 (sin)
              8 STORE_NAME               1 (sin)
             10 POP_TOP
             12 LOAD_NAME                1 (sin)
             14 LOAD_CONST               2 (1)
             16 CALL_FUNCTION            1
             18 POP_TOP
             20 LOAD_CONST               3 (None)
             22 RETURN_VALUE
********************************************************************************
from math import e; (e**1j).imag
  1           0 LOAD_CONST               0 (0)
              2 LOAD_CONST               1 (('e',))
              4 IMPORT_NAME              0 (math)
              6 IMPORT_FROM              1 (e)
              8 STORE_NAME               1 (e)
             10 POP_TOP
             12 LOAD_NAME                1 (e)
             14 LOAD_CONST               2 (1j)
             16 BINARY_POWER
             18 LOAD_ATTR                2 (imag)
             20 POP_TOP
             22 LOAD_CONST               3 (None)
             24 RETURN_VALUE
********************************************************************************
from cmath import exp; exp(1j).imag
  1           0 LOAD_CONST               0 (0)
              2 LOAD_CONST               1 (('exp',))
              4 IMPORT_NAME              0 (cmath)
              6 IMPORT_FROM              1 (exp)
              8 STORE_NAME               1 (exp)
             10 POP_TOP
             12 LOAD_NAME                1 (exp)
             14 LOAD_CONST               2 (1j)
             16 CALL_FUNCTION            1
             18 LOAD_ATTR                2 (imag)
             20 POP_TOP
             22 LOAD_CONST               3 (None)
             24 RETURN_VALUE
********************************************************************************
(2.718281828459045**1j).imag
  1           0 LOAD_CONST               0 ((0.5403023058681398+0.8414709848078965j))
              2 LOAD_ATTR                0 (imag)
              4 RETURN_VALUE

As you can see, your last example is so fast because the interpreter is turning the value into a constant when the bytecode is created. You aren't actually doing any work in your last timeit except for the call to imag .