Python квадратный корень числа: Квадратный корень в Python 3 — Извлечение кубических и n-ой степени

Содержание

Квадратный корень в Python 3 — Извлечение кубических и n-ой степени

Под извлечением корня из какого-либо числа чаще всего подразумевают нахождение решение уравнения 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, но подходит только для квадратный корней из числа. Остальные методы не такие элегантные, но легко могут извлечь корень нужной степени из числа. Кроме того оператор ** оказался наиболее быстрым при тестировании.

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

Извлечение корня в Python OTUS

В этой статье мы рассмотрим, как извлечь корень в 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/.

Целочисленный квадратный корень в python

Похоже, вы могли бы проверить вот так:

if int(math.sqrt(n))**2 == n:
    print n, 'is a perfect square'

Обновление:

Как вы указали выше, это не удается для больших значений n . Для них следующее выглядит многообещающим, что является адаптацией примера кода C, написанного Мартином Гаем @ UKC, июнь 1985 года, для относительно простого на вид метода вычисления двоичного числа digit-by-digit, упомянутого в статье Википедии Методы вычисления квадратных корней :

from math import ceil, log

def isqrt(n):
    res = 0
    bit = 4**int(ceil(log(n, 4))) if n else 0  # smallest power of 4 >= the argument
    while bit:
        if n >= res + bit:
            n -= res + bit
            res = (res >> 1) + bit
        else:
            res >>= 1
        bit >>= 2
    return res

if __name__ == '__main__':
    from math import sqrt  # for comparison purposes

    for i in range(17)+[2**53, (10**100+1)**2]:
        is_perfect_sq = isqrt(i)**2 == i
        print '{:21,d}:  math.sqrt={:12,.7G}, isqrt={:10,d} {}'.format(
            i, sqrt(i), isqrt(i), '(perfect square)' if is_perfect_sq else '')

Выход:

                    0:  math.sqrt=           0, isqrt=         0 (perfect square)
                    1:  math.sqrt=           1, isqrt=         1 (perfect square)
                    2:  math.sqrt=    1.414214, isqrt=         1
                    3:  math.sqrt=    1.732051, isqrt=         1
                    4:  math.sqrt=           2, isqrt=         2 (perfect square)
                    5:  math.sqrt=    2.236068, isqrt=         2
                    6:  math.sqrt=     2.44949, isqrt=         2
                    7:  math.sqrt=    2.645751, isqrt=         2
                    8:  math.sqrt=    2.828427, isqrt=         2
                    9:  math.sqrt=           3, isqrt=         3 (perfect square)
                   10:  math.sqrt=    3.162278, isqrt=         3
                   11:  math.sqrt=    3.316625, isqrt=         3
                   12:  math.sqrt=    3.464102, isqrt=         3
                   13:  math.sqrt=    3.605551, isqrt=         3
                   14:  math.sqrt=    3.741657, isqrt=         3
                   15:  math.sqrt=    3.872983, isqrt=         3
                   16:  math.sqrt=           4, isqrt=         4 (perfect square)
9,007,199,254,740,992:  math.sqrt=9.490627E+07, isqrt=94,906,265
100,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,020,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,001:  math.sqrt=      1E+100, isqrt=10,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,001 (perfect square)

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



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

Есть ли более быстрый и простой способ найти квадратный корень?

python
Поделиться Источник kaki     15 июня 2010 в 16:19

11 ответов




33

Импорт математического модуля происходит только один раз, и вы, вероятно, не получите намного быстрее, чем математический модуль. Существует также более старый вопрос Stackoverflow о том, что быстрее в Python: x**.5 или math.sqrt(x)? . Неясно, какой метод быстрее.

Возможно , взгляните на NumPy и SciPy, не обязательно для sqrt, но если вы делаете какие-то тяжелые вычисления, они могут быть полезны.

Поделиться Mad Scientist     15 июня 2010 в 16:23



12

Как сказал Фабиан, трудно быть быстрее, чем math.sqrt . Причина в том, что он вызывает соответствующую функцию из библиотеки C с CPython.

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

from math import sqrt

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

print sqrt(2)

