Python 3 корень: Как в python извлечь корень? — Хабр Q&A

Кубический корень отрицательного числа на python Ru Python

Может ли кто-нибудь помочь мне найти решение о том, как вычислить кубический корень отрицательного числа с помощью python?

это не работает. Кубический корень отрицательного числа – отрицательное число. Любые решения?

Вы можете использовать:

 -math.pow(3, float(1)/3) 

Или в целом:

 if x > 0: return math.pow(x, float(1)/3) elif x < 0: return -math.pow(abs(x), float(1)/3) else: return 0 

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

 import numpy import math def cuberoot( z ): z = complex(z) x = z.real y = z.imag mag = abs(z) arg = math.atan2(y,x) return [ mag**(1./3) * numpy.exp( 1j*(arg+2*n*math.pi)/3 ) for n in range(1,4) ] 

Изменить: по запросу в случаях, когда неуместно иметь зависимость от numpy, следующий код делает то же самое.

 def cuberoot( z ): z = complex(z) x = z.real y = z.imag mag = abs(z) arg = math.atan2(y,x) resMag = mag**(1./3) resArg = [ (arg+2*math.pi*n)/3. for n in range(1,4) ] return [ resMag*(math.cos(a) + math.sin(a)*1j) for a in resArg ] 

 math.pow(abs(x),float(1)/3) * (1,-1)[x<0] 

Вы можете получить полный (все n корней) и более общий (любой знак, любое питание) решение, используя:

 import cmath x, t = -3., 3 # x**(1/t) a = cmath.exp((1./t)*cmath.log(x)) p = cmath.exp(1j*2*cmath.pi*(1./t)) r = [a*(p**i) for i in range(t)] 

Объяснение: a использует уравнение x ^u = exp (u * log (x)). (1/3)

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

Вы также можете обернуть библиотеку libm которая предлагает функцию cbrt (кубический корень):

 from ctypes import * libm = cdll.LoadLibrary('libm.so.6') libm.cbrt.restype = c_double libm.cbrt.argtypes = [c_double] libm.cbrt(-8.0) 

дает ожидаемый

 -2.0 

это работает также с массивом numpy:

 cbrt = lambda n: n/abs(n)*abs(n)**(1./3) 

Примитивное решение:

 def cubic_root(nr): if nr<0: return -math.pow(-nr, float(1)/3) else: return math.pow(nr, float(1)/3) 

Наверное, массово непифонный, но он должен работать.

Вы можете использовать cbrt из scipy.special :

 >>> from scipy.special import cbrt >>> cbrt(-3) -1.4422495703074083 

Это также работает для массивов.

У меня была очень похожая проблема, и я нашел решение NumPy на этом форуме .

В nushell мы можем использовать sign NumPy и absolute методы, чтобы помочь нам. Вот пример, который сработал для меня:

 import numpy as np x = np.array([-81,25]) print x #>>> [-81 25] xRoot5 = np.sign(x) * np.absolute(x)**(1.0/5.0) print xRoot5 #>>> [-2.40822469 1.90365394] print xRoot5**5 #>>> [-81. 25.] 

Итак, возвращаясь к исходной проблеме куба:

 import numpy as np y = -3. np.sign(y) * np.absolute(y)**(1./3.) #>>> -1.4422495703074083 

Надеюсь, это поможет.

Для арифметики, калькуляторный ответ в Python 3:

 >>> -3.0**(1/3) -1.4422495703074083 

или -3.0**(1./3) в Python 2.

Для алгебраического решения x**3 + (0*x**2 + 0*x) + 3 = 0 используйте numpy:

 >>> p = [1,0,0,3] >>> numpy. roots(p) [-3.0+0.j 1.5+2.59807621j 1.5-2.59807621j] 

python — Неправильное значение для корня куба в Python

Используя Python 3.5 на repl.it и на консоли в Windows, я получаю неправильные ответы для корней куба.

Когда вводом (-1)**(1/3), Я получаю комплексное число (0.5000000000000001 + 0.8660254037844386j) в качестве ответа, когда оно должно быть просто -1. Кажется, что любое отрицательное значение под этим корнем дает сложный результат.

Я делаю что-то неправильно?

3

Lupilum

12 Фев 2017 в 18:27

3 ответа

Лучший ответ

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

Для особого случая степени 1/3 с действительными основаниями вы могли бы написать такую функцию:

def cubeRoot(x):
    if x >= 0:
        return x**(1/3)
    else:
        return -(-x)**(1/3)

Который даст ожидаемый реальный кубический корень.

1

John Coleman
12 Фев 2017 в 17:56

На самом деле, Python не знает, что вы берете корень куба!

Все, что он видит, это аргумент с плавающей запятой со значением, близким к 0,3333333333 …, но из-за конечности представления невозможно предположить, что вы имеете в виду в точности 1/3.

Таким образом, все, что может сделать Python, — это вернуться к обычному определению возведения в степень отрицательных базисов в реальную степень (основную ветвь) через формулу

