A partir desta página , sabemos que:
As comparações encadeadas são mais rápidas que o uso do
and
operador. Escreva emx < y < z
vez dex < y and y < z
.
No entanto, obtive um resultado diferente testando os seguintes trechos de código:
$ python -m timeit "x = 1.2" "y = 1.3" "z = 1.8" "x < y < z"
1000000 loops, best of 3: 0.322 usec per loop
$ python -m timeit "x = 1.2" "y = 1.3" "z = 1.8" "x < y and y < z"
1000000 loops, best of 3: 0.22 usec per loop
$ python -m timeit "x = 1.2" "y = 1.3" "z = 1.1" "x < y < z"
1000000 loops, best of 3: 0.279 usec per loop
$ python -m timeit "x = 1.2" "y = 1.3" "z = 1.1" "x < y and y < z"
1000000 loops, best of 3: 0.215 usec per loop
Parece que x < y and y < z
é mais rápido que x < y < z
. Por quê?
Depois de pesquisar algumas postagens neste site (como esta ), eu sei que "avaliado apenas uma vez" é a chave x < y < z
, mas ainda estou confuso. Para fazer um estudo mais aprofundado, desmontei essas duas funções usando dis.dis
:
import dis
def chained_compare():
x = 1.2
y = 1.3
z = 1.1
x < y < z
def and_compare():
x = 1.2
y = 1.3
z = 1.1
x < y and y < z
dis.dis(chained_compare)
dis.dis(and_compare)
E a saída é:
## chained_compare ##
4 0 LOAD_CONST 1 (1.2)
3 STORE_FAST 0 (x)
5 6 LOAD_CONST 2 (1.3)
9 STORE_FAST 1 (y)
6 12 LOAD_CONST 3 (1.1)
15 STORE_FAST 2 (z)
7 18 LOAD_FAST 0 (x)
21 LOAD_FAST 1 (y)
24 DUP_TOP
25 ROT_THREE
26 COMPARE_OP 0 (<)
29 JUMP_IF_FALSE_OR_POP 41
32 LOAD_FAST 2 (z)
35 COMPARE_OP 0 (<)
38 JUMP_FORWARD 2 (to 43)
>> 41 ROT_TWO
42 POP_TOP
>> 43 POP_TOP
44 LOAD_CONST 0 (None)
47 RETURN_VALUE
## and_compare ##
10 0 LOAD_CONST 1 (1.2)
3 STORE_FAST 0 (x)
11 6 LOAD_CONST 2 (1.3)
9 STORE_FAST 1 (y)
12 12 LOAD_CONST 3 (1.1)
15 STORE_FAST 2 (z)
13 18 LOAD_FAST 0 (x)
21 LOAD_FAST 1 (y)
24 COMPARE_OP 0 (<)
27 JUMP_IF_FALSE_OR_POP 39
30 LOAD_FAST 1 (y)
33 LOAD_FAST 2 (z)
36 COMPARE_OP 0 (<)
>> 39 POP_TOP
40 LOAD_CONST 0 (None)
Parece que o x < y and y < z
comando tem menos disfarces do que x < y < z
. Devo considerar x < y and y < z
mais rápido do que x < y < z
?
Testado com Python 2.7.6 em uma CPU Intel (R) Xeon (E) E5640 a 2.67GHz.
y
não é apenas uma pesquisa variável, mas um processo mais caro, como uma chamada de função? Ou seja, 10 < max(range(100)) < 15
é mais rápido do que 10 < max(range(100)) and max(range(100)) < 15
porque max(range(100))
é chamado uma vez para as duas comparações.
timeit
testes, fiquei interessado nisso.