Почему x * x быстрее, чем x ** 2? [Дубликат]

Реализация b ^ p с бинарным возведением в степень

def power(b, p):
    """
    Calculates b^p
    Complexity O(log p)
    b -> double
    p -> integer
    res -> double
    """
    res = 1

    while p:
        if p & 0x1: res *= b
        b *= b
        p >>= 1

    return res

Выполнение этого в проверке экспоненциальности замедлит случаи, когда это не простая сила двух очень незначительных, поэтому не обязательно выигрыш. Однако в тех случаях, когда экспонента известна заранее (например, используется литерал 2), генерируемый байт-код может быть оптимизирован с простой оптимизацией глазок. Предположительно, это просто не считается достойным (это довольно конкретный случай).

Вот краткое доказательство концепции, которая делает такую ​​оптимизацию (можно использовать как декоратор). Примечание: вам понадобится модуль byteplay для его запуска.

import byteplay, timeit

def optimise(func):
    c = byteplay.Code.from_code(func.func_code)
    prev=None
    for i, (op, arg) in enumerate(c.code):
        if op == byteplay.BINARY_POWER:
            if c.code[i-1] == (byteplay.LOAD_CONST, 2):
                c.code[i-1] = (byteplay.DUP_TOP, None)
                c.code[i] = (byteplay.BINARY_MULTIPLY, None)
    func.func_code = c.to_code()
    return func

def square(x):
    return x**2

print "Unoptimised :", timeit.Timer('square(10)','from __main__ import square').timeit(10000000)
square = optimise(square)
print "Optimised   :", timeit.Timer('square(10)','from __main__ import square').timeit(10000000)

Что дает тайминги:

Unoptimised : 6.42024898529
Optimised   : 4.52667593956

[Edit] На самом деле, думая об этом немного больше, есть очень веская причина, почему этот оптимизатор не сделан. Нет никакой гарантии, что кто-то не создаст пользовательский класс, который переопределяет методы __mul__ и __pow__ и сделает что-то другое для каждого. Единственный способ сделать это безопасно, если вы можете гарантировать, что объект в верхней части стека имеет тот же результат, что и «x **2» и «x*x», но работа над этим намного сложнее. Например. в моем примере это невозможно, так как любой объект может быть передан квадратной функции.

Я подозреваю, что никто не ожидал, что это будет так важно. Обычно, если вы хотите делать серьезные вычисления, вы делаете их в Fortran или C или C ++ или что-то в этом роде (и, возможно, называете их с Python).

Рассмотрение всего как exp (n * log (x) ) хорошо работает в случаях, когда n не является интегральным или довольно большим, но относительно малоэффективен для малых целых чисел.

Проверить, действительно ли проверка стоит, зависит от ожидаемых экспонентов, насколько важно получить максимальную производительность здесь, а также стоимость дополнительной сложности. По-видимому, Гвидо и остальная часть банды Python решили, что чек не стоит делать.

Если вам нравится, вы можете написать свою собственную функцию повторного умножения.

Добавление чека также является расходами. Вы всегда этого хотите? Скомпилированный язык может сделать проверку для постоянного экспонента, чтобы узнать, является ли это относительно небольшим целым числом, потому что нет затрат времени исполнения, а просто затраты времени компиляции.

Это зависит от конкретной реализации, если этот тип не задан языком.

Python не знает, какое распределение экспонентов вам он собирается его кормить. Если это будет 99% нецелых значений, вы хотите, чтобы код каждый раз проверял целое число, делая выполнение еще медленнее?

как насчет x x x x x? это все еще быстрее, чем x ** 5?

, поскольку индексы int увеличиваются, причем полномочия могут быть быстрее, чем умножение. но число, в котором происходит фактический кроссовер, зависит от различных условий, поэтому, на мой взгляд, именно поэтому оптимизация не была выполнена (или не может быть выполнена) на уровне языка / библиотеки. Но пользователи могут по-прежнему оптимизировать некоторые специальные случаи:)