Вот цифры времени, от самого быстрого до самого медленного (Python 2.6.5, Mac OS X 10.6.3): sqrt быстрее, чем **0.5 :

[email protected] ~ % python -m timeit -s 'from math import sqrt; x = 2' 'sqrt(x)'
1000000 loops, best of 3: 0.207 usec per loop
[email protected] ~ % python -m timeit -s 'x = 2' 'x**0.5'
1000000 loops, best of 3: 0.226 usec per loop
[email protected] ~ % python -m timeit -s 'import math; x = 2' 'math.sqrt(x)'
1000000 loops, best of 3: 0.268 usec per loop

Обратите внимание, что тесты синхронизации вычисляют квадратный корень из переменной . Они не вычисляют константу , такую как 2**0.5, потому что 2**0.5 предварительно вычисляется в CPython:

import dis

def f():
    return 2**0.5

print dis.dis(f)

печать

2           0 LOAD_CONST               3 (1.4142135623730951)
            3 RETURN_VALUE        

где вы видите постоянную плавающую sqrt(2) = 1.414…

Если вы манипулируете массивами чисел, NumPy sqrt -это путь, как упоминалось в другом ответе.

Поделиться Eric O Lebigot     15 июня 2010 в 17:16



10

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

function sqrt(x)
  lastGuess=x/2
  loop
    guess=(lastGuess+x/lastGuess)/2
    if abs(guess-lastGuess)<.000001 // or whatever threshold you want
      exit loop
    lastGuess=guess
  return guess

и псевдокод, переведенный на Python:

def sqrt(x):
    last_guess= x/2.0
    while True:
        guess= (last_guess + x/last_guess)/2
        if abs(guess - last_guess) < .000001: # example threshold
            return guess
        last_guess= guess

Поделиться Jay     15 июня 2010 в 17:33


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

    У меня есть следующий код, пытающийся вычислить квадратный корень из ряда Даска my_dask_df[‘a_column’] = numpy.sqrt(my_dask_df[‘a_column’]) То, что я получаю, — это следующее исключение: ValueError: Not all divisions are known, can’t align partitions. Please use `set_index` to set the index. Как я…

  • квадратный корень без предопределенной функции в python

    Как можно найти квадратный корень из числа, не используя никаких заранее определенных функций в python? Мне нужна основная логика того, как работает квадратный корень из программы. В общей математике мы будем делать это с помощью HCF, но в программировании я не могу найти логику.



5

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

(Вот как это сделал quake)

Поделиться Jay     15 июня 2010 в 17:35



5

Вы должны ввести эту строку в блокнот Jupyter:

25**(1/2)

Поделиться Unknown     14 июля 2018 в 06:31



4

Используйте оператор питания и увеличьте свои числа до 1/2 мощности:

>>> 2**0.5
1.4142135623730951

Что касается того, быстрее ли это:

>>> timeit.timeit(stmt='sqrt(x)', setup='from math import sqrt; x = 2')
0.7182440785071833
>>> timeit.timeit(stmt='x**0.5', setup='from math import sqrt; x = 2')
0.87514279049432275

Поделиться Seth     15 июня 2010 в 16:33



3

Вы могли бы реализовать метод Ньютона, но, хотя он действительно быстр, он вряд ли будет быстрее, чем версия C, которая, как я предполагаю, реализована в математическом модуле. См . http://en.wikipedia.org/wiki/ Methods_of_computing_square_roots .

Поделиться lhf     15 июня 2010 в 16:27



2

Функция Квадратного Корня

 def sqrt(number):
    if number ** 0.5 == int(number ** 0.5):
      return True
    else:
      return False

Поделиться Davis Tanugraha     21 августа 2018 в 01:29



1

немного поздно для вечеринки, но в любом случае я хотел бы упомянуть об этих простых арифметиках:

25**(1/2)

или

pow(25, 0,5)

вернется как 5. Заказать.

Поделиться cabavyras     11 апреля 2020 в 21:47



0

Python фрагмент кода для вычисления квадрата. Сначала он делает первоначальную догадку, и если догадка недостаточно хороша, она повторяется до тех пор, пока у нас не будет хорошей догадки