(-x)^y = exp(y(ln(x) + iπ) = exp(y ln(x)) (cos(yπ) + i sin(yπ))

Который дает комплексное значение.

1

Yves Daoust
12 Фев 2017 в 17:58

Вы получите именно этот ответ, потому что оператор власти вычисляет

x**y = exp(y*ln(x))

И если x не является положительным вещественным веществом, то его логарифм вычисляется из основной ветви комплексного логарифма

ln(u+i*v)=0.5*ln(u²+v²) + i*arg(u+i*v)

Где в терминах математической библиотеки arg(u+i*v)=atan2(v,u).

Таким образом, ln(-1)=i*pi и

(-1)**(1.0/3)=exp(i*pi/3)=cos(pi/3)+i*sin(pi/3)

Который имеет ценность, которую вы получили. Ошибки с плавающей запятой возникают, поскольку y=1.0/3 не совсем 1/3, pi не является точно математической константой с тем же именем, а тригонометрические функции также являются приближениями к точным математическим функциям.

0

Lutz Lehmann
12 Фев 2017 в 17:15

42189413

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 2.7.8 не получается найти корень квадратный и экспоненту.

3 Answers

Как уже написали ранее, можно воспользоваться функциями из стандартного модуля math . Для этого его нужно подключить к программе. Использование выглядит следующим образом:

При желании можно использовать и без префикса, в таком случае можно использовать другой синтаксис импорта:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Но можно использовать и трюки с возведением в степень 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 с помощью этих двух методов:

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

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

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

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

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

Вывод

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

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

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

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

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

В Python есть выражение для возведения числа в степень ( ** ) :

А мы знаем, что вычисление квадратного корня числа, аналогично возведению в степень 1/2. Значит на языку Python можем воспользоваться выражением для возведения числа в степень для вычисления корня числа:

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

Второй вариант вычисления квадратного корня — это импорт модуля math и последующее использование функции данного модуля:

В первой стоке мы импортируем встроенный модуль math, а во второй используем функцию вычисления квадратного корня (math. 2+bx+c’)

a = int(input(‘Введите a = ‘))

b = int(input(‘Введите b = ‘))

c = int(input(‘Введите c = ‘))

D = b ** 2 — 4 * a * c

if D == 0:

____x = -b / (2 * a)

____print(‘Дискриминант D равен 0. Имеет один корень:’)

____print(‘x =’, x)

if D < 0:

print(‘Вещественных корней нет’)

if D > 0:

____x1 = (-b + Mathf.sqrt(D)) / (2 * a)

____x2 = (-b — Mathf.sqrt(D)) / (2 * a)

____print(‘Дискриминант D больше 0. Имеет два корня:’)

____print(‘x1 =’, x1, ‘x2 =’, x2)

Functions and recursion — Learn Python 3

Напомним, что в математике факториал числа n определяется как n! = 1 ⋅ 2 ⋅ … ⋅ n (как произведение всех целых чисел от 1 до n). Например, 5! = 1 ⋅ 2 ⋅ 3 ⋅ 4 ⋅ 5 = 120. Ясно, что факториал легко вычислить, используя цикл for. Представьте, что нам нужно в нашей программе несколько раз вычислить факториал разных чисел (или в разных местах кода). Конечно, вы можете написать вычисление факториала один раз, а затем с помощью Copy-Paste вставить его туда, где вам это нужно:

None

# вычислить 3!
res = 1
for i in range(1, 4):
    res *= i
print(res)

# вычислить 5!
res = 1
for i in range(1, 6):
    res *= i
print(res)

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

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

Теперь мы хотим показать вам, как написать функцию factorial() которая принимает один параметр — число и возвращает значение — факториал этого числа.

None

def factorial(n):
    res = 1
    for i in range(1, n + 1):
        res *= i
    return res

print(factorial(3))
print(factorial(5))

Мы хотим дать несколько объяснений. Во-первых, код функции должен быть помещен в начало программы (до места, где мы хотим использовать функцию factorial() , если быть точным). Первая строка def factorial(n): из этого примера является описанием нашей функции; слово factorial является идентификатором (имя нашей функции). Сразу после идентификатора появляется список параметров, которые получает наша функция (в скобках). Список состоит из разделенных запятыми идентификаторов параметров; в нашем случае список состоит из одного параметра n . В конце строки поместите двоеточие.

Затем идет тело функции. В Python тело должно быть отступом (по Tab или четыре пробела, как всегда). Эта функция вычисляет значение n! и сохраняет его в переменной res . Последней строкой функции является return res , которая выходит из функции и возвращает значение переменной res .

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

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

10
20

def max(a, b):
    if a > b:
        return a
    else:
        return b

print(max(3, 5))
print(max(5, 3))
print(max(int(input()), int(input())))

Теперь вы можете написать функцию max3() которая принимает три числа и возвращает максимум из них.

None

def max(a, b):
    if a > b:
        return a
    else:
        return b

def max3(a, b, c):
    return max(max(a, b), c)

print(max3(3, 5, 4))

Встроенная функция max() в Python может принимать различное количество аргументов и возвращать максимум из них. Вот пример того, как можно написать такую ​​функцию.

None

def max(*a):
    res = a[0]
    for val in a[1:]:
        if val > res:
            res = val
    return res

print(max(3, 5, 4))

Все, переданное этой функции, соберет параметры в один кортеж, называемый a , который обозначен звездочкой.

Внутри функции вы можете использовать переменные, объявленные где-то вне нее:

None

def f():
    print(a)

a = 1
f()

Здесь переменная a установлена ​​в 1, а функция f() печатает это значение, несмотря на то, что когда мы объявляем функцию f эта переменная не инициализируется. Причина в том, что во время вызова функции f() (последняя строка) переменная a уже имеет значение. Вот почему функция f() может отображать ее.

Такие переменные (объявленные вне функции, но доступные внутри функции) называются глобальными .

Но если вы инициализируете некоторую переменную внутри функции, вы не сможете использовать эту переменную за ее пределами. Например:

None

def f():
    a = 1

f()
print(a)

Мы получаем ошибку NameError: name 'a' is not defined . Такие переменные, объявленные внутри функции, называются локальными . После выхода из функции они становятся недоступными.

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

None

def f():
    a = 1
    print(a)

a = 0
f()
print(a)

Эта программа напечатает вам числа 1 и 0. Несмотря на то, что значение переменной a измененное внутри функции, вне функции остается неизменным! Это делается для того, чтобы «защитить» глобальные переменные от непреднамеренных изменений функции. Итак, если какая-либо переменная изменяется внутри функции, переменная становится локальной переменной, и ее модификация не изменит глобальную переменную с тем же именем.

Более формально: интерпретатор Python рассматривает переменную локальную для функции, если в коде этой функции есть хотя бы одна команда, которая изменяет значение переменной. Тогда эта переменная также не может быть использована до инициализации. Инструкции, которые изменяют значение переменной — operator = , += и использование переменной в качестве цикла for параметра. Однако, даже если оператор change-variable никогда не выполняется, интерпретатор не может его проверить, и переменная остается локальной. Пример:

None

def f():
    print(a)
    if False:
        a = 0

a = 1
f()

Произошла ошибка: UnboundLocalError: local variable 'a' referenced before assignment . А именно, в функции f() идентификатор a становится локальной переменной, так как функция содержит команду, которая модифицирует переменную a . Инструкция по модификации никогда не будет выполнена, но интерпретатор не проверяет ее. Поэтому, когда вы пытаетесь распечатать переменную a , вы обращаетесь к неинициализированной локальной переменной.

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

None

def f():
    global a
    a = 1
    print(a)

a = 0
f()
print(a)

В этом примере будет напечатан вывод 1 1, потому что переменная a объявлена ​​глобальной, а ее изменение внутри функции вызывает ее изменение в глобальном масштабе.

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

Например, предположим, что ваша программа должна вычислить факториал данного номера, который вы хотите сохранить в переменной f. Вот как вы не должны этого делать:

5

def factorial(n):
    global f
    res = 1
    for i in range(2, n + 1):
        res *= i
    f = res

n = int(input())
factorial(n)
print(f)
# делать другие вещи с переменной f

Это пример плохого кода, потому что трудно использовать другое время. Если завтра вам понадобится другая программа для использования функции «factorial», вы не сможете просто скопировать эту функцию и вставить новую программу. Вам нужно будет убедиться, что эта программа не содержит переменную f .

Гораздо лучше переписать этот пример следующим образом:

5

# начало фрагмента кода, который можно скопировать из программы в программу
def factorial(n):
    res = 1
    for i in range(2, n + 1):
        res *= i
    return res
# конец фрагмента кода

n = int(input())
f = factorial(n)
print(f)
# делать другие вещи с переменной f

Полезно сказать, что функции могут возвращать более одного значения. Вот пример возврата списка из двух или более значений:

return [a, b]

Вы можете вызвать функцию такого списка и использовать его в нескольких назначениях:

n, m = f(a, b)

Как мы видели выше, функция может вызвать другую функцию. Но функции могут также называть себя! Чтобы проиллюстрировать это, рассмотрим пример факторно-вычислительной функции. Хорошо известно, что 0! = 1, 1! = 1. Как рассчитать значение n! для больших n? Если бы нам удалось вычислить значение (n-1) !, то мы легко вычислим n !, так как n! = N⋅ (n-1) !. Но как вычислить (n-1) !? Если мы вычислили (n-2) !, тогда (n-1)! = (N-1) ⋅ (n-2) !. Как рассчитать (n-2) !? Если … В итоге мы получаем 0 !, что равно 1. Таким образом, для вычисления факториала мы можем использовать значение факториала для меньшего целого числа. Этот расчет можно сделать с помощью Python:

None

def factorial(n):
    if n == 0:
        return 1
    else:
        return n * factorial(n - 1)

print(factorial(5))        

Ситуация, когда функция вызывает себя, называется рекурсией , и такая функция называется рекурсивной.

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

def f():
    return f()

Две наиболее распространенные причины, вызывающие бесконечную рекурсию:

1. Неправильное условие остановки. Например, если в факториал-калькуляционной программе мы забываем поставить проверку, if n == 0 , то factorial(0) вызовет factorial(-1) , который вызовет factorial(-2) и т. Д.
2. Рекурсивный вызов с неправильными параметрами. Например, если функция factorial(n) вызывает функцию factorial(n) , мы также получим бесконечную цепочку вызовов.

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

Модуль math — Питошка

Модуль math – один из наиважнейших в Python. Этот модуль предоставляет обширный функционал для работы с числами.

math.ceil(X) – округление до ближайшего большего числа.

math.copysign(X, Y) — возвращает число, имеющее модуль такой же, как и у числа X, а знак — как у числа Y.

math.fabs(X) — модуль X.

math.factorial(X) — факториал числа X.

math.floor(X) — округление вниз.

math.fmod(X, Y) — остаток от деления X на Y.

math.frexp(X) — возвращает мантиссу и экспоненту числа.

math.ldexp(X, I) — X * 2ⁱ. Функция, обратная функции math.frexp().

math.fsum(последовательность) — сумма всех членов последовательности. Эквивалент встроенной функции sum(), но math.fsum() более точна для чисел с плавающей точкой.

math.isfinite(X) — является ли X числом.

math.isinf(X) — является ли X бесконечностью.

math.isnan(X) — является ли X NaN (Not a Number — не число).

math.modf(X) — возвращает дробную и целую часть числа X. Оба числа имеют тот же знак, что и X.

math.trunc(X) — усекает значение X до целого.

math.exp(X) — e^X.

math.expm1(X) — e^X — 1. При X → 0 точнее, чем math.exp(X)-1.

math.log(X, [base]) — логарифм X по основанию base. Если base не указан, вычисляется натуральный логарифм.

math.log1p(X) — натуральный логарифм (1 + X). При X → 0 точнее, чем math.log(1+X).

math.log10(X) — логарифм X по основанию 10.

math.log2(X) — логарифм X по основанию 2. Новое в Python 3.3.

math.pow(X, Y) — X^Y.

math.sqrt(X) — квадратный корень из X.

math.acos(X) — арккосинус X. В радианах.

math.asin(X) — арксинус X. В радианах.

math.atan(X) — арктангенс X. В радианах.

math.atan2(Y, X) — арктангенс Y/X. В радианах. С учетом четверти, в которой находится точка (X, Y).

math.cos(X) — косинус X (X указывается в радианах).

math.sin(X) — синус X (X указывается в радианах).

math.tan(X) — тангенс X (X указывается в радианах).

math.hypot(X, Y) — вычисляет гипотенузу треугольника с катетами X и Y (math.sqrt(x * x + y * y)).

math.degrees(X) — конвертирует радианы в градусы.

math.radians(X) — конвертирует градусы в радианы.

math.cosh(X) — вычисляет гиперболический косинус.

math.sinh(X) — вычисляет гиперболический синус.

math.tanh(X) — вычисляет гиперболический тангенс.

math.acosh(X) — вычисляет обратный гиперболический косинус.

math.asinh(X) — вычисляет обратный гиперболический синус.

math.atanh(X) — вычисляет обратный гиперболический тангенс.

math.erf(X) — функция ошибок.

math.erfc(X) — дополнительная функция ошибок (1 — math.erf(X)).

math.gamma(X) — гамма-функция X.

math.lgamma(X) — натуральный логарифм гамма-функции X.

math.pi — pi = 3,1415926…

math.e — e = 2,718281…

numpy.cbrt () в Python — GeeksforGeeks

numpy.cbrt () в Python

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

 numpy.cbrt (arr, out = None, ufunc ‘cbrt’): 

Параметры:

  arr:   [array_like]  Входной массив или объект
        элементы которого нам нужно возвести в квадрат.
 

Возврат:

Массив с кубическим корнем из x для всех x i.е. элементы массива
 

Код # 1: Рабочий

Выход:

cbrt Значение arr1:
 [1. 30. 4. -10.]

cbrt Значение arr2: [10.0793684 -5.0396842]
 

Код # 2: Работа с комплексными числами

Выход:

  TypeError:  ufunc 'cbrt' не поддерживается для типов ввода,
и нельзя было безопасно привести входные данные к поддерживаемым
типы в соответствии с правилом литья 'safe' 

Код # 3: Графическое представление

Выход:

 
 Графическое представление :
 [-1.70997595 2.30347441 3,08793243 3,60027433 3,99768384 4,3287262
  4.61565763 4.87076238 5.10162421 5.31329285] 

Ссылки:
https://docs.scipy.org/doc/numpy-1.12.0/reference/generated/numpy.cbrt.html
.

Математическая функция Python | sqrt ()

Математическая функция Python | sqrt ()

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

  Синтаксис: 
  математика.sqrt (x) 

  Параметр: 
x - любое число такое, что x> = 0

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

Выход:

0,0
2.0
1,8708286933869707
 

Ошибка: Когда x <0, он не выполняется из-за ошибки времени выполнения.

Выход:

Отслеживание (последний вызов последний):
  Файл "/home/67438f8df14f0e41df1b55c6c21499ef.py", строка 8, в
    печать (math.sqrt (-1))
ValueError: ошибка математического домена
 

Практическое применение: Для данного числа проверьте, является ли оно простым или нет.
Подход: Выполните цикл от 2 до sqrt (n) и проверьте, делит ли какое-либо число в диапазоне (2-sqrt (n)) n.

Выход:

основной
 

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

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

# Получение квадратного корня в Python: три варианта

Квадратный корень числа — это некоторое значение, которое при умножении на само себя возвращает то же самое число (Wikipedia, 2019). Например, 5 x 5 = 25, поэтому квадратный корень 25 равен 5. Но -5 x -5 тоже 25, поэтому -5 также является квадратным корнем из 25.

Символ, который мы используем для получения квадратного корня, √, однако, всегда означает положительный квадратный корень. Итак, √16 равно 4 (а не -4).

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

• Функция math.sqrt () возвращает квадратный корень как точное значение с плавающей запятой. (Эта функция — то, что вам нужно в 95% случаев.)
• Функция math.isqrt () возвращает квадратный корень в виде целого числа (то есть с округлением до целого числа).
• И, когда мы возводим число в степень 0,5 , мы также получаем квадратный корень. Для этого мы можем использовать оператор экспоненты Python ( ** ) или функцию pow () .

Давайте посмотрим, как каждый подход работает в Python.

# Получите точный квадратный корень: функция Python

math.sqrt ()

Функция math.sqrt () возвращает точный квадратный корень из своего аргумента (Python Docs, n.d.). Итак, чтобы получить квадратный корень, мы просто передаем значение функции math.sqrt () .

Например:

  импорт математики

math.sqrt (12)
# Возвращает: 3,464101615137755
  

Математика Python .Функция sqrt () требует положительного значения. Если мы используем отрицательное значение, функция генерирует исключение ValueError . С помощью функции abs () вы можете убедиться, что функция работает с положительным значением.

# Пример: получить квадратный корень в Python с помощью

math.sqrt ()

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

  import math

# Некоторые значения
значениеA = 16
значениеB = 81
значениеC = 8301.430
значениеD = -98,25

# Получить квадратный корень из этих значений
sqrtA = math.sqrt (значениеA)
sqrtB = math.sqrt (значениеB)
sqrtC = math.sqrt (значениеC)
sqrtD = math.sqrt (абс (значениеD))

# Вывод результатов
print ("√", valueA, "=", sqrtA, sep = "")
print ("√", значениеB, "=", sqrtB, sep = "")
print ("√", valueC, "=", sqrtC, sep = "")
print ("√", abs (значениеD), "=", sqrtD, sep = "")
  

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

Затем мы вычисляем квадратный корень из каждого. Мы выполняем функцию math.sqrt () для каждой из переменных. Мы помещаем возвращенный квадратный корень в новую переменную для последующего использования (от sqrtA до sqrtD ). Мы используем функцию abs () для отрицательной переменной. Таким образом, math.sqrt () не ошибается.

Затем мы отображаем как исходное значение, так и его квадратный корень.Для этого мы несколько раз вызываем функцию Python print () . Вот что отображается:

  √16 = 4,0
√81 = 9,0
√8301,43 = 91,11218359802382
√98,25 = 9,3800799505
  

Квадратный корень — это все равно что спросить себя: «Какое значение мы можем умножить само на себя, чтобы получить такой результат?». Это умножение само по себе также называется возведением в квадрат. Другими словами, 3 в квадрате равно 9, и поэтому квадрат корень из 9 равен 3. Подробнее см. квадратные значения в Python

# Получение целочисленного квадратного корня: математика Python

.isqrt ()

Другой способ вычисления квадратного корня — использование функции math.isqrt () . Эта функция всегда возвращает целое число квадратный корень (Python Docs, n.d.). То есть функция возвращает квадратный корень значения, округленный до целого числа.

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

  импорт математики

math.isqrt (12)
# Возвращает: 3 (а не 3,464101615137755)
  

Математика Python .isqrt () требует аргумента, значение которого равно нулю или больше (Python Docs, n.d.). При отрицательном аргументе получаем ошибку Python. Используйте функцию Python abs () , чтобы убедиться, что math.isqrt () работает с неотрицательным значением.

# Пример: вычисление целочисленного квадратного корня в Python

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

  import math

# Некоторые значения
значениеA = 16
значениеB = 81
значениеC = 8301.430
значениеD = -98,25

# Получить целочисленный квадратный корень из этих значений
isqrtA = math.isqrt (значениеA)
isqrtB = math.isqrt (значениеB)
isqrtC = math.isqrt (значениеC)
isqrtD = math.isqrt (абс (значениеD))

# Вывод результатов
print ("√", valueA, "=", isqrtA, sep = "")
print ("√", значениеB, "=", isqrtB, sep = "")
print ("√", значениеC, "=", isqrtC, sep = "")
print ("√", abs (значениеD), "=", isqrtD, sep = "")
  

Сначала мы импортируем модуль math . Затем мы создаем четыре переменные со случайными значениями (от valueA, до valueD ). Здесь бывают целые числа и значения с плавающей запятой, а также положительные и отрицательные.

Затем мы получаем квадратный корень целого числа из этих значений. Для этого мы вызываем функцию math.isqrt () для каждой переменной. Возвращенный квадратный корень — это то, что мы сохраняем в новых переменных isqrtA – isqrtD .

Поскольку math.isqrt () не работает с отрицательными значениями, мы сначала оборачиваем переменную valueD внутри функции abs () .Это извлекает квадратный корень из абсолютного положительного значения.

Последний бит программы выводит исходный и целочисленный квадратный корень с функцией print () . Вот что это дает:

  √16 = 4
√81 = 9
√8301,43 = 91
√98,25 = 9
  

# Вычислить квадратные корни из значений списка Python

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

# Получение квадратного корня с помощью списка

Так называемое понимание списка — это первый способ получить квадратный корень из списка. Эти эффективные конструкции кода могут управлять целым списком значений с помощью одной строчки кода.

Вот пример:

  import math

# Некоторые случайные положительные значения
значения = [
    33, 81, 4,25,
    16, 55, 12
]

# Создать новый список с квадратными корнями
squareRoots = [math.sqrt (число) для числа в значениях]

# Выходные данные
print ("Исходные значения: \ n", значения)
print ("Их квадратные корни: \ n", squareRoots)  

Сначала мы импортируем модуль math .Это делает доступной функцию math.sqrt () . Затем составляем список ( значений, ) со случайными числами.

Затем мы составляем еще один список с именем squareRoots . Значения этого списка являются квадратными корнями из списка значений , и мы генерируем эти значения с пониманием списка. Этот код вызывает функцию math.sqrt () для каждой переменной number .

Переменная создается встроенным для выражения цикла : для числа в значениях .Это выполняет итерацию по всем элементам в списке значений и делает доступным по одному через переменную номер .

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

  Исходные значения:
 [33, 81, 4,25, 16, 55, 12]
Их квадратные корни:
 [5.744562646538029, 9,0, 2,0615528128088303, 4,0, 7,416198487095663, 3,4641016151377544]
  

Может ли ваш список содержать отрицательные значения? Тогда неплохо было бы также использовать функцию abs () . Таким образом вы предотвратите появление ошибки math.sqrt () . В этом случае список становится понятным:

  # Сгенерировать новый список с квадратным корнем из каждого числа
squareRoots = [math.sqrt (abs (число)) для числа в значениях]
  

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

  # Извлеките квадратный корень из каждого значения в 'values'
# list, перезаписывая исходный список
values ​​= [math.sqrt (значение) для значения в значениях]
  

# Получение квадратного корня с помощью обычного

для цикла

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

Вот как цикл для извлекает квадратный корень из списка:

  import math

# Некоторые случайные значения
числа = [
    12, 36, 45, 81,
    122, 234, 450, 992
]

# Создать новый список
sqrtNumbers = []

# Прокрутите список, извлеките квадратный корень из каждого
# значение, округленное до 2 знаков после запятой
для числа в числах:
    sqrtNumbers.append (круглый (math.sqrt (число), 2))

# Выходные данные
print ("Исходные значения: \ n", числа)
print ("Значения квадратного корня: \ n", sqrtNumbers)  

Сначала мы импортируем модуль math , чтобы получить math.sqrt () функция. Затем мы составляем список со случайными целыми числами. Этот список чисел — это то, из чего мы хотим получить квадратные корни.

Прежде чем мы это сделаем, мы сначала составим список, который будет содержать эти квадратные корни. Этот список sqrtNumbers изначально пуст ( [] ).

Затем мы обрабатываем список номеров с помощью цикла для . Во время каждого цикла цикла переменная number ссылается на одно значение из этого списка.

Внутри цикла мы добавляем новое значение в список sqrtNumbers с его методом append () .Это значение является квадратным корнем из переменной number , вычисленной с помощью функции math.sqrt () . Но прежде чем добавить это значение в список, мы сначала округляем его до двух десятичных знаков с помощью функции round () .

После того, как цикл выполнил эти задачи, у нас есть два списка: один с исходными значениями и квадратными корнями. Мы выводим оба значения с помощью функции print () :

  Исходные значения:
 [12, 36, 45, 81, 122, 234, 450, 992]
Значения квадратного корня:
 [3.46, 6,0, 6,71, 9,0, 11,05, 15,3, 21,21, 31,5]
  

Не нужно хранить исходный список? В этом случае вы можете перезаписать список его квадратными корнями. Полезной функцией для этого является функция Python enumerate () , которая генерирует как значение списка, так и его значение индекса. Например:

  # Просмотрите исходный список номеров и
# заменяем каждое число его квадратным корнем
для индекса, число в перечислении (числа):
    числа [индекс] = math.sqrt (число)
  

# Бонус: получить квадратный корень через возведение в степень

Математика Python .Функция sqrt () — это стандартный способ получения квадратного корня. Но знаете ли вы, что возведение значения в степень 0,5 также возвращает квадратный корень? Давайте взглянем.

# Получение квадратного корня в Python: оператор экспоненты (

** )

