Что быстрее в Python: x **. 5 или math.sqrt (x)?

Question

Мне давно интересно. Как говорится в названии, что быстрее, фактическая функция или просто повышение до половины мощности?

UPDATE

Это не вопрос преждевременной оптимизации. Это просто вопрос о том, как на самом деле работает базовый код. Какова теория того, как работает код Python?

Я послал Гвидо ван Россуму электронное письмо, потому что я действительно хотел знать различия в этих методах.

Мой электронный адрес:

Существует как минимум 3 способа сделать квадратный корень в Python: math.sqrt, оператор ** и pow (x, .5). Мне просто любопытно, что касается различий в реализация каждого из них. Когда дело доходит до эффективности, которая лучше?

Его ответ:

Pow и ** эквивалентны; math.sqrt не работает для комплексных чисел, и ссылки на функцию C sqrt (). Что касается того, кто быстрее я понятия не имею ...

Answer 1

Согласно комментариям, я обновил код:

import time
import math

def timeit1():
    s = time.time()
    for i in xrange(750000):
        z=i**.5
    print "Took %f seconds" % (time.time() - s)

def timeit2(arg=math.sqrt):
    s = time.time()
    for i in xrange(750000):
        z=arg(i)
    print "Took %f seconds" % (time.time() - s)

timeit1()
timeit2()

Теперь функция math.sqrt находится непосредственно в локальном аргументе, то есть имеет самый быстрый поиск.

ОБНОВЛЕНИЕ: Кажется, здесь важна версия Python. Раньше я думал, что timeit1 будет быстрее, так как, когда python анализирует «i **. 5», он синтаксически знает, какой метод вызывать (__pow__ или какой-либо вариант), поэтому он не должен проходить издержки поиска, которые делает вариант math.sqrt. Но я могу ошибаться:

Python 2.5: 0.191000 против 0.224000

Python 2.6: 0.195000 против 0.139000

Также, похоже, психо справляется с math.sqrt лучше:

Python 2.5 + Psyco 2.0: 0.109000 против 0.043000

Python 2.6 + Psyco 2.0: 0.128000 против 0.067000

---

| Interpreter    |  x**.5, |   sqrt, | sqrt faster, % |
|                | seconds | seconds |                |
|----------------+---------+---------+----------------|
| Python 3.2rc1+ |    0.32 |    0.27 |             19 |
| Python 3.1.2   |   0.136 |   0.088 |             55 |
| Python 3.0.1   |   0.155 |   0.102 |             52 |
| Python 2.7     |   0.132 |   0.079 |             67 |
| Python 2.6.6   |   0.121 |   0.075 |             61 |
| PyPy 1.4.1     |   0.083 |  0.0159 |            422 |
| Jython 2.5.1   |   0.132 |    0.22 |            -40 |
| Python 2.5.5   |   0.129 |   0.125 |              3 |
| Python 2.4.6   |   0.131 |   0.123 |              7 |
#+TBLFM: $4=100*($2-$3)/$3;%.0f

Таблица результатов, полученных на машине:

$ uname -vms
Linux #42-Ubuntu SMP Thu Dec 2 02:41:37 UTC 2010 x86_64
$ cat /proc/cpuinfo | grep 'model name' | head -1
model name      : Intel(R) Core(TM) i7 CPU         920  @ 2.67GHz

Воспроизвести результаты:

• получить источник: git clone git://gist.github.com/783011.git gist-783011
• установка tox: pip install tox
• запустить tox из каталога с файлом tox.ini.

Answer 2

• первое правило оптимизации: не делай этого
• второе правило: не делай этого , пока

Вот некоторые моменты времени (Python 2.5.2, Windows):

$ 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

Этот тест показывает, что x**.5 немного быстрее, чем sqrt(x).

Для Python 3.0 результат противоположен:

$ \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) всегда быстрее, чем x**.5 на другом компьютере (Ubuntu, Python 2.6 и 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

Answer 3

Сколько квадратных корней вы действительно исполняете? Вы пытаетесь написать движок трехмерной графики на Python? Если нет, то зачем идти с кодом, который является загадочным по сравнению с кодом, который легко читать? Разница во времени будет меньше, чем кто-либо мог заметить практически в любом приложении, которое я мог предвидеть. Я действительно не хочу задавать ваш вопрос, но кажется, что вы слишком далеко зашли с преждевременной оптимизацией.

Answer 4

В этих микро-бенчмарках math.sqrt будет медленнее из-за небольшого времени, необходимого для поиска sqrt в пространстве имен math. Вы можете немного улучшить его с помощью

 from math import sqrt

Несмотря на то, что, выполняя несколько изменений во времени, оно показывает небольшое (4-5%) преимущество в производительности для "x **. 5"

интересно, занимаюсь

 import math
 sqrt = math.sqrt

ускорило его еще больше, с разницей в скорости 1%, с очень небольшой статистической значимостью.

Я повторю Кибби и скажу, что это, вероятно, преждевременная оптимизация.

Answer 5

В Python 2.6 функция (float).__pow__() использует функцию C pow(), а функции math.sqrt() использует функцию C sqrt().

В компиляторе glibc реализация pow(x,y) довольно сложна и хорошо оптимизирована для различных исключительных случаев. Например, вызов C pow(x,0.5) просто вызывает функцию sqrt().

Разница в скорости использования .** или math.sqrt вызвана обертками, используемыми вокруг функций C, и скорость сильно зависит от флагов оптимизации / компилятора C, используемых в системе.

Edit:

Вот результаты алгоритма Клавдия на моей машине. Я получил разные результаты:

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

Answer 6

с использованием кода Клаудиу, на моей машине даже с "from math import sqrt" x **. 5 быстрее, но использование psyco.full () sqrt (x) становится намного быстрее, по крайней мере, на 200%

Answer 7

Кто-то прокомментировал «быстрый квадратный корень Ньютона-Рафсона» из Quake 3 ... Я реализовал его с помощью ctypes, но он очень медленный по сравнению с нативными версиями. Я собираюсь попробовать несколько оптимизаций и альтернативных реализаций.

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

Вот еще один метод, использующий struct, который работает примерно в 3,6 раза быстрее, чем версия ctypes, но все еще на 1/10 скорости 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

Answer 8

Для чего это стоит (см. Ответ Джима). На моей машине работает python 2.5:

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

Answer 9

Скорее всего math.sqrt (x), потому что он оптимизирован для квадратного корня.

Тесты предоставят вам ответ, который вы ищете.

Answer 10

Результаты Клавдия отличаются от моих. Я использую Python 2.6 на Ubuntu на старой машине P4 2.4Ghz ... Вот мои результаты:

>>> 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

sqrt для меня постоянно быстрее ... Даже Codepad.org СЕЙЧАС, похоже, согласен с тем, что sqrt в локальном контексте быстрее (http://codepad.org/6trzcM3j). Кажется, Codepad работает на Python 2.5 в настоящее время. Возможно, они использовали 2.4 или старше, когда Клаудиу впервые ответил?

На самом деле, даже используя math.sqrt (i) вместо arg (i), я получаю лучшие времена для sqrt. В этом случае timeit2 () заняло от 0,53 до 0,55 секунд на моей машине, что все еще лучше, чем цифры 0,56-0,60 из timeit1.

Я бы сказал, что в современном Python используйте math.sqrt и определенно перенесите его в локальный контекст, либо с помощью somevar = math.sqrt, либо с помощью команды math import sqrt.