Как написать квадратный корень python

Квадратный корень из числа — это значение, которое при умножении само на себя дает исходное число. Каждое положительное число имеет два квадратных корня (то же значение с положительным и отрицательным знаками). Ниже приводится запись квадратного корня:
√25 = ±5

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

Математическое представление квадрата числа

Все мы в детстве узнали, что, когда число умножается само на себя, мы получаем его квадрат. Также квадрат числа можно представить как многократное умножение этого числа. Попробуем разобраться в этом на примере.

Предположим, мы хотим получить квадрат 5. Если мы умножим число (в данном случае 5) на 5, мы получим квадрат этого числа. Для обозначения квадрата числа используется следующая запись:
5² = 25

При программировании на Python довольно часто возникает необходимость использовать функцию извлечения квадратного корня. Есть несколько способов найти квадратный корень числа в Python.

1. Используя оператор возведения в степень

num = 25
sqrt = num ** (0.5)
print("Квадратный корень из числа "+str(num)+" это "+str(sqrt))

Вывод:

Квадратный корень из числа 25 это 5.0

Объяснение: Мы можем использовать оператор «**» в Python, чтобы получить квадратный корень. Любое число, возведенное в степень 0.5, дает нам квадратный корень из этого числа.

2. Использование math.sqrt()

Квадратный корень из числа можно получить с помощью функции sqrt() из модуля math, как показано ниже. Далее мы увидим три сценария, в которых передадим положительный, нулевой и отрицательный числовые аргументы в sqrt().

a. Использование положительного числа в качестве аргумента.

import math
num = 25
sqrt = math.sqrt(num)
print("Квадратный корень из числа " + str(num) + " это " + str(sqrt))

Вывод: Квадратный корень из числа 25 это 5.0.

b. Использование ноля в качестве аргумента.

import math
num = 0
sqrt = math.sqrt(num)
print("Квадратный корень из числа " + str(num) + " это " + str(sqrt))

import math
num = -25
sqrt = math.sqrt(num)
print("Квадратный корень из числа " + str(num) + " это " + str(sqrt))

Вывод:

Traceback (most recent call last):
  File "C:wb.py", line 3, in 
    sqrt = math.sqrt(num)
ValueError: math domain error

Объяснение: Когда мы передаем отрицательное число в качестве аргумента, мы получаем следующую ошибку «math domain error». Из чего следует, что аргумент должен быть больше 0. Итак, чтобы решить эту проблему, мы должны использовать функцию sqrt() из модуля cmath.

3. Использование cmath.sqrt()

Ниже приведены примеры применения cmath.sqrt().

а. Использование отрицательного числа в качестве аргумента.

import cmath
num = -25
sqrt = cmath.sqrt(num)
print("Квадратный корень из числа " + str(num) + " это " + str(sqrt))

Вывод: Квадратный корень из числа -25 это 5j.

Объяснение: Для отрицательных чисел мы должны использовать функцию sqrt() модуля cmath, которая занимается математическими вычислениями над комплексными числами.

b. Использование комплексного числа в качестве аргумента.

import cmath
num = 4 + 9j
sqrt = cmath.sqrt(num)
print("Квадратный корень из числа " + str(num) + " это " + str(sqrt))

Вывод: Квадратный корень из числа (4+9j) это (2.6314309606938298+1.7100961671491028j).

Объяснение: Для нахождения квадратного корня из комплексного числа мы также можем использовать функцию cmath.sqrt().

4. Использование np.sqrt()

import numpy as np
num = -25
sqrt = np.sqrt(num)
print("Квадратный корень из числа " + str(num) + " это " + str(sqrt))

Вывод:

...
RuntimeWarning: invalid value encountered in sqrt
Квадратный корень из числа -25 это nan

5. Использование scipy.sqrt()

import scipy as sc
num = 25
sqrt = sc.sqrt(num)
print("Квадратный корень из числа " + str(num) + " это " + str(sqrt))

Вывод: Квадратный корень из числа 25 это 5.0.

Объяснение: Как и функция sqrt() модуля numpy, в scipy квадратный корень из положительных, нулевых и комплексных чисел может быть успешно вычислен, но для отрицательных возвращается nan с RunTimeWarning.

6. Использование sympy.sqrt()

import sympy as smp
num = 25
sqrt = smp.sqrt(num)
print("Квадратный корень из числа "+str(num)+" это "+str(sqrt))