Первый способ поднять значение — использовать оператор экспоненты Python ( ** ). Когда мы вычисляем значение в степени 0,5 , результатом является квадратный корень. Например:

  12 ** 0.5
# Возвращает: 3,464101615137755
  

Выражение ** 0,5 возвращает квадратный корень, только если основание возведения в степень неотрицательно. (В противном случае вместо этого мы получим комплексное число.) Используйте функцию Python abs () , чтобы получить абсолютное положительное значение числа.

# Пример: вычисление квадратных корней с помощью оператора экспоненты

Итак, чтобы получить квадратный корень, мы просто возводим значение в степень 0,5 . Вот пример быстрой программы на Python:

  # Некоторые значения
значениеA = 16
значениеB = 81
значениеC = 8301.430
значениеD = -98,25

# Получить квадратный корень из этих значений
sqrtA = значениеA ** 0,5
sqrtB = значениеB ** 0,5
sqrtC = значениеC ** 0,5
sqrtD = abs (значениеD) ** 0,5

# Вывод результатов
print ("√", valueA, "=", sqrtA, sep = "")
print ("√", значениеB, "=", sqrtB, sep = "")
print ("√", valueC, "=", sqrtC, sep = "")
print ("√", abs (значениеD), "=", sqrtD, sep = "")
  