def gen_square_root_v1(number, epsilon):

   #boundary condition check

   if number == '1':
      return 1

   elif number <= 0:
      print('this computes square root for positive numbers only' )

   else:
      pass


   prev_estimate = number/2

   while True: 

       #each itearation, calculate a new estimate
       new_estimate = (prev_estimate + number/prev_estimate)/2

       #Alternatively can use if abs(new_estimate - prev_estimate) < epsilon:

       #check the difference between  square of new_estimate and number
       if abs(new_estimate * new_estimate - number) < epsilon:
         return prev_estimate

     #if guess is not good enough, use it to make the next guess           
     prev_estimate = new_estimate


#call the function    
print(gen_square_root_v1(16,1e-5))

Поделиться Sarvesh     13 ноября 2017 в 14:56



0

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

 x=float(input())
 min1=0 
 max1=x
 for i in range(10):
     mid=(min1+max1)/2  #middle value
     res=mid**2       #finding the square of middle value
     if res==x:       #if the middle value is square root program break here
        break        
     elif res>x:      #if the square value of the middle value is more than x then we need to take max value as middle 
        max1=mid
     else:                  #if the square value of the middle value is less than x then we need to take min  value as middle 
        min1=mid

 print(mid)
  

Поделиться srikanth Gattu     28 апреля 2020 в 16:40



Похожие вопросы:


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

Я пытаюсь написать программу с assembly, чтобы запросить у пользователя input, вычислить квадратный корень из числа, а затем вывести квадратный корень из числа. Я действительно не знаю, с чего…


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

Это формула, которая может быть использована для вычисления квадратного корня из числа. result=(guess+(number/guess))/2; Например, мне нужно получить квадратный корень из 9. Во-первых, мне нужно…


Наибольшее число раз квадратный корень может быть вычислен на числах между 2 интервалами

Я написал простую программу для вычисления максимального числа раз квадратный корень может быть вычислен на число , вход-это интервал от num1 до num2 , например: если вход равен (1,20), ответ-2 ,…


Умножение, деление и квадратный корень без использования арифметических операторов

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


Отрицательный квадратный корень

Как вы берете квадратный корень из отрицательного числа в C++? Я знаю, что он должен вернуть реальную и сложную часть, я получаю NaN? Как мне принять реальную роль?


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

У меня есть следующий код, пытающийся вычислить квадратный корень из ряда Даска my_dask_df[‘a_column’] = numpy.sqrt(my_dask_df[‘a_column’]) То, что я получаю, — это следующее исключение: ValueError:…


квадратный корень без предопределенной функции в python

Как можно найти квадратный корень из числа, не используя никаких заранее определенных функций в python? Мне нужна основная логика того, как работает квадратный корень из программы. В общей…


F# квадратный корень на Int

Я создаю программу в F#, в которой мне нужно сделать квадратный корень из целого числа. Я искал и не нашел ни одной функции, которая позволяла бы делать это без использования cast int -> float ….


Как взять квадратный корень из числа в Elixir?

Как взять квадратный корень из числа в Elixir? Там, кажется, нет модуля Math или чего-то еще, и нет такой функции, как sqrt() .


Как выполнить поэлементный квадратный корень вектора в Julia?

Мне нужно выполнить квадратный корень массива в Julia, но, похоже, функция sqrt() просто выполняет квадратные корни на скалярах и квадратных матрицах. Есть ли какой-нибудь простой компактный способ…

Целочисленный квадратный корень в python Ru Python

Существует ли целочисленный квадратный корень где-то в python или в стандартных библиотеках? Я хочу, чтобы он был точным (т. Е. Возвращал целое число) и лаем, если нет решения.

В настоящий момент я перевернул свой наивный:

Но это уродливо, и я не очень доверяю ему для больших целых чисел. Я мог бы перебирать квадраты и сдаваться, если бы я превысил ценность, но я предполагаю, что было бы слишком медленно делать что-то подобное. Также я предполагаю, что, вероятно, буду изобретать колесо, что-то вроде этого наверняка существует в питоне уже …