Заключение

Наконец, мы подошли к завершению этой статьи. В начале мы кратко затронули использование квадратного корня в математике. Затем мы обсудили принципы внутреннего устройства функции извлечения квадратного корня и ее возможную реализацию. В завершении мы рассмотрели различные методы применения этой функции в Python.

В Python есть предопределенная функция sqrt(), которая возвращает квадратный корень числа. Она определяет квадратный корень из значения, которое умножается на само себя и дает число. Функция sqrt() не используется напрямую для нахождения квадратного корня из заданного числа, поэтому нам нужно использовать математический модуль для вызова функции sqrt() в Python.

Например, квадратный корень из 144 равен 12.

Использование метода math.sqrt()

Функция sqrt() – это встроенная функция, которая возвращает квадратный корень из любого числа. Ниже приведены шаги, чтобы найти квадратный корень из числа.

1. Запустите программу.
2. Определите любое число, квадратный корень которого нужно найти.
3. Вызовите функцию sqrt() и передайте значение, которое вы определили на шаге 2, сохраните результат в переменной.
4. Выведите квадратный корень.
5. Завершите программу.

Давайте напишем программу на Python.

SqrRoot.py

 
import math # import math module 
N = 25 # define the value to the variable N  
result = math.sqrt(N) # use math.sqrt() function and pass the variable. 
print(" Square root of 25 is :", result) # prints the square root of a given number  
M = 625 # define the value 
result = math.sqrt(M) # use math.sqrt() function and pass the variable 
print(" Square root of 625 is :", result) # prints the square root of a given number  
 
P = 144 # define the value 
result = math.sqrt(P) # use math.sqrt() function and pass the variable 
print(" Square root of 144 is :", result) # prints the square root of a given number  
 
S = 64 # define the value 
result = math.sqrt(S) # use math.sqrt() function and pass the variable 
print(" Square root of 64 is :", result) # prints the square root of a given number 

Выход:

Давайте создадим программу на Python, которая находит квадратный корень десятичных чисел.

SqrRoot.py

 
import math 
print(" The Square root of 4.5 is", math.sqrt(4.5)) # Pass the decimal number 
print(" The Square root of 627 is", math.sqrt(627)) # Pass the decimal number 
print(" The Square root of 6.25 is", math.sqrt(6.25)) # Pass the decimal number 
 
print(" The Square root of 0 is", math.sqrt(0)) # Pass number as 0 

Выход:

В следующей программе мы прочитали число от пользователя и нашли квадратный корень.

SqRoot_Usr.py

 
import math # import math module 
a = int(input("Enter a number to get the Square root")) # take an input  
res = math.sqrt(a) # Use math.sqrt() function and pass the variable a. 
print("Square root of the number is", res) # print the Square Root 

Выход:

Использование функции math.pow()

Pow() – это встроенная функция, которая используется в Python для возврата степени числа. У него два параметра. Первый параметр определяет число, а второй параметр определяет увеличение мощности до этого числа.

Pow_Sqrt.py

 
import math # import the math module 
num = float(input("Enter the number :")) # take an input 
SquareRoot = math.pow(num, 0.5) # Use the math.pow() function and pass the value and 0.5(which is equal to √) as an parameters 
print(" The Square Root of the given number {0} = {1}" .format(num, SquareRoot)) # print the Square Root. 

Выход:

Использование оператора **

Мы также можем использовать оператор экспоненты, чтобы найти квадратный корень из числа. Оператор может применяться между двумя операндами. Например, x ** y. Это означает, что левый операнд возведен в степень правого.

Ниже приведены шаги, чтобы найти квадратный корень из числа.

• Шаг 1. Определите функцию и передайте значение в качестве аргумента.
• Шаг 2. Если заданное число меньше 0 или отрицательное, оно ничего не возвращает.
• Шаг 3. Используйте экспоненциальный знак **, чтобы найти степень числа.
• Шаг 4. Возьмите числовое значение у пользователя.
• Шаг 5. Вызовите функцию и сохраните ее вывод в переменной.
• Шаг 6. Отобразите квадратный корень числа в Python.
• Шаг 7. Выход из программы.

Давайте реализуем вышеуказанные шаги.