Сначала мы создадим здесь четыре разные переменные (значение A, — значение D ). Каждому присваивается случайное значение. У нас есть положительные и отрицательные, а также целые числа и значения с плавающей запятой.

Затем мы получаем квадратный корень из каждого. Для этого мы возводим каждое значение в степень 0,5 . Поскольку значение valueD отрицательно, мы сначала получаем абсолютное значение и , а затем возведение в степень . В противном случае мы получили бы комплексное число, а не квадратный корень. Мы сохраняем результаты в четырех новых переменных (от sqrtA до sqrtD ).

Последний бит кода выводит результаты. Для этого мы многократно вызываем функцию Python print () .Вот как выглядит этот вывод:

  √16 = 4,0
√81 = 9,0
√8301,43 = 91,11218359802382
√98,25 = 9,3800799505
  

# Вычислить квадратный корень в Python: функция

pow ()

Другой способ поднять значение до определенной степени — использовать функцию Python pow () . Эта функция принимает два аргумента: основание и показатель степени. Когда второй равен 0,5 , pow () возвращает квадратный корень. Например:

  pow (12, 0.5)
# Возвращает: 3,464101615137755
  

# Пример: вычислить квадратные корни с помощью функции

pow ()

Итак, для получения квадратного корня мы возводим в степень 0,5 с помощью pow () . Вот как это работает в программе Python:

  # Некоторые значения
