subplots - ¿Por qué es más lento llamar a float() en un número que al agregar 0.0 en Python?

suptitle

Question

¿Cuál es la razón por la que convertir un entero en un flotador es más lento que agregar 0.0 a ese int en Python?

import timeit
def add_simple():
for i in range(1000):
a = 1 + 0.0
def cast_simple():
for i in range(1000):
a = float(1)
def add_total():
total = 0
for i in range(1000):
total += 1 + 0.0
def cast_total():
total = 0
for i in range(1000):
total += float(1)
print "Add simple timing: %s" % timeit.timeit(add_simple, number=1)
print "Cast simple timing: %s" % timeit.timeit(cast_simple, number=1)
print "Add total timing: %s" % timeit.timeit(add_total, number=1)
print "Cast total timing: %s" % timeit.timeit(cast_total, number=1)

La salida de la cual es:

Añadir tiempo simple: 0.0001220703125

Tiempo de lanzamiento simple: 0.000469923019409

Agregue el tiempo total: 0.000164985656738

Tiempo total de lanzamiento: 0.00040078163147

Answer 1

En pocas palabras, no estás lanzando nada. Un tipo de conversión le dice al compilador que trate el valor en una variable como si tuviera un tipo diferente; Se utilizan los mismos bits subyacentes. El float(1) de Python float(1) , sin embargo, construye un nuevo objeto en la memoria distinto del argumento para float .

Cuando agrega 1 + 0.0 , esto simplemente llama (1).__add__(0.0) , y el método __add__ de la clase int incorporada sabe cómo tratar los objetos float . No es necesario construir objetos adicionales (aparte del valor de retorno).

Las versiones más nuevas de Python tienen un optimizador para que las expresiones constantes como 1 + 0.0 puedan reemplazarse en tiempo de compilación con 1.0 ; no es necesario ejecutar ninguna función en el tiempo de ejecución. Reemplace 1 + 0.0 con x = 1 (antes del bucle) y x + 0.0 para forzar que int.__add__ sea ​​llamado en tiempo de ejecución para observar la diferencia. Será más lento que 1 + 0.0 , pero aún más rápido que float(1) .

Answer 2

La adición se puede hacer en C. Hacer la conversión hace que se llame a una función y luego se active la función C lib. Hay sobrecarga para esa llamada de función.

Answer 3

Si está utilizando Python 3 o una versión reciente de Python 2 (2.5 o superior), se realiza un plegado constante en el tiempo de generación del código de bytes. Esto significa que 1 + 0.0 se reemplaza con 1.0 antes de que se ejecute el código.

Answer 4

Si nos fijamos en el bytecode para add_simple :

>>> dis.dis(add_simple)
2 0 SETUP_LOOP 26 (to 29)
3 LOAD_GLOBAL 0 (range)
6 LOAD_CONST 1 (1000)
9 CALL_FUNCTION 1
12 GET_ITER
>> 13 FOR_ITER 12 (to 28)
16 STORE_FAST 0 (i)
3 19 LOAD_CONST 4 (1.0)
22 STORE_FAST 1 (a)
25 JUMP_ABSOLUTE 13
>> 28 POP_BLOCK
>> 29 LOAD_CONST 0 (None)
32 RETURN_VALUE

Verás que 0.0 no es en realidad en ningún lugar allí. Simplemente carga la constante 1.0 y la almacena en a. Python calculó el resultado en tiempo de compilación, por lo que no está sincronizando la suma.

Si usa una variable para 1 , entonces el optimizador de mirilla primitivo de Python no puede hacer la adición en tiempo de compilación, agregar 0.0 aún tiene una ventaja:

>>> timeit.timeit(''float(a)'', ''a=1'')
0.22538208961486816
>>> timeit.timeit(''a+0.0'', ''a=1'')
0.13347005844116211

Llamar a float requiere dos búsquedas de dict para determinar qué es float , uno en el espacio de nombres global del módulo y otro en los incorporados. También tiene una sobrecarga de llamadas a la función Python, que es más costosa que una llamada a la función C.

Agregar 0.0 solo requiere indexar en los co_consts del objeto de código de la co_consts para cargar la constante 0.0 , y luego llamar a las funciones nb_add nivel nb_add de los tipos int y float para realizar la suma. Esta es una menor cantidad de gastos generales en general.

Answer 5

Si usa el módulo dis , puede comenzar a ver por qué:

In [11]: dis.dis(add_simple)
2 0 SETUP_LOOP 26 (to 29)
3 LOAD_GLOBAL 0 (range)
6 LOAD_CONST 1 (1000)
9 CALL_FUNCTION 1 (1 positional, 0 keyword pair)
12 GET_ITER
>> 13 FOR_ITER 12 (to 28)
16 STORE_FAST 0 (i)
3 19 LOAD_CONST 4 (1.0)
22 STORE_FAST 1 (a)
25 JUMP_ABSOLUTE 13
>> 28 POP_BLOCK
>> 29 LOAD_CONST 0 (None)
32 RETURN_VALUE
In [12]: dis.dis(cast_simple)
2 0 SETUP_LOOP 32 (to 35)
3 LOAD_GLOBAL 0 (range)
6 LOAD_CONST 1 (1000)
9 CALL_FUNCTION 1 (1 positional, 0 keyword pair)
12 GET_ITER
>> 13 FOR_ITER 18 (to 34)
16 STORE_FAST 0 (i)
3 19 LOAD_GLOBAL 1 (float)
22 LOAD_CONST 2 (1)
25 CALL_FUNCTION 1 (1 positional, 0 keyword pair)
28 STORE_FAST 1 (a)
31 JUMP_ABSOLUTE 13
>> 34 POP_BLOCK
>> 35 LOAD_CONST 0 (None)
38 RETURN_VALUE

Tenga en cuenta el CALL_FUNCTION

Las llamadas a funciones en Python son (relativamente) lentas. Como son búsquedas Porque el casting para float requiere una llamada de función, por eso es más lento.