SqrtFun.py

 
import math # import the math package or module 
def sqrt_fun(num): # define the sqrt_fun() and pass the num as an argument 
    if num < 0:  # if num is less than 0 or negative, it returns nothing 
        return 
    else: 
        return num ** 0.5 # Use the exponent operator  
num = int(input(" Enter a numeric value: ") ) # take an input from the user 
 
res = sqrt_fun(num) # call the sqrt_fun() to find the result 
print("  Square Root of the {0} = {1}".format(num, res)) # print the Square Root of the variable 

Выход:

Как мы видим в приведенном выше примере, сначала мы берем ввод(число) от пользователя, а затем используем оператор степени **, чтобы узнать степень числа. Где 0,5 равно √(символ корня), чтобы увеличить степень данного числа.

Давайте создадим программу Python, которая находит квадратный корень из указанного диапазона, в следующей программе вычисление из всех чисел от 0 до 50.

Sqrloop.py

 
import math 
for i in range(50): 
    print("Square root of a number {0} = {1}".format(i,math.sqrt(i))) 

Выход:

В этой статье мы рассмотрим, как извлечь корень в Python, а также какой модуль и функция для этого используется. Но давайте обо всем по порядку.

Если мы знаем только общую площадь квадрата и хотим узнать размер одной его стороны либо же собираемся рассчитать расстояние между 2-мя точками в декартовых координатах, нам потребуется квадратный корень. Это не проблема, если речь идет о математике. Но что делать, когда речь идет о языке программирования? К нашему счастью разработчики Python предусмотрели для решения вышеописанной задачи специальную функцию. Но прежде чем продолжить, давайте немного вспомним теорию.

Квадратный корень — что это?

Квадратным корнем, полученным из числа «A», называют число «B», которое при возведении во 2-ю степень даст в итоге то самое изначальное число «A».

B2 = A

Непосредственную операцию, позволяющую найти значение «B», называют извлечением корня из «A». Математики применяют для обозначения этой операции специальный знак (его еще называют знаком радикала):

B = √A

Когда речь идет о корне в «Питоне», ситуация обстоит иначе, причем в обоих случаях. К примеру, само возведение числа в степень записывают посредством оператора «**«:

X = 2

Y = X ** 2

print(Y)

Ответ в консоли «Пайтона» будет равняться четырем.

Касаемо квадратного корня, то он в Python представлен функцией sqrt(). Однако она существует не сама по себе, а в рамках соответствующего математического модуля math. Таким образом, перед началом работы этот модуль надо будет импортировать, но это абсолютно не сложно сделать на практике:

import math

Идем дальше. Наша функция sqrt() принимает лишь один параметр – значение, из которого нам надо извлечь √. Давайте напишем простенький код и задействуем float в качестве типа данных возвращаемого значения.

import math

import random

# попробуем функцию sqrt() на практике

# найдем корень случайного числа с последующим выводом его на экран

rand_num = random.randint(5, 55)

sqrt_rand_num = math.sqrt(rand_num)

print('Наше случайное число = ', rand_num)

print('Искомое значение корня = ', sqrt_rand_num)

Вы можете попробовать работу этого кода у себя на компьютере или на любом онлайн-компиляторе. Вот, к примеру, компилятор для Python 3.

Результат может быть таким:

Или таким:

Так как мы используем модуль random, результат будет различаться при каждом выполнении кода.

Но никто не мешает сделать все намного проще:

print (math.sqrt(64))

Ответ очевиден:

Положительные числа

Функция sqrt() предназначена для работы с положительными значениями. Если число больше либо равно нулю, то неважно, какой тип данных у него, ведь извлечение корня возможно как из целых, так и из вещественных чисел.

Из целых:

import math

print(math.sqrt(81))

> 9.0

Из вещественных:

print(math.sqrt(81.5))

> 9.027735042633894

Сомневаетесь в корректности итоговых результатов предыдущего примера? Просто выполните обратное возведение в степень:

print(9.027735042633894 ** 2)

> 81.5

Также не забывайте, что сделать это можно и посредством специальной функции pow:

print(pow(9.027735042633894, 2))

> 81.5

Отрицательные значения и ноль

Функция sqrt в «Питоне» — вещь полезная и знать ее нужно, однако она не принимает отрицательного числа — лишь положительные (целые и вещественные), а также ноль.

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

Учитывайте вышесказанное, если пытаетесь извлекать корни в Python посредством этой функции. Передав отрицательное значение, вы получите error:

import math