значениеA = 16
значениеB = 81
значениеC = 8301,430
значениеD = -98,25

# Получить квадратный корень из этих значений
sqrtA = pow (значениеA, 0,5)
sqrtB = pow (значениеB, 0,5)
sqrtC = pow (значениеC, 0,5)
sqrtD = pow (значениеD, 0.5)

# Вывод результатов
print ("√", valueA, "=", sqrtA, sep = "")
print ("√", значениеB, "=", sqrtB, sep = "")
print ("√", valueC, "=", sqrtC, sep = "")
print ("√", abs (значениеD), "=", abs (sqrtD), sep = "")
  

Сначала мы делаем четыре переменные. Мы называем эти значения A от до valueD .

Затем мы получаем квадратный корень из них. Для этого мы вызываем функцию pow () с двумя аргументами. Первая — это переменная, из которой мы хотим получить квадратный корень. Второй — 0.5 . Мы помещаем результаты этого возведения в степень в переменных с sqrtA до sqrtD .

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

  √16 = 4,0
√81 = 9,0
√8301,43 = 91,11218359802382
√98,25 = 9,3800799505
  

# Сводка

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

Первый и самый простой вариант — это функция math.sqrt () , которая возвращает квадратный корень из своего аргумента. Эта функция выдает ошибку с отрицательными значениями. В этих случаях мы вызываем функцию abs () , чтобы сначала получить абсолютное значение.

