Python 字典与 If 语句速度

Question

我找到了一些链接，讨论 switch case 在 c++ 中比 if else 更快，因为它可以在编译中进行优化。然后我发现了一些建议，人们认为使用字典可能比 If 语句更快。然而，大部分的谈话都是关于某人的工作，最终只是讨论他们应该首先优化代码的其他部分，除非你做了数百万个 if else，否则这并不重要。谁能解释这是为什么？

假设我有 100 个唯一的数字，这些数字将不断地流入 python 代码。我想检查它是哪个数字，然后执行一些操作。所以我可以做大量的 if else，或者我可以将每个数字放入字典中。为了争论起见，假设它是一个线程。

有人了解 python 和可以解释其工作原理的低级执行之间的层吗？

谢谢:)

Answer 1

However, most of the conversation are about someones work end just end up discussing that they should optimize other parts of the code first and it wont matter unless your doing millions of if else. Can anyone explain why this is?

通常，只有在确实需要时才应该费心去优化代码，即如果程序的性能慢得无法使用。

如果是这种情况，您应该使用分析器来确定哪些部分实际上导致了最多的问题。对于 Python，cProfile模块非常适合这个。

Does someone understand the layer between python and the low level execution that can explain how this is working?

如果您想了解代码的执行方式，请查看 dis模块。

一个简单的例子...

import dis

# Here are the things we might want to do
def do_something_a():
    print 'I did a'


def do_something_b():
    print 'I did b'


def do_something_c():
    print 'I did c'


# Case 1
def f1(x):
    if x == 1:
        do_something_a()
    elif x == 2:
        do_something_b()
    elif x == 3:
        do_something_c()


# Case 2
FUNC_MAP = {1: do_something_a, 2: do_something_b, 3: do_something_c}
def f2(x):
    FUNC_MAP[x]()


# Show how the functions execute
print 'Case 1'
dis.dis(f1)
print '\n\nCase 2'
dis.dis(f2)

...输出...

Case 1
 18           0 LOAD_FAST                0 (x)
              3 LOAD_CONST               1 (1)
              6 COMPARE_OP               2 (==)
              9 POP_JUMP_IF_FALSE       22

 19          12 LOAD_GLOBAL              0 (do_something_a)
             15 CALL_FUNCTION            0
             18 POP_TOP
             19 JUMP_FORWARD            44 (to 66)

 20     >>   22 LOAD_FAST                0 (x)
             25 LOAD_CONST               2 (2)
             28 COMPARE_OP               2 (==)
             31 POP_JUMP_IF_FALSE       44

 21          34 LOAD_GLOBAL              1 (do_something_b)
             37 CALL_FUNCTION            0
             40 POP_TOP
             41 JUMP_FORWARD            22 (to 66)

 22     >>   44 LOAD_FAST                0 (x)
             47 LOAD_CONST               3 (3)
             50 COMPARE_OP               2 (==)
             53 POP_JUMP_IF_FALSE       66

 23          56 LOAD_GLOBAL              2 (do_something_c)
             59 CALL_FUNCTION            0
             62 POP_TOP
             63 JUMP_FORWARD             0 (to 66)
        >>   66 LOAD_CONST               0 (None)
             69 RETURN_VALUE


Case 2
 29           0 LOAD_GLOBAL              0 (FUNC_MAP)
              3 LOAD_FAST                0 (x)
              6 BINARY_SUBSCR
              7 CALL_FUNCTION            0
             10 POP_TOP
             11 LOAD_CONST               0 (None)
             14 RETURN_VALUE

...所以很容易看出哪个函数必须执行最多的指令。

至于哪个实际上更快，这是您必须通过分析代码来检查的事情。