print(math.sqrt(-1))

А вот если говорить про ноль, то ошибки не будет, так как код отработает корректно. Однако результат тут очевиден, поэтому практическая ценность данной возможности весьма условна:

import math

print(math.sqrt(0))

> 0.0

Хотите знать о «Питоне» намного больше? Добро пожаловать на специализированный курс в «Отус»!

По материалам:

• http://python-teach.ru/python-dlya-nachinayushhih/vychislenie-kvadratnogo-kornya-chisla-v-python/.

Если коротко, то разница в реализации. И очевидно в скорости выполнения, входных и выходных параметрах. А вообще-то интересно заглянуть, что там во встроенных функциях.

pow(x, n)

 @overload
    def pow(base: int, exp: int, mod: None = ...) -> Any: ...  # returns int or float depending on whether exp is non-negative
    @overload
    def pow(base: int, exp: int, mod: int) -> int: ...
    @overload
    def pow(base: float, exp: float, mod: None = ...) -> float: ...
    @overload
    def pow(base: _SupportsPow2[_E, _T_co], exp: _E) -> _T_co: ...
    @overload
    def pow(base: _SupportsPow3[_E, _M, _T_co], exp: _E, mod: _M) -> _T_co: ...

math.sqrt()

def sqrt(__x: SupportsFloat) -> float: ...

math.pow()

def pow(__x: SupportsFloat, __y: SupportsFloat) -> float: ...

И немного документации math.pow(). Здесь хотелось бы перевести одно заключение из документации:

В отличие от встроенного оператора **, math.pow () преобразует оба своих аргумента в тип float. Используйте ** или встроенную функцию pow () для вычисления точных целочисленных степеней.

А так же можно пользоваться и cmath модулем, для комплексных чисел и не только. Он возращает комплексное число, но при получении квадратного корня из 4, например, мнимая часть будет равняться 0j.

def sqrt(__z: _C) -> complex: ...

Можно сделать вывод, что под каждую конкретную задачу может быть подобран оптимальная функция для вычислений. Думаю, что тема достаточно обширна и можно исследовать, например, скорости для вычисления в том или ином случае.

Все вышеописанное для версии python 3.х.x.

upd

И все таки я решил посмотреть глубже. Не уверен в верности моей попытки, но все же (скажите, где я ошибся). Я решил исследовать две built-in функции: pow() и math.pow(). Найти их исходный код можно pow и math.pow.

Для pow() были найдены данные строки

/*[clinic input]
pow as builtin_pow
    base: object
    exp: object
    mod: object = None
Equivalent to base**exp with 2 arguments or base**exp % mod with 3 arguments
Some types, such as ints, are able to use a more efficient algorithm when
invoked using the three argument form.
[clinic start generated code]*/

static PyObject *
builtin_pow_impl(PyObject *module, PyObject *base, PyObject *exp,
                 PyObject *mod)
/*[clinic end generated code: output=3ca1538221bbf15f input=435dbd48a12efb23]*/
{
    return PyNumber_Power(base, exp, mod);
}

Что это может означать? В данной документации можно найти, как это работает. А конкретно в документации написано, что используется препроцессор для CPython и в данной конструкции «магическим образом преобразуются в переменные С с типом данных, которые нам нужны»(вольный перевод.). Функция PyNumber_Power() импортируется из DLL библиотеки (могу ошибаться, т.к. нашел только вызов в python3dll.c-файле, строка 409, EXPORT_FUNC(PyNumber_Power)). Вот в принципе и все.

Для math.pow() реализация немного интересней:

/*[clinic input]
math.pow
    x: double
    y: double
    /
Return x**y (x to the power of y).
[clinic start generated code]*/