Метод Ньютона отлично работает на целых числах:

 def isqrt(n): x = n y = (x + 1) // 2 while y < x: x = y y = (x + n // x) // 2 return x 

Это возвращает наибольшее целое число x, для которого x * x не превосходит n . Если вы хотите проверить, является ли результат точно квадратным корнем, просто выполните умножение, чтобы проверить, является ли n идеальным квадратом.

Я обсуждаю этот алгоритм и три других алгоритма вычисления квадратных корней в моем блоге .

Извините за очень поздний ответ; Я просто наткнулся на эту страницу. В случае, если кто-либо посещает эту страницу в будущем, модуль python gmpy2 предназначен для работы с очень большими входами и включает в себя, помимо прочего, целочисленную функцию с квадратным корнем.

Пример:

 >>> import gmpy2 >>> gmpy2.isqrt((10**100+1)**2) mpz(10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001L) >>> gmpy2.isqrt((10**100+1)**2 - 1) mpz(10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000L) 

Конечно, все будет иметь тег «mpz», но mpz совместимы с int:

 >>> gmpy2.mpz(3)*4 mpz(12) >>> int(gmpy2.mpz(12)) 12 

См. Мой другой ответ для обсуждения эффективности этого метода относительно некоторых других ответов на этот вопрос.

Загрузить: https://code.google.com/p/gmpy/

Длинный алгоритм квадратного корня

Оказывается, существует алгоритм вычисления квадратных корней, который вы можете вычислить вручную, что-то вроде длинного деления. Каждая итерация алгоритма производит ровно одну цифру полученного квадратного корня, потребляя две цифры числа, квадратный корень которого вы ищете. В то время как «длинная рука» версия алгоритма указана в десятичной форме, она работает в любой базе, причем бинарные файлы проще всего реализовать и, возможно, самые быстрые для выполнения (в зависимости от базового представления bignum).

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

На сайте «Dr. Math» есть две хорошие записи, которые объясняют алгоритм:

  • Квадратные корни в двоичном
  • Длинные квадратные корни

И вот реализация в Python:

 def exact_sqrt(x): """Calculate the square root of an arbitrarily large integer. The result of exact_sqrt(x) is a tuple (a, r) such that a**2 + r = x, where a is the largest integer such that a**2 <= x, and r is the "remainder". If x is a perfect square, then r will be zero. The algorithm used is the "long-hand square root" algorithm, as described at http://mathforum.org/library/drmath/view/52656.html Tobin Fricke 2014-04-23 Max Planck Institute for Gravitational Physics Hannover, Germany """ N = 0 # Problem so far a = 0 # Solution so far # We'll process the number two bits at a time, starting at the MSB L = x.bit_length() L += (L % 2) # Round up to the next even number for i in xrange(L, -1, -1): # Get the next group of two bits n = (x >> (2*i)) & 0b11 # Check whether we can reduce the remainder if ((N - a*a) << 2) + n >= (a<<2) + 1: b = 1 else: b = 0 a = (a << 1) | b # Concatenate the next bit of the solution N = (N << 2) | n # Concatenate the next bit of the problem return (a, Na*a) 

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

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

Источник репо: https://gist.github.com/tobin/11233492

Одним из вариантов было бы использовать decimal модуль и делать это в достаточно точных поплавках:

 import decimal def isqrt(n): nd = decimal.Decimal(n) with decimal.localcontext() as ctx: ctx.prec = n.bit_length() i = int(nd.sqrt()) if i**2 != n: raise ValueError('input was not a perfect square') return i 

который, я думаю, должен работать:

 >>> isqrt(1) 1 >>> isqrt(7**14) == 7**7 True >>> isqrt(11**1000) == 11**500 True >>> isqrt(11**1000+1) Traceback (most recent call last): File "<ipython-input-121-e80953fb4d8e>", line 1, in <module> isqrt(11**1000+1) File "<ipython-input-100-dd91f704e2bd>", line 10, in isqrt raise ValueError('input was not a perfect square') ValueError: input was not a perfect square 

Похоже, вы можете проверить вот так:

 if int(math.sqrt(n))**2 == n: print n, 'is a perfect square' 

Обновить:

Как вы указали выше, при больших значениях n не выполняется. Для тех, которые выглядят многообещающе, что является адаптацией примера кода C Мартином Гаем @ UKC, июнь 1985 года, для относительно простого выглядящего двоичного численного численного метода расчета, упомянутого в статье в Википедии. Методы вычисления квадратных корней :

 from math import ceil, log def isqrt(n): res = 0 bit = 4**int(ceil(log(n, 4))) if n else 0 # smallest power of 4 >= the argument while bit: if n >= res + bit: n -= res + bit res = (res >> 1) + bit else: res >>= 1 bit >>= 2 return res if __name__ == '__main__': from math import sqrt # for comparison purposes for i in range(17)+[2**53, (10**100+1)**2]: is_perfect_sq = isqrt(i)**2 == i print '{:21,d}: math.sqrt={:12,.7G}, isqrt={:10,d} {}'.format( i, sqrt(i), isqrt(i), '(perfect square)' if is_perfect_sq else '') 

Вывод:

  0: math.sqrt= 0, isqrt= 0 (perfect square) 1: math.sqrt= 1, isqrt= 1 (perfect square) 2: math.sqrt= 1.414214, isqrt= 1 3: math.sqrt= 1.732051, isqrt= 1 4: math.sqrt= 2, isqrt= 2 (perfect square) 5: math.sqrt= 2.236068, isqrt= 2 6: math.sqrt= 2.44949, isqrt= 2 7: math.sqrt= 2.645751, isqrt= 2 8: math.sqrt= 2.828427, isqrt= 2 9: math.sqrt= 3, isqrt= 3 (perfect square) 10: math.sqrt= 3.162278, isqrt= 3 11: math.sqrt= 3.316625, isqrt= 3 12: math.sqrt= 3.464102, isqrt= 3 13: math.sqrt= 3.605551, isqrt= 3 14: math.sqrt= 3.741657, isqrt= 3 15: math.sqrt= 3.872983, isqrt= 3 16: math.sqrt= 4, isqrt= 4 (perfect square) 9,007,199,254,740,992: math.sqrt=9.490627E+07, isqrt=94,906,265 100,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,020,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,001: math.sqrt= 1E+100, isqrt=10,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,001 (perfect square) 

Вот очень простая реализация:

 def i_sqrt(n): i = n.(log_2(n)) = n. QED. # while m*m > n: m >>= 1 i -= 1 for k in xrange(i-1, -1, -1): x = m | (1 << k) if x*x <= n: m = x return m 

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

Для достаточно больших значений n (например, около 10**6000 или около 20000 бит) это выглядит так:

  • Быстрее, чем реализация метода Ньютона, описанная user448810 .
  • Много, гораздо медленнее, чем встроенный в gmpy2 метод в моем другом ответе .
  • Сопоставимый, но несколько медленнее, чем Longhand Square Root, описанный nibot .

Все эти подходы достигают успеха на входе такого размера, но на моей машине эта функция занимает около 1,5 секунд, тогда как @ Nibot занимает около 0,9 секунды, @ user448810 занимает около 19 секунд, а встроенный метод gmpy2 занимает менее миллисекунды (!). Пример:

 >>> import random >>> import timeit >>> import gmpy2 >>> r = random.getrandbits >>> t = timeit.timeit >>> t('i_sqrt(r(20000))', 'from __main__ import *', number = 5)/5. # This function 1.5102493192883117 >>> t('exact_sqrt(r(20000))', 'from __main__ import *', number = 5)/5. # Nibot 0.8952787937686366 >>> t('isqrt(r(20000))', 'from __main__ import *', number = 5)/5. # user448810 19.326695976676184 >>> t('gmpy2.isqrt(r(20000))', 'from __main__ import *', number = 5)/5. # gmpy2 0.0003599147067689046 >>> all(i_sqrt(n)==isqrt(n)==exact_sqrt(n)[0]==int(gmpy2.isqrt(n)) for n in (r(1500) for i in xrange(1500))) True 

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

 def i_root(num, root, report_exactness = True): i = num.bit_length() / root m = 1 << i while m ** root < num: m <<= 1 i += 1 while m ** root > num: m >>= 1 i -= 1 for k in xrange(i-1, -1, -1): x = m | (1 << k) if x ** root <= num: m = x if report_exactness: return m, m ** root == num return m 

