O que é mais rápido em Python: x**.5 ou matemática.sqrt (x)?

• primeira regra de optimização: não o faças
• segunda regra: não o faças , ainda

$ python -mtimeit -s"from math import sqrt; x = 123" "x**.5"
1000000 loops, best of 3: 0.445 usec per loop

$ python -mtimeit -s"from math import sqrt; x = 123" "sqrt(x)"
1000000 loops, best of 3: 0.574 usec per loop

$ python -mtimeit -s"import math; x = 123" "math.sqrt(x)"
1000000 loops, best of 3: 0.727 usec per loop

Este teste mostra que x**.5 é ligeiramente mais rápido do que sqrt(x).

Para o Python 3.0 o resultado é o oposto:

$ \Python30\python -mtimeit -s"from math import sqrt; x = 123" "x**.5"
1000000 loops, best of 3: 0.803 usec per loop

$ \Python30\python -mtimeit -s"from math import sqrt; x = 123" "sqrt(x)"
1000000 loops, best of 3: 0.695 usec per loop

$ \Python30\python -mtimeit -s"import math; x = 123" "math.sqrt(x)"
1000000 loops, best of 3: 0.761 usec per loop

math.sqrt(x) é sempre mais rápido do que x**.5 noutra máquina (Ubuntu, Python 2.6 e 3.1):

$ python -mtimeit -s"from math import sqrt; x = 123" "x**.5"
10000000 loops, best of 3: 0.173 usec per loop
$ python -mtimeit -s"from math import sqrt; x = 123" "sqrt(x)"
10000000 loops, best of 3: 0.115 usec per loop
$ python -mtimeit -s"import math; x = 123" "math.sqrt(x)"
10000000 loops, best of 3: 0.158 usec per loop
$ python3.1 -mtimeit -s"from math import sqrt; x = 123" "x**.5"
10000000 loops, best of 3: 0.194 usec per loop
$ python3.1 -mtimeit -s"from math import sqrt; x = 123" "sqrt(x)"
10000000 loops, best of 3: 0.123 usec per loop
$ python3.1 -mtimeit -s"import math; x = 123" "math.sqrt(x)"
10000000 loops, best of 3: 0.157 usec per loop

Nestes micro-benchmarks, matemática.o sqrt será mais lento, devido ao pouco tempo que leva para procurar o sqrt no espaço de nomes de matemática. Você pode melhorá-lo ligeiramente com

 from math import sqrt

Mesmo assim, executando algumas variações através do tempo, mostrar uma pequena (4-5%) vantagem de desempenho para "x**.5"

 import math
 sqrt = math.sqrt

Acelerou ainda mais, para uma diferença de 1% na velocidade, com muito pouco significado estatístico.

No python 2.6 a função (float).__pow__() usa a função C pow() e as funções math.sqrt() usam a função C sqrt().

No compilador glibc, a implementação de pow(x,y) é bastante complexa e está bem optimizada para vários casos excepcionais. Por exemplo, chamar C pow(x,0.5) simplesmente chama a função sqrt().

A diferença na velocidade de utilização de .** ou math.sqrt é causada pelas embalagens usadas em torno das funções C e a velocidade depende fortemente das opções de optimização/compilador C usado no sistema.

Editar:

zoltan@host:~$ python2.4 p.py 
Took 0.173994 seconds
Took 0.158991 seconds
zoltan@host:~$ python2.5 p.py 
Took 0.182321 seconds
Took 0.155394 seconds
zoltan@host:~$ python2.6 p.py 
Took 0.166766 seconds
Took 0.097018 seconds

PS C:\> python -m timeit -n 100000 10000**.5
100000 loops, best of 3: 0.0543 usec per loop
PS C:\> python -m timeit -n 100000 -s "import math" math.sqrt(10000)
100000 loops, best of 3: 0.162 usec per loop
PS C:\> python -m timeit -n 100000 -s "from math import sqrt" sqrt(10000)
100000 loops, best of 3: 0.0541 usec per loop

from ctypes import c_float, c_long, byref, POINTER, cast

def sqrt(num):
 xhalf = 0.5*num
 x = c_float(num)
 i = cast(byref(x), POINTER(c_long)).contents.value
 i = c_long(0x5f375a86 - (i>>1))
 x = cast(byref(i), POINTER(c_float)).contents.value

 x = x*(1.5-xhalf*x*x)
 x = x*(1.5-xhalf*x*x)
 return x * num

Aqui está outro método usando struct, sai cerca de 3,6 x mais rápido do que a versão ctypes, mas ainda 1/10 a velocidade de C.

from struct import pack, unpack

def sqrt_struct(num):
 xhalf = 0.5*num
 i = unpack('L', pack('f', 28.0))[0]
 i = 0x5f375a86 - (i>>1)
 x = unpack('f', pack('L', i))[0]

 x = x*(1.5-xhalf*x*x)
 x = x*(1.5-xhalf*x*x)
 return x * num

>>> timeit1()
Took 0.564911 seconds
>>> timeit2()
Took 0.403087 seconds
>>> timeit1()
Took 0.604713 seconds
>>> timeit2()
Took 0.387749 seconds
>>> timeit1()
Took 0.587829 seconds
>>> timeit2()
Took 0.379381 seconds

É melhor referenciar a raiz quadrada rápida de Newton-Raphson também. Não deve ser preciso muito para converter ao Python.

O problema SQRMINSUM que resolvi recentemente requer a computação de raiz quadrada repetidamente num conjunto de dados grande. As duas mais antigas submissões na minha história , antes de eu ter feito outras otimizações, diferem apenas por substituir **0.5 por sqrt(), reduzindo assim o tempo de execução de 3,74 s para 0,51 s em PyPy. Isso é quase o dobro da já massiva melhoria de 400% que Claudiu mediu.

1. Vá para math.py
2. Encontre a função "sqrt"
3. entendido. it
4. colar a função no seu programa como o localizador sqrt.
Tempo.