static PyObject *
math_pow_impl(PyObject *module, double x, double y)
/*[clinic end generated code: output=fff93e65abccd6b0 input=c26f1f6075088bfd]*/
{
    double r;
    int odd_y;

    /* deal directly with IEEE specials, to cope with problems on various
       platforms whose semantics don't exactly match C99 */
    r = 0.; /* silence compiler warning */
    if (!Py_IS_FINITE(x) || !Py_IS_FINITE(y)) {
        errno = 0;
        if (Py_IS_NAN(x))
            r = y == 0. ? 1. : x; /* NaN**0 = 1 */
        else if (Py_IS_NAN(y))
            r = x == 1. ? 1. : y; /* 1**NaN = 1 */
        else if (Py_IS_INFINITY(x)) {
            odd_y = Py_IS_FINITE(y) && fmod(fabs(y), 2.0) == 1.0;
            if (y > 0.)
                r = odd_y ? x : fabs(x);
            else if (y == 0.)
                r = 1.;
            else /* y < 0. */
                r = odd_y ? copysign(0., x) : 0.;
        }
        else if (Py_IS_INFINITY(y)) {
            if (fabs(x) == 1.0)
                r = 1.;
            else if (y > 0. && fabs(x) > 1.0)
                r = y;
            else if (y < 0. && fabs(x) < 1.0) {
                r = -y; /* result is +inf */
            }
            else
                r = 0.;
        }
    }
    else {
        /* let libm handle finite**finite */
        errno = 0;
        r = pow(x, y);
        /* a NaN result should arise only from (-ve)**(finite
           non-integer); in this case we want to raise ValueError. */
        if (!Py_IS_FINITE(r)) {
            if (Py_IS_NAN(r)) {
                errno = EDOM;
            }
            /*
               an infinite result here arises either from:
               (A) (+/-0.)**negative (-> divide-by-zero)
               (B) overflow of x**y with x and y finite
            */
            else if (Py_IS_INFINITY(r)) {
                if (x == 0.)
                    errno = EDOM;
                else
                    errno = ERANGE;
            }
        }
    }

    if (errno && is_error(r))
        return NULL;
    else
        return PyFloat_FromDouble(r);
}

Можно увидеть не только использования Argument Clinic-препроцессора, но и обработку некоторых крайних значений (бесконечность ** бесконечность, например) и обработку ошибок.

Можно копать дальше, не уверен есть ли необходимость. Но инетересно же) можно так же увидеть еще одну интересную реализацию для long_pow() здесь

Вступление

Квадратный корень из числа – очень распространенная математическая функция, используемая во всех областях науки – физике, математике, информатике и т.д. Квадратные корни чисел и выражений очень часто встречаются в формулах во всех областях науки, и особенно в том, как мы представляем реальность – моделируя то, что мы можем наблюдать с помощью исчисления.

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

Вычисление квадратного корня в Python с помощью NumPy

NumPy – это библиотека научных вычислений, которая присутствовала во многих приложениях и вариантах использования. Естественно, в нем есть множество оболочек математических функций в качестве вспомогательных методов.

Если она еще не установлена, вы можете установить ее через pip:

$ pip install numpy

В терминах NumPy функция sqrt() вычисляет квадратный корень из числа и возвращает результат:

import numpy as np:
x = np.scrt(2)
print(x)

Это приводит к:

1.4142135623730951

Помимо использования одной переменной в качестве аргумента, sqrt() также может анализировать списки и возвращать список квадратных корней:

arr = [2, 3, 5, 7]
roots = np.sqrt(arr)
print(roots)

Это приводит к:

[1.41421356 1.73205081 2.23606798 2.64575131]

Функция sqrt(), однако, имеет ограничение – она не может вычислять квадратный корень из отрицательного числа, поскольку операция квадратного корня с действительными числами определена только для положительных чисел.

Попытка вставить -4 в функцию sqrt() приведет к исключению:

print(np.sqrt(-4))

Попытка вычислить квадратный корень из отрицательного числа приведет к появлению предупреждения и значению nan:

RuntimeWarning: invalid value encountered in sqrt nan

Вычисление квадратного корня из комплексного числа с помощью Numpy

К счастью, NumPy не ограничивается работой только с действительными числами – он также может работать с комплексными числами:

import numpy as np

complex_number = -1 + 1j
complex_array = [-2, 3, complex_number]

complex_root = np.sqrt(complex_number)
complex_array_roots = np.sqrt(complex_array)

print(f"Square root of '{complex_number}':n {complex_root}")
print(f"Square roots of '{complex_array}':n {complex_array_roots}")

Если в списке есть хотя бы одно комплексное число, все числа будут приведены и обработаны как сложные, поэтому можно добавить даже отрицательные целые числа:

Square root of '(-1+1j)':
 (0.45508986056222733+1.09868411346781j)
Square roots of '[-2, 3, (-1+1j)]':
 [0.        +1.41421356j 1.73205081+0.j         0.45508986+1.09868411j]

Модуль math в Python