Однако обратите внимание, что gmpy2 также имеет метод i_root .(2k) if new_diff >= 0: d = new_diff m |= j return m

Заметим, что по конструкции k й бит m << 1 не установлен, поэтому побитовым или может быть использован для реализации добавления (m<<1) + (1<<k) . В конечном счете у меня есть (2*m*(2**k) + 2**(2*k)) записанный как (((m<<1) | (1<<k)) << k) , поэтому это три сдвигами и одним поразрядным – или (с последующим вычитанием для получения new_diff ). Может быть, есть еще более эффективный способ получить это? Несмотря на это, это намного лучше, чем умножение m*m ! Сравните с выше:

 >>> t('improved_i_sqrt(r(20000))', 'from __main__ import *', number = 5)/5. 0.10908999762373242 >>> all(improved_i_sqrt(n) == i_sqrt(n) for n in xrange(10**6)) True 

Ваша функция не работает для больших входов:

 In [26]: isqrt((10**100+1)**2) ValueError: input was not a perfect square 

На сайте ActiveState есть рецепт, который, надеюсь, будет более надежным, поскольку он использует только математические целые числа. Он основан на более раннем вопросе StackOverflow: написание собственной функции квадратного корня

Я нашел эту ветку несколько дней назад и повторно написал решение nibot , и, сократив количество итераций пополам и сделав некоторые другие незначительные улучшения производительности, я смог улучшить производительность в 2,4 раза:

 def isqrt(n): a = 0 # a is the current answer. r = 0 # r is the current remainder. for s in reversed(range(0, n.bit_length(), 2)): # Shift n by s bits. t = n >> s & 3 # t is the two next most significant bits of n. r = r << 2 | t # Increase the remainder as if no new bit is set. c = a << 2 | 1 # c is an intermediate value used for comparison. b = r >= c # b is the next bit in the remainder. if b: r -= c # b has been set, so reduce the remainder. a = a << 1 | b # Update the answer to include b. return (a, r) 

Вот результаты от timeit :

 >>> timeit('isqrt(12345678901234567890)', setup='from __main__ import isqrt') 8.862877120962366 

