Как найти корень в питоне без sqrt

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

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() здесь

Квадратный корень из числа — это значение, которое при умножении само на себя дает исходное число. Каждое положительное число имеет два квадратных корня (то же значение с положительным и отрицательным знаками). Ниже приводится запись квадратного корня:
√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.

In this article, we will show you how to perform square root without using a math module in python. Below are the various methods to accomplish this task:

• Using exponential operator **
• Using Mathematical Logic

Using exponential operator **

Without using the math module, the simplest approach to find the square root of a number in Python is to use the built-in exponential operator **(It is an exponent operator because it calculates the power of the first operand to the power of the second operand).

Algorithm (Steps)

Following are the Algorithm/steps to be followed to perform the desired task −

• Create a variable to store the input number.

• Use the exponential operator** to get the square root of a number.

• Print the square root of an input number.

Example

The following program returns the square root of the input number without using math module and using ** operator −

inputNumber = 25


squareRoot = inputNumber**(1/2)


print("The square root of", inputNumber, "=", squareRoot)

Output

On executing, the above program will generate the following output −

('The square root of', 25, '=', 1)

In this method, we took a number and calculated its square root with the ** operator, passing the exponent value as (1/2) or 0.5 to it, and then printed it.

Using Mathematical Logic

This method is similar to binary search.

Algorithm (Steps)

Following are the Algorithm/steps to be followed to perform the desired task −

• Create a variable to store the input number.

• Initialize the minimum value as 0.

• Initialize maximum value with input number.

• Use the for loop, to repeat the loop 10 times.

• Get the middle value of both the minimum and maximum numbers by adding min and max values and dividing by 2(Getting the average of the minimum and maximum values).

• Calculate the square of the middle value using the ** operator and store it in a variable.

• Use the if conditional statement to check whether the square value of the middle value is equal to the input number and if it is true then break the code using the break statement(The break statement in Python terminates the current loop and resumes execution at the next statement, just like the traditional break found in C).

• Else check whether the square value of the middle value is greater than the input number and if it is true then set the maximum value as the middle value.

• Else if the square value of the middle value is less than the number take the minimum value as the middle value.

• Print the middle value which is the resultant square root of an input number.

Example

The following program returns the square root of the input number without using math module and using mathematical logic −

number = 9


minimum = 0


maximum =number


for i in range(10):
   
   middle =(minimum+maximum)/2
   
   squareValue=middle**2
   
   if squareValue ==number:
      
      break
   
     
   
   maximum=middle
  
   
   
   minimum=middle


print("The resultant square root of", number, "=", middle)




  


                       
  

Output

On executing, the above program will generate the following output −

('The resultant square root of', 9, '=', 4)

Conclusion

In this article, we learned two different methods for calculating the square root of a given number without using the math module. We also learned how to calculate the square or square root using the exponential operator(**). We also computed the square using a mathematical logic method similar to the binary search.

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

Выход:

Перейти к контенту

num = input("Please enter a number:n")

sqrt = float(num) ** 0.5

print(f'{num} square root is {sqrt}')

Please enter a number:
4.344
4.344 square root is 2.0842264752180846

Please enter a number:
10
10 square root is 3.1622776601683795

import math

num = 10
num_sqrt = math.sqrt(num)

print(f'{num} square root is {num_sqrt}')

>>> import math
>>> 
>>> math.pow(10, 0.5)
3.1622776601683795
>>> 

import cmath

c = 1 + 2j

c_sqrt = cmath.sqrt(c)

print(f'{c} square root is {c_sqrt}')

(1+2j) square root is (1.272019649514069+0.7861513777574233j)