Модуль math – это стандартный модуль, упакованный с Python. Он всегда доступен, но должен быть импортирован и предоставляет оболочки для некоторых общих функций, таких как квадратный корень, полномочия и т.д.:

import math
math.sqrt()

Функция sqrt() модуля math- это простая функция, которая возвращает квадратный корень из любого положительного числа:

print(math.sqrt(2))

Это приводит к:

1.4142135623730951

В отличие от функции sqrt() NumPy, она может работать только с одним элементом, поэтому, если вы хотите вычислить квадратный корень из всех элементов в списке, вам придется использовать цикл for или генератор списка:

import math

arr = [2, 3, 5, 7]
roots = []

for x in arr:
    roots.append(math.sqrt(x))

# OR
roots = [math.sqrt(x) for x in arr]

В обоих случаях список корней будет содержать:

[1.4142135623730951, 1.7320508075688772, 2.23606797749979, 2.6457513110645907]

math.pow()

Квадратный корень из числа также может быть вычислен путем возведения числа в степень ½:

√x = x^1/2

Так что на самом деле, нахождение квадратного корня из числа может быть выражено как увеличение числа до степени ½. math.pow() принимает два аргумента – основание и показатель степени, и увеличивает основание до степени экспоненты:

print(math.pow(2, 0.5))

Естественно, это приводит к:

1.4142135623730951

Оператор **

Оператор ** является двоичным оператором, что означает, что он работает с двумя значениями, как и обычное умножение с помощью *. Однако, поскольку это оператор, используемый для возведения в степень, мы повышаем его левый аргумент до степени его правого аргумента.

Этот подход может быть использован в той же форме, что и предыдущий:

print(2 ** 0.5)

И это также приводит к:

1.4142135623730951

Функция pow()

В Python есть еще один встроенный метод pow(), который не требует импорта математического модуля. Этот метод отличается от метода math.pow() внутренне.

math.pow() неявно преобразует элементы в двойные, в то время как pow() использует внутреннюю реализацию объекта, основанную на операторе **. Хотя это различие в реализации может оправдать использование того или иного в определенных контекстах, если вы просто вычисляете квадратный корень из числа, вы на самом деле не увидите разницы:

print(pow(2, 0.5))

Это приводит к:

1.4142135623730951

Контрольный показатель производительности

Итак, какой из них дает наилучшую производительность, и какой из них вы должны выбрать? Как обычно, нет одного явного победителя, и это зависит от использования методов. А именно, если вы работаете с постоянными числами, случайными числами или массивом случайных чисел в большем масштабе – эти методы будут работать по-другому.

Давайте проверим их все на постоянных числах, случайных числах и массивах случайных чисел:

import timeit

print("Time to execute 100k operations on constant number: n")
print("math.sqrt(): %ss" % timeit.timeit("math.sqrt(100)", setup="import math", number=100000))
print("math.pow(): %ss" % timeit.timeit("math.pow(100, 0.5)", setup="import math", number=100000))
print("pow(): %ss" % timeit.timeit("pow(100, 0.5)", number=100000))
print("np.sqrt(): %ss" % timeit.timeit("np.sqrt(100)", setup="import numpy as np", number=100000))
print("** operator: %ss" % timeit.timeit("100 ** 0.5", number=100000))

print("nTime to execute 100k operations on random number: n")
print("math.sqrt() %ss" % timeit.timeit("math.sqrt(random.random())", setup="import math; import random;", number=100000))
print("math.pow(): %ss" % timeit.timeit("math.pow(random.random(), 0.5)", setup="import math; import random", number=100000))
print("pow(): %ss" % timeit.timeit("pow(random.random(), 0.5)", setup="import random", number=100000))
print("np.sqrt(): %ss" % timeit.timeit("np.sqrt(random.random())", setup="import numpy as np; import random", number=100000))
print("** operator: %ss" % timeit.timeit("random.random() ** 0.5", setup="import random", number=100000))

print("nTime to execute 100k operations on list of random numbers: n")
print("math.sqrt() %ss" % timeit.timeit("[math.sqrt(x) for x in np.random.rand(100)]", setup="import math; import numpy as np;", number=100000))
print("math.pow(): %ss" % timeit.timeit("[math.pow(x, 0.5) for x in np.random.rand(100)]", setup="import math; import numpy as np;", number=100000))
print("pow(): %ss" % timeit.timeit("[pow(x, 0.5) for x in np.random.rand(100)]", setup="import numpy as np;", number=100000))
print("np.sqrt(): %ss" % timeit.timeit("np.sqrt(np.random.rand(100))", setup="import numpy as np; import numpy as np;", number=100000))
print("** operator: %ss" % timeit.timeit("np.random.rand(100) ** 0.5", setup="import numpy as np", number=100000))