Затем для сравнения я применил наиболее часто используемый алгоритм с квадратным корнем: метод Ньютона . Это определение гораздо более компактно.

 def isqrt(n): x, y = n, n >> 1 while x > y: x, y = y, (y + n//y) >> 1 return (x, n - x*x) 

Оказывается, что даже оптимизированная версия длинномерных квадратных корней медленнее метода Ньютона, занимая примерно в 1,5 раза.

 >>> timeit('isqrt(12345678901234567890)', setup='from __main__ import isqrt') 5.74083631898975 

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

Изменить: я исправил ошибку в методе Ньютона выше. На моей машине он работает на ~ 10% быстрее, чем решение user448810 .

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

 def isqrt(n): epsilon = .00000000001 i = int(n**.5 + 0.5) if abs(i**2 - n) < epsilon: return i raise ValueError('input was not a perfect square') 

Я сравнил различные методы, приведенные здесь, с циклом:

 for i in range (1000000): # 700 msec r=int(123456781234567**0.5+0.5) if r**2==123456781234567:rr=r else:rr=-1 

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

 15241576832799734552675677489**0.5 = 123456781234567.0 

Попробуйте это условие (без дополнительных вычислений):

 def isqrt(n): i = math.sqrt(n) if i != int(i): raise ValueError('input was not a perfect square') return i 

Если вам нужно, чтобы он возвращал int (а не float с конечным нолем), то либо назначить вторую переменную, либо вычислить int(i) дважды.

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

Автор оригинала: Team Python Pool.

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

Для вычисления квадратного корня в Python у нас есть в основном 5 методов или способов. Самый распространенный или самый простой способ-это использование функции математического модуля sqrt. Функция Python sqrt встроена в математический модуль, вы должны импортировать математический пакет (модуль). Функция sqrt в языке программирования python, возвращающая квадратный корень из любого числа (число > 0).

Различные способы вычисления квадратного корня в Python

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

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

Вычисление квадратного корня в Python С помощью функции sqrt()

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

Синтаксис

Ниже приведен синтаксис функции Python sqrt ().

import math
math.sqrt(num)

Параметры

номер – Здесь num может быть любым положительным числом, квадратный корень которого вы хотите.

Возвращаемое значение функции sqrt()

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

Совместимость функций Python sqrt()

Python 2.x Да
Python 3.x Да

Примеры Вычисления Квадратного Корня С Помощью Функции sqrt()

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

Пример 1: Вычисление квадратного корня из положительного целого числа

import math
print("The square root of 25 is",math.sqrt(64))

Выход:

The square root of 25 is 8.0

Пример 2: Вычисление квадратного корня из числа с плавающей запятой

import math
print("The square root of 9.9 is:", math.sqrt(12.9))

Выход:

The square root of 9.9 is: 3.591656999213594

Пример 3: Вычисление квадратного корня из 0

import math
print("The square root of 0 is",math.sqrt(0))

Выход:

The square root of 0 is 0.0

Выход:

import math
print("The square root of -16 is",math.sqrt(-16))

Выход:

Traceback (most recent call last):
  File "c:/Users/Karan/Desktop/test.py", line 2, in 
    print("The square root of -16 is",math.sqrt(-16))
ValueError: math domain error

Таким образом, когда x <0 он не выполняется, вместо этого генерируется ValueError.

Пример 5: Вычисление квадратного корня из постоянной Больцмана

import math
# Find square root of boltzmann constant
.38064852*pow(10,-23)

print("Square root of Boltzmann constant:{}".format(math.sqrt(boltzmannConstant_SqRoot)))

Выход:

Square root of Boltzmann constant:3.715707900252655e-12

Записи:

    функция math.sqrt () – это встроенная функция в языке программирования Python, которая предоставляет квадратный корень из заданного числа. Для работы функции math.sqrt() необходимо импортировать модуль (библиотеку) “math”. Если вы передадите отрицательное значение в функцию sqrt, то python выдаст ошибку

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

** оператор-это оператор экспоненты. а**б (а поднят до степени б).

Шаги по поиску квадратного корня в Python с помощью оператора **

    Определите функцию с именем sqrt(n) Уравнение, n**0.5-это нахождение квадратного корня, а результат хранится в переменной x. Возьмите входные данные от пользователя и сохраните их в переменной n. Функция вызывается для реализации действия и вывода результата. Выход

Пример 1: Вычисление квадратного корня из числа С помощью оператора * *

def sqrt(n):
  if n < 0:
    return
  else:
    return n**0.5
  
print(sqrt(61))

Выход:

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

Модуль cmath используется для вычисления квадратного корня в python из Действительного или сложного числа.

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

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

# Find square root of real or complex numbers
# Import the complex math module
import cmath

# change this value for a different result+2j

# uncommment to take input from the user(input('Enter a number: ')).sqrt(num)
print('The square root of {0} is {1:0.3f}+{2:0.3f}j'.format(num ,num_sqrt.real,num_sqrt.imag))

Выход:

The square root of (1+2j) is 1.272+0.786j

В этой программе мы используем функцию sqrt() в href=”https://docs.python.org/2/library/cmath.html”>cmath (комплексная математика) модуль. Обратите внимание, что мы также использовали функцию eval() вместо float() для преобразования комплексного числа. Кроме того, обратите внимание на то, как форматируются выходные данные. href=”https://docs.python.org/2/library/cmath.html”>cmath (комплексная математика) модуль. Обратите внимание, что мы также использовали функцию eval() вместо float() для преобразования комплексного числа. Кроме того, обратите внимание на то, как форматируются выходные данные.

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

Пример:

Выход:

Please Enter any Postive Integer : 5
Enter Exponent Value to the power raise to : 3
The Result of 5 Power

Вычисление Квадратного Корня С Помощью pow()

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

Давайте разберемся, как работает функция pow() в Python.

Метод pow() принимает 2 параметра, первый параметр-числовое значение, а второй параметр-мощность числового значения. Если мы посмотрим на него, то вы заметите, что он похож на то, как мы вычисляли квадратный корень в приведенных выше примерах.

Метод pow() принимает 2 параметра, первый параметр-числовое значение, а второй параметр-мощность числового значения. Если мы посмотрим на него, то вы заметите, что он похож на то, как мы вычисляли квадратный корень в приведенных выше примерах.

Синтаксис

pow(x,y) # где y-сила x или x**y

Пример: Вычисление квадратного корня из числа С помощью pow()

# Python Square root program
import math(input(" Please Enter any numeric Value : "))
.pow(number, 0.5)

print("The Square Root of a Given Number {0}  = {1}".format(number, squareRoot))

Выход:

Please Enter any numeric Value: 69
The Square Root of a Given Number.306623862918075

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

Программа Python Для Проверки Того, Является Ли Число Идеальным Квадратом или Нет

Любое число, которое может быть выражено как произведение двух целых равных чисел, классифицируется как совершенный квадрат. Например, 25 можно записать как 5*5, следовательно, 25-идеальный квадрат.

Алгоритм проверять

    Примите входные данные от пользователя Вычислите квадратный корень из заданного числа с помощью математической библиотеки Проверка того, является ли int(root + 0.5) ** 2, если это значение равно True, то число является идеальным квадратом

Пример:

import math

# Taking the input from user(input("Enter the Number: "))
.sqrt(number)
if int(root + 0.5) ** 2:
    print(number, "is a perfect square")
else:
    print(number, "is not a perfect square")

Выход:

Enter the Number: 81
81 is a perfect square

Функция sqrt() в Numpy для вычисления квадратного корня

numpy — это сторонняя библиотека и модуль, который обеспечивает вычисления матриц, рядов, больших данных и т. Д. Numpy также предоставляет функции sqrt() и pow(), и мы можем использовать эти функции для вычисления квадратного корня.

import numy
numpy.sqrt(9)
//The result is 3
 
numpy.pow(9,1/2)
//The result is 3

Также Читайте:

Как проверить версию Python в различных ОСPython User Input | Python Input () Function | Keyboard InputPython Stack | Реализация стека в PythonСколько времени требуется Для Изучения Python

Вывод

Поэтому в этом уроке мы попытались рассказать о том, как вычислить Квадратный корень In Python. Мы обсудили все методы и приемы, с помощью которых можно вычислить квадратный корень.

Если у вас еще есть какие-то сомнения или предложения. Дайте нам знать об этом в разделе комментариев ниже.

sqrt | NumPy

numpy.sqrt(x, *ufunc_args) = <ufunc 'sqrt'>

Функция sqrt() вычисляет квадратный корень элементов массива.

Данная функция эквивалентна команде x**0.5 (или x**(1/2)).

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

Параметры:
x — число, массив или подобный массиву объект
Входные данные.
*ufunc_args — аргументы универсальной функции
Аргументы, позволяющие настроить и оптимизировать работу функции (подробнее см. универсальные функции).
Возвращает:
результат — массив NumPy или вещественное число
Массив вычисленных квадратных корней элементов из x или число, если на вход подано одно число.

Замечание

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


Примеры

>>> import numpy as np
>>> 
>>> np.sqrt(25)
5.0
>>> 
>>> np.sqrt(-1)
__main__:1: RuntimeWarning: invalid value encountered in sqrt
nan
>>>
>>> np.sqrt([2, 3, 5, 7])
array([1.41421356, 1.73205081, 2.23606798, 2.64575131])
>>>
>>> np.sqrt([0.01, 0.04, 0.09, 0.16]) 
array([0.1, 0.2, 0.3, 0.4])
>>> 
>>> np.sqrt([-9, -4, -1, 3 + 4j, 8 + 6j])
array([0.+3.j, 0.+2.j, 0.+1.j, 2.+1.j, 3.+1.j])
>>> 
>>> np.sqrt([-np.inf, -0, np.nan, np.inf])
array([nan,  0., nan, inf]) 

Функция квадратного корня Python — настоящий Python