Мы также можем вычислить квадратный корень, возведя число в степень 0,5 . Для этого возведения в степень мы используем функцию Python pow () или оператор экспоненты ( ** ).

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

Опубликовано 20 декабря 2019 г. . «Все математические статьи Python

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

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

Давайте посмотрим, как это сделать.

1. Использование экспоненты

число = int (input («введите число:»))
sqrt = число ** 0.5
print («квадратный корень:», sqrt)

Выход:

введите число: 64
квадратный корень: 8.0

В приведенной выше программе сначала мы берем число от пользователя в качестве ввода, а введенное значение будет преобразовано в int из строки и сохранится в переменной с именем number. Затем мы используем знак экспоненты (**), который используется для определения степени числа. Но мы знаем, что если число имеет степень ½ или 0,5, то оно представляет собой квадратный корень из этого числа. Вот почему здесь мы используем 0,5 в качестве мощности. Таким образом, число ** 0,5 даст нам квадратный корень из этого числа и будет сохранено в переменной с именем sqrt. В последней строке мы просто печатаем квадратный корень из числа.

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

импорт математики
number = int (input («введите число:»))
sqrt = math.sqrt (число)
print («квадратный корень:», sqrt)

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

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

импорт математики
number = int (input («введите число:»))
sqrt = math.pow (число, 0,5)
print («квадратный корень:», sqrt)

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

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

3 Примеры функции Python квадратного корня (SQRT) из Math

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

Значение x должно быть больше 0.

Пример квадратного корня

Синтаксис использования функции sqrt

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

математ.sqrt (х)

Например:

math.sqrt (25)

Метод sqrt возвращает квадратный корень из заданного числа, которое должно быть больше 0.

Обратите внимание, что по умолчанию математические функции возвращают значения с плавающей запятой.

Пример получения квадратного корня

В этом примере программа Python написана для получения квадратного корня из 9, 25, 81, 90 и 100 чисел. Смотрите код и вывод:

См. Онлайн-демонстрацию и код

Пример использования отрицательного числа

Что, если мы предоставим число меньше 0, т.е. отрицательное число? См. Этот пример, где для функции sqrt () предоставлено значение -25:

См. Онлайн-демонстрацию и код

Как видите, генерируется ошибка ValueError: ошибка математического домена .

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

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

См. Онлайн-демонстрацию и код

Примечание: Если вы введете строку, обработчик ошибок остановит выполнение, и отобразится сообщение для ввода числа.

Как найти квадратный корень в Python | Использование sqrt () и pow ()

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

Прежде чем двигаться дальше, давайте взглянем на темы, затронутые здесь:

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

Квадратный корень — это любое число y такое, что x ² = y . Математически это представлено как x = √y . Python предоставляет встроенные методы для вычисления квадратных корней.

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

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

Чтобы вычислить квадратные корни в Python , вам необходимо импортировать модуль math . Этот модуль состоит из встроенных методов, а именно sqrt () и pow () , с помощью которых вы можете вычислить квадратные корни. Вы можете импортировать его, просто используя ключевое слово import следующим образом:

 import math 

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

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

Функция sqrt () обычно принимает один параметр и возвращает из него квадратный корень. Синтаксис этой функции:

SYNTAX:

sqrt (x) # x — число, квадратный корень которого необходимо вычислить.

Теперь давайте посмотрим на пример этой функции:

ПРИМЕР:

 from math import sqrt #absolute importing
print (sqrt (25)) 

ВЫХОД: 5.0

Как видите, квадратный корень из 25, т.е. 5, был возвращен.

ПРИМЕЧАНИЕ: В приведенном выше примере функция sqrt () была импортирована абсолютным методом. Однако, если вы импортируете полный математический модуль, вы можете выполнить то же самое, как показано ниже:

ПРИМЕР:

 import math
print (math.sqrt (25)) 

ВЫХОД: 5.0

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

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

x ² = y или y = x **. 5

Синтаксис этой функции следующий:

SYNTAX:

pow (x, y) # где y — степень x или x ** y

Теперь давайте посмотрим на пример этой функции:

ПРИМЕР:

 from math import pow
print (pow (25 ,.5)) 

ВЫХОД: 5.0

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

Рабочий пример квадратного корня в Python

Давайте попробуем реализовать очень известную теорему Пифагора , используя эти функции.

Постановка задачи:

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

Решение:

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

c = √ (a2 + b2) # где c — гипотенуза

Вот решение на Python:

 из math import sqrt # Импортирована функция квадратного корня из математического модуля
from math import pow # Импортирована степенная функция из математического модуля

a = int (input ("Введите размер одной стороны прямоугольного треугольника:"))
b = int (input ("Введите размер другой стороны прямоугольного треугольника:"))
#input функция используется для ввода данных от пользователя и хранится в виде строки
# которое затем преобразуется в целое число с помощью функции int ().c = sqrt (pow (a, 2) + pow (b, 2)) # мы реализовали формулу c = √ (a2 + b2)
print (f "Измерение гипотенузы: {c} основано на измерениях двух других сторон {a} и {b}")
 

ВЫХОД:

Введите размер одной стороны прямоугольного треугольника: 3
Введите размер другой стороны прямоугольного треугольника: 4

Мера гипотенузы: 5,0 на основе меры двух других сторон 3 и 4

На этом мы подошли к концу статьи о квадратном корне в Python.Надеюсь, вы все ясно поняли.

Убедитесь, что вы как можно больше тренируетесь, и вернитесь к своему опыту.

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

Есть к нам вопрос? Пожалуйста, укажите это в разделе комментариев этого блога «Квадратный корень в Python», и мы свяжемся с вами как можно скорее.

Python 3 Примечания: импорт модулей

>>> импорт математики
>>> dir (математика)
['__doc__', '__loader__', '__name__', '__package__', '__spec__', 'acos', 'acosh', 'asin',
'asinh', 'atan', 'atan2', 'atanh', 'ceil', 'copysign', 'cos', 'cosh', 'градусы', 'e', ​​'erf',
erfc, exp, expm1, fabs, factorial, floor, fmod, frexp, fsum, gamma,
'gcd', 'hypot', 'inf', 'isclose', 'isfinite', 'isinf', 'isnan', 'ldexp', 'lgamma', 'журнал',
'log10', 'log1p', 'log2', 'modf', 'nan', 'pi', 'pow', 'радианы', 'sin', 'sinh', 'sqrt',
'tan', 'tanh', 'trunc']
>>>
 

>>> sqrt (256)
Отслеживание (последний вызов последний):
  Файл "", строка 1, в
    sqrt (256)
NameError: имя sqrt не определено
>>> math.sqrt (256)
16.0
>>> math.sqrt (3849458582)
62044.005205982634
>>>
 

>>> импорт случайный
>>> dir (случайный)
['BPF', 'LOG4', 'NV_MAGICCONST', 'RECIP_BPF', 'Случайный', 'SG_MAGICCONST', 'SystemRandom',
TWOPI, _BuiltinMethodType, _MethodType, _Sequence, _Set, __all__, __builtins__,
'__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__',
_acos, _ceil, _cos, _e, _exp, _inst, _log, _pi, _random, _sha512, _sin,
_sqrt, _test, _test_generator, _urandom, _warn, betavariate, choice, expovariate,
'gammavariate', 'gauss', 'getrandbits', 'getstate', 'lognormvariate', 'normalvariate',
'paretovariate', 'randint', 'random', 'randrange', 'sample', 'seed', 'setstate', 'перемешать',
"треугольная", "однородная", "vonmisesvariate", "weibullvariate"]
>>>
 

>>> справка (random.choice)
Помощь по выбору метода в модуле random:

выбор (seq) метод экземпляра random.Random
    Выберите случайный элемент из непустой последовательности.>>> random.choice ([1,2,3,4,5])
2
>>> random.choice ([1,2,3,4,5])
5
 

>>> adj = ['счастливый', 'грустный', 'любопытный', 'зеленый', 'бесцветный', 'злой']
>>> n = ['идеи', 'пингвины', 'панды', 'любовь', 'профессора']
>>> random.choice (прил.) + "" + random.выбор (n)
'грустные панды'
>>> random.choice (прил.) + "" + random.choice (n)
"зеленые профессора"
>>> random.choice (прил.) + "" + random.choice (n)
'печальная любовь'
>>>
 

>>> import nltk
>>> нлтк.word_tokenize («Где-то 5 часов.»)
['It', "s", '5', "o'clock", 'где-то', '.']
>>>
 

 >>> из случайного выбора импорта
 >>> выбор ([1,2,3,4,5])
 4
 >>> справка (случайный.
No related posts.
 Share :
 
Добавить комментарий Отменить ответ
Ваш адрес email не будет опубликован. Обязательные поля помечены *
Комментарий *
Имя * 
Email * 
Сайт