Мы прошли все описанные выше методы через один и тот же тест – постоянное число (которое, вероятно, будет кэшировано для оптимизации), случайное число на каждой из 100 тыс. итераций и список из 100 случайных чисел.

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

Выполнение этого фрагмента кода приводит к:

Time to execute 100k operations on constant number: 

math.sqrt(): 0.014326499999999999s
math.pow(): 0.0165132s
pow(): 0.018766599999999994s
np.sqrt(): 0.10575379999999998s
** operator: 0.0006493000000000193s

Time to execute 100k operations on random number: 

math.sqrt() 0.019939999999999958s
math.pow(): 0.022284300000000035s
pow(): 0.0231711s
np.sqrt(): 0.09066460000000004s
** operator: 0.018928s

Time to execute 100k operations on list of random numbers: 

math.sqrt() 2.7786073s
math.pow(): 2.9986906s
pow(): 3.5157339999999992s 
np.sqrt(): 0.2291957s
** operator: 0.2376024000000001s

С постоянными числами – функции math.pow(), math.sqrt() и pow() значительно превосходят функцию Numpy sqrt(), поскольку они могут лучше использовать кэширование в процессоре на уровне языка.

Со случайными числами кэширование работает не так хорошо, и мы видим меньшие расхождения.

Со списками случайных чисел np.sqrt() значительно превосходит все три встроенных метода, и оператор ** работает в одной и той же области действия.

Подводя итоги:

• Для постоянных чисел оператор ** явно работает лучше всего на тестовой машине, выполняя в 16 раз быстрее, чем встроенные методы.
• Для случайных чисел np.sqrt() превосходит встроенные методы и оператор **, хотя в результатах нет существенных расхождений.
• Для случайных массивов функция np.sqrt() превосходит встроенные методы, но оператор ** очень близок.

В зависимости от конкретного ввода, с которым вы имеете дело, вы будете выбирать между этими функциями. Хотя может показаться, что все они будут работать хорошо, и хотя в большинстве случаев это не будет иметь большого значения, при работе с огромными наборами данных даже сокращение времени обработки на 10 % может помочь в долгосрочной перспективе.

В зависимости от обрабатываемых данных – протестируйте различные подходы на своем локальном компьютере.

Вывод

В этой короткой статье мы рассмотрели несколько способов вычисления квадратного корня из числа в Python.

Мы рассмотрели функции pow() и sqrt() математического модуля, а также встроенную функцию pow(), функцию Numpy sqrt() и оператор **. Наконец, мы провели сравнительный анализ методов для сравнения их производительности на различных типах входных данных – постоянных числах, случайных числах и списках случайных чисел.

Просмотры: 2 542

Под извлечением корня из какого-либо числа чаще всего подразумевают нахождение решение уравнения x в степени n = value, соответственно для квадратного корня, число n — это два, для кубического — 3. Чаще всего под результатом и числом подразумеваются вещественные числа.

В программировании нахождение корней используется очень часто. Разберемся, как и какими методами можно эффективно извлекать корни из числа. Вначале рассмотрим, какие способы есть в Python, и определим самый эффективный. Потом более подробно разберём, как можно найти не только квадратный корень из числа, но и кубический, и потом корень n степени.

Способы извлечения корня

В языке программирования Python 3 существует три способа извлечения корней:

• Использование функции sqrt из стандартной математической библиотеки math.
• Операция возведения в степень **
• Применение функции pow(x, n)

Чтобы воспользоваться первым способом, необходимо вначале импортировать sqrt из модуля math. Это делается с помощью ключевого слова import: from math import sqrt. При помощи этой функции можно извлекать только квадратный корень из числа. Приведем пример:

from math import sqrt
x = sqrt(4)
print(x)

2.0

Если же нам нужно вычислить в Python корень квадратный из суммы квадратов, то можно воспользоваться функцией hypot из модуля math. Берется сумма квадратов аргументов функции, из нее получается корень. Аргументов у функции два.

from math import hypot
x = hypot(4,3)
print(x)

5.0

Еще одним, чуть более универсальным методом, будет использование возведения в степень. Известно, что для того, чтобы взять корень n из числа, необходимо возвести его в степень 1/n. Соответственно, извлечение квадратного корня из числа 4 будет выглядеть так:

n = 2
x = 4**(1./n)
print(x)

2.0

Обратите внимание, что в Python 2 необходимо ставить точку после единицы, иначе произойдет целочисленное деление, и 1/n == 0, а не нужной нам дроби. В Python 3 можно не ставить точку.

Последний метод использует функцию pow(value, n). Эта функция в качестве аргумента value возьмет число, которое необходимо возвести в степень, а второй аргумент будет отвечать за степень числа. Как и в предыдущем методе, необходимо использовать дробь, для того, чтобы получить корень числа.

x = pow(4, 0.5)
print(x)

2.0

Какой метод быстрее?

Для того, чтобы определить какой же метод предпочтительнее использовать, напишем программу. Замерять время выполнения будем с помощью метода monotonic библиотеки time.

from time import monotonic
from math import sqrt
iterations = 1000000
start = monotonic()
for a in range(iterations):
    x = sqrt(4)
print("sqrt time: {:>.3f}".format(monotonic() - start) + " seconds")
start = monotonic()
for a in range(iterations):
    x = 4 ** 0.5
print("** time: {:>.3f}".format(monotonic() - start) + " seconds")
start = monotonic()
for a in range(iterations):
    x = pow(4, 0.5)
print("pow time: {:>.3f}".format(monotonic() - start) + " seconds")

sqrt time: 0.266 seconds
** time: 0.109 seconds
pow time: 0.453 seconds

Как видно, самое быстрое решение — использовать **. На втором месте метод sqrt, а pow — самый медленный. Правда, метод sqrt наиболее нагляден при вычислении в Python квадратных корней.

Таким образом, если критична скорость, то используем **. Если скорость не критична, а важна читаемость кода, то следует использовать sqrt.

Квадратный корень

Для извлечения квадратного корня самым наглядным способом, правда не самым быстрым, будет использование sqrt из модуля math.

from math import sqrt
x = sqrt (value)

Но можно использовать и трюки с возведением в степень 1/2, что тоже будет приводить к нужному результату.

x = value ** (0.5) или x = pow(value, 0.5).

Кубический корень

Для извлечения кубического корня в Python 3 метод sqrt не подойдет, поэтому воспользуйтесь возведением в степень 1/3:

x = value ** (1./3) или x=pow(value, 1/3).

Корень n-степени

Корень n-степени из числа в Python извлекается можно получить двумя способами с помощью возведения в степень 1.0/n:

• С помощью оператора **.
• Используя функцию pow.

Как было проверено выше, оператор ** быстрее. Поэтому его использовать более целесообразно. Приведем пример вычисления кубических корней в Python 3 с помощью этих двух методов:

n = 4.
x = 16.0 ** (1./n)
print(x)
x = pow(16.0, 1./n)
print(x)

2.0
2.0

Корень отрицательного числа

Рассмотрим, как поведут себя функции, если будем брать корень из отрицательного числа.

from math import sqrt
x = sqrt(-4)

File "main.py", line 2, in 
    x = sqrt(-4)
ValueError: math domain error

Как видим, функция sqrt выдаёт исключение.

Теперь посмотрим, что будет при использовании других методов.

x = -4 ** 0.5
print(x)
x = pow(-4, 0.5)
print(x)

-2.0
(1.2246467991473532e-16+2j)

Как видно из результата, оператор ** не выдает исключения и возвращает некорректный результат. Функция pow работает корректно. В результате получаем комплексное число 2j, что является верным.

Вывод

В Python существуют два универсальных способа для извлечения корня из числа. Это возведение в необходимую степень 1/n. Кроме того, можно воспользоваться функцией из математического модуля языка, если необходимо извлечь квадратный корень числа.

Все эти методы имеют свои преимущества и недостатки. Самый наглядный это sqrt, но подходит только для квадратный корней из числа. Остальные методы не такие элегантные, но легко могут извлечь корень нужной степени из числа. Кроме того оператор ** оказался наиболее быстрым при тестировании.

Необходимо также помнить про целочисленное деление, неправильное использование которого может приводить к ошибке в вычислении.