Корень числа в питоне: Python 3 для начинающих | Уроки на Python Teach

Содержание

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

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

в большую или меньшую сторону — До целого или до сотых (2 заков)

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

Для этого программист может использовать различные инструменты, такие как встроенная функция round(), преобразование к типу int и функции из подключаемого модуля math.

Способы округления чисел

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

Если используется стандартная библиотека math, то в начале кода её необходимо подключить. Сделать это можно, например, с помощью инструкции: import math.

math.ceil() – округление чисел в большую сторону

Функция получила своё имя от термина «ceiling», который используется в математике для описания числа, которое больше или равно заданному.

Любая дробь находится в целочисленном интервале, например, 1.2 лежит между 1 и 2. Функция ceil() определяет, какая из границ интервала наибольшая и записывает её в результат округления.

Пример:

math.ceil(5.15) # = 6
math.ceil(6.666) # = 7
math.ceil(5) # = 5

Важно помнить, что функция определяет наибольшее число с учётом знака. То есть результатом округления числа -0.9 будет 0, а не -1.

math.floor() – округление чисел в меньшую сторону

Функция округляет дробное число до ближайшего целого, которое меньше или равно исходному. Работает аналогично функции ceil(), но с округлением в противоположную сторону.

Пример:

math.floor(7.9) # = 7
math.floor(9.999) # = 9
math.floor(-6.1) # = -7

math.trunc() – отбрасывание дробной части

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

Примеры:

math.trunc(5.51) # = 5
math.trunc(-6.99) # = -6

Избавиться от дробной части можно с помощью обычного преобразования числа к типу int. Такой способ полностью эквивалентен использованию trunc().

Примеры:

int(5.51) # = 5
int(-6.99) # = -6

Нормальное округление

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

И хотя int() работает по другому алгоритму, результат её использования для положительных чисел полностью аналогичен выводу функции floor(), которая округляет числа «вниз». Для отрицательных аналогичен функции ceil().

Примеры:

math.floor(9.999) # = 9
int(9.999) # = 9
math.ceil(-9.999) # = -9
int(-9.999) # = -9

Чтобы с помощью функции int() округлить число по математическим правилам, необходимо добавить к нему 0.5, если оно положительное, и -0.5, если оно отрицательное.

Тогда операция принимает такой вид: int(num + (0.5 if num > 0 else -0.5)). Чтобы каждый раз не писать условие, удобно сделать отдельную функцию:

def int_r(num):
    num = int(num + (0.5 if num > 0 else -0.5))
    return num

Функция работает также, как стандартная функция округление во второй версии Python (арифметическое округление).

Примеры:

int_r(11.5) # = 12
int_r(11.4) # = 11
int_r(-0.991) # = -1
int_r(1.391) # = 1

round() – округление чисел

round() – стандартная функция округления в языке Python. Она не всегда работает так, как ожидается, а её алгоритм различается в разных версиях Python.

В Python 2

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

Увеличение погрешности вызвано неравным количеством цифр, определяющих, в какую сторону округлять. Всего 4 цифры на конце приводят к округлению «вниз», и 5 цифр к округлению «вверх».

Помимо этого, могут быть неточности, например, если округлить число 2.675 до второго знака, получится число 2.67 вместо 2.68. Это происходит из-за невозможности точно представить десятичные числа типа «float» в двоичном коде.

В Python 3

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

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

Примеры:

round(3.5) # = 4
round(9.5) # = 10
round(6.5) # = 6
round(-6.5) # = -6
round(-7.5) # = -8

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

Округление до сотых

У функции raund() есть ещё один аргумент. Он показывает до какого количества знаков после запятой следует округлять. Таким образом, если нам надо в Python округлить до сотых, этому параметру следует задать значение 2.

Пример округления до нужного знака:

round(3.555, 2) # = 3.56
round(9.515,1) # = 9.5
round(6.657,2) # = 6.66

Ошибки округления и модуль decimal

При округлении функцией round(), можно получить следующее:

round(2.65, 1) # = 2.6
round(2.85, 1) # = 2.9

Почему в одном случае округляется вниз, а в другом вверх? При переводе 2.85 в двоичную систему получается число, которое немного больше. Поэтому функция видит не «5», а «>5» и округляет вверх.

Проблему неточного представления чисел отлично иллюстрирует пример:

print (0.1 + 0.1 + 0.1)

0.30000000000000004

Из-за подобных ошибок числа типа «float» нельзя использовать там, где изменения значения на одну тысячную может привести к неверному результату. Решить данную проблему поможет модуль decimal.

decimal — модуль, позволяющий округлять десятичные дроби с почти 100% точностью. Его основной принцип: компьютер должен считать так, как считает человек. Речь идёт не о скорости вычисления, а о точности и отсутствии проблем неправильного представления чисел.

Python 3 - Числа | ИТ Блог. Администрирование серверов на основе Linux (Ubuntu, Debian, CentOS, openSUSE)

Числовые типы данных хранят числовые значения. Они неизменные типы данных.

Количество объектов создаются при присвоении значения для них. Например:

var1 = 1
var2 = 10

 

Вы также можете удалить ссылку на объект номер с помощью заявление del. Синтаксис утверждения del:

del var1[,var2[,var3[....,varN]]]]

 

Вы можете удалить один или несколько объектов с помощью заявление del. Например:

del var
del var_a, var_b

 

Python поддерживает различные числовые типы:

  • Int (целые числа): Их часто называют просто целыми числами или ints. Они положительные или отрицательные целые числа, не имеющие знака после запятой. Целые числа в Python 3, неограниченного размера. Python 2 имеет два целочисленных типа: Int и long. Там больше нет  ‘long integer‘ в Python.
  • float (реальные значения с плавающей точкой): также называемые float, они представляют собой действительные числа и записываются с десятичной точкой, отделяющей целое число от дробные части. float могут быть также в научной записи, с Е или е, указывающей мощность  в 10 (2.5e2 = 2,5 × 10 2 = 250).
  • complex (комплексные числа): имеют вид A + BJ, где А и В являются float и J (или J) представляет собой корень квадратный из -1 (который является мнимым числом). Действительная часть числа является A, а мнимая часть B. Комплексные числа не используются часто в программировании на Python.

Представить целое число в гекса-десятичной или восьмеричной форме

>>> number = 0xA0F #Hexa-decimal
>>> number
2575

>>> number = 0o37 #Octal
>>> number
31

 

Примеры

Вот некоторые примеры чисел.

int float complex
10 0.0 3.14j
100 34.20 45.j
-786 -21.9 9.345e-36j
345 32.3+e18 .876j
-0490 -90. -.6546+0J
-0×450 -32.45e100 3e+26J
0×69 32.2-E12 4.67e-7j

Комплексное число состоит из упорядоченной пары действительных чисел с плавающей точкой, помеченных a + bj, где а действительная часть и б является мнимой частью комплексного числа.

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

  • Тип int(х) для преобразования х в простое целое.
  • Тип long(х) для преобразования х в длинное целое число.
  • Тип float(х) для преобразования х в число с плавающей точкой.
  • Тип complex(х) для преобразования х в комплексное число с вещественной частью х и мнимой частью нуля.
  • Тип complex(х, у) для преобразования х и у в комплексное число с вещественной частью х и мнимой части у. х и у являются числовыми выражениями

Математические функции

Python включает в себя следующие функции, которые выполняют математические расчеты.

S.No. Функция & Возвращает (Описание)
1 abs(х) – Абсолютное значение х: (положительное) расстояние между x и нулем.
2 ceil(х) – Наименьшее целое число не меньше, чем х.
3 cmp(х, у) – 1, если х <у, 0, если х == у, или 1, если х> у. Запрещены в Python 3. Вместо использования возврата (х> у): (х <у) .
4 ехр(х) – Экспоненциальный х: е х
5 fabs(х) – Абсолютное значение х.
6 flor(х) – Наибольшее целое число, не большее, чем х.
7 log(х) – Натуральный логарифм х, при х> 0.
8 log10(х) – По основанию 10 логарифм х при х> 0.
9 max(x1, x2, …) – Самый большой из своих аргументов: значение ближе к положительной бесконечности
10 min(X1, x2, …) – Самый маленький из его аргументов: значение ближе к отрицательной бесконечности.
11 modf(х) – Дробные и целые части х в два-элемента кортежа а. Обе части имеют один и тот же знак, что и х. Целая часть возвращается в виде float.
12 pow(х, у) – Значение х ** у.
13 round(х [n]) – х округляется до n цифр от десятичной запятой. Python, округляет от нуля в качестве связующего выключателя: round(0.5) составляет 1,0 и round(-0,5) является: 1,0.
14 sqrt(х) – Квадратный корень из х при х> 0.

Функции случайного числа

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

S.No. Описание функции
1 choice(seq) – Случайный элемент из списка, кортежа или строки.
2 randrange([start,] stop [,step]) – Случайно выбранный элемент из range(start, stop, step).
3 random() – Случайное плавающее число r, такие, что 0 меньше или равен r и r меньше, чем 1
4 seed([х]) – Задает значение целого числа, начиная используемое в генерации случайных чисел. Вызывайте эту функцию перед вызовом любой другой функции случайного модуля. Возвращает no.
5 shuffle(lst) – Рандомизация числа из списка на месте. Возвращает no.
6 uniform(х, у) – Случайное плавающее число r, так, что х меньше или равен r и r меньше, чем у.

Тригонометрические функции

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

S.No. Описание функции
1 acos(х) – Возвращает арккосинус х, в радианах.
2 asin(х) – Возвращает арксинус х, в радианах.
3 atan(х) – Возвращает арктангенс х, в радианах.
4 atan2(у, х) – Возврат atan(у/х), в радианах.
5 cos(х) – Возвращает косинус х радианах.
6 hypot(х, у) – Возвращение евклидовую норму, sqrt(х * х + у * у).
7 sin(х) – Возвращает синус х радианах.
8 tan(х) – Возвращает тангенс х радианах.
9 degrees(х) – Преобразование угол х из радиан в градусы.
10 radians(х) – Преобразование угол х из градусов в радианы.

Математические константы

Модуль также определяет две математические константы:

S.No. Константы и описание
1 pi – Математическая константа пи.
2 e – Математическая константа е.

 

Если вы нашли ошибку, пожалуйста, выделите фрагмент текста и нажмите Ctrl+Enter.

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

кажется, вы можете проверить вот так:

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

обновление:

как вы указали выше не для больших значений n. Для тех, кто выглядит многообещающим, что является адаптацией кода примера C, Martin Guy @ 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)

Модуль math | Python 3 для начинающих и чайников

Модуль 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 * 2i. Функция, обратная функции 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) - eX.

math.expm1(X) - eX - 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) - XY.

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...

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

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

К концу этой статьи вы узнаете:

  • Что такое квадратный корень
  • Как использовать функцию квадратного корня Python, sqrt ()
  • Когда sqrt () может быть полезным в реальном мире

Погружаемся!

Python Pit Stop: Это руководство представляет собой быстрый и практический способ найти нужную информацию, так что вы сразу же вернетесь к своему проекту!

Квадратные корни в математике

В алгебре квадрат , x , является результатом умножения числа n на само себя: x = n²

Вы можете вычислить квадраты с помощью Python:

>>>
  >>> п = 5
>>> х = п ** 2
>>> х
25
  

Оператор Python ** используется для вычисления степени числа.В этом случае 5 в квадрате или 5 в степени 2 дает 25.

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

В этом примере n , квадратный корень, равен 5.

25 - это пример полного квадрата . Совершенные квадраты - это квадраты целых чисел:

>>>
  >>> 1 ** 2
1

>>> 2 ** 2
4

>>> 3 ** 2
9
  

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

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

К счастью, как разработчик Python, у вас есть калькулятор, а именно интерпретатор Python!

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

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

Вы начнете с импорта math :

Вот и все, что нужно! Теперь вы можете использовать math.sqrt () для вычисления квадратных корней.

sqrt () имеет простой интерфейс.

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

Возвращаемое значение sqrt () - это квадратный корень из x в виде числа с плавающей запятой. В примере это будет 5.0 .

Давайте рассмотрим несколько примеров того, как использовать (и как не использовать) sqrt () .

Python: поиск квадратного корня с использованием алгоритма предположения и проверки

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

. 7 января 2013 г. - 5 минут на чтение -

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

Как следует из этого термина, сначала мы делаем предположение, а затем проверяем на соответствие известному условию (в зависимости от проблемы).Мы повторяем это в цикле, пока не получим ответ.

Перед нами стоит задача найти квадратный корень из любого числа.

Прежде чем перейти к идеальному решению, давайте попробуем найти решение более простой проблемы. Как насчет того, чтобы найти квадратный корень из полного квадрата. Такие числа, как 4, 9, 16, 25… точные квадраты.

  
 1
2
3
4
5
 
 x = int (raw_input ('Введите полный квадрат:'))
guess = 0 # Наш предположительный ответ
а угадайте ** 2  

Анализ вышеуказанного кода:

  • Мы объявляем guess как наш ответ и инициализируем его как 0
  • Продолжаем цикл до тех пор, пока квадрат угадать меньше x
  • Как только квадрат guess равен или превышает x , мы прерываем цикл и печатаем значение guess

Попробуйте это сделать с числами, такими как 25, 144 или любым другим точным квадратом.

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

abs () - возвращает абсолютное значение любого числа. Вы все любите видеть примеры, не так ли?

  >>> абс (10)
10
>>> абс (-10)
10
>>> абс (10.11)
10.11
>>> абс (-10,11)
10.11
>>> абс (0,003)
0.003
>>> абс (-0,003)
0,003  

Теперь все готово!

  
 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
 x = int (raw_input ('Введите число:'))
guess = 0.0 # Предполагаемый ответ
epsilon = 0,01 # Используется для точности. См. Условие в цикле пока
step = epsilon ** 2 # используется для увеличения нашего предположения 'ans'
total_guesses = 0
# Мы разберемся с этим условием во время анализа кода
while (abs (guess ** 2 - x))> = epsilon:
    угадать + = шаг
    total_guesses + = 1

print ('Всего предположений было' + str (total_guesses))
если абс (угадать ** 2-х)> = эпсилон:
    print ('Ошибка при извлечении квадратного корня из' + str (x))
еще:
    print (str (guess) + 'близок к квадратному корню из' + str (x))
 

Анализ вышеуказанного кода:

  • epsilon - это переменная, которая поможет нам проверить условие, близки ли мы к нашему ответу
  • шаг - переменная, на которую мы будем увеличивать наше предположение внутри цикла
  • Условие в цикле while проверяет, близко ли наше предположение к ответу.Например, если мы должны найти квадратный корень из 16 и если наше предположение равно 4, то предположение ** 2-x приведет к 4 ** 2 - 16 , т.е. 0. Здесь мы просто пытаемся приблизиться к насколько это возможно для окончательного ответа, поэтому просто проверяем, не превышает ли предел ошибки значение эпсилон

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

  Введите число: 2
Всего предположений было 14107
1,4107 близко к квадратному корню из 2
---------------------------------------
Введите число: 4
Всего предположений было 19975
1.9975 близко к квадратному корню из 4
---------------------------------------
Введите число: 7
Всего предположений было 26439
2,6439 близко к квадратному корню из 7
---------------------------------------
Введите число: 144
Всего предположений 119996
11,9996 близко к квадратному корню из 144  

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

  Введите число: 1000000
Всего предположений 10000000
999.999999821 близко к квадратному корню из 1000000
-------------------------------------------------- -
Введите число: 100000000
... Он работает слишком долго ...  

Как найти квадратный корень из очень больших чисел? Целых 1000000000! Всегда есть возможности для оптимизации. Рекомендуется прочитать о двоичном поиске, прежде чем продолжить.

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

  
 1
2
3
4
5
6
7
8
9
10
11
12
 
 x = int (raw_input ('Введите число:'))
эпсилон = 0.01
left = 0
право = х
угадать = (вправо + влево) /2.0
в то время как абс (угадайте ** 2 - x)>:
    если угадайте ** 2  

Попробуйте найти квадратный корень из 1000000000, он будет работать намного быстрее, чем предыдущий код. Бывают случаи, когда этот код не срабатывает, случаи, когда x является дробным числом от 0 до 1 или когда x отрицательно. Если вам интересно, опубликуйте исправление в комментариях.

Up next - это один из самых важных методов программирования, рекурсия.


Примечание: Это часть того, что я узнал в онлайн-программе Open Course Ware, предлагаемой MIT на edX. Это для моей личной справки, а также для тех, кто хотел бы вернуться к курсу.

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

Вычисление квадратного корня числа с использованием метода Ньютона-Рафсона [Практическое руководство]

@ suraj-regmi Suraj Regmi

Data Scientist, Всемирный банк - взгляды и содержание здесь являются моими собственными, а не моих работодателей.

Ситуации

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

Легко?

Хорошо, легко. У нас есть встроенные функции (или команды / кнопки) в наших калькуляторах, компьютерах, языках программирования, мобильных телефонах и везде для вычисления квадратного корня.Да, это можно сделать простым способом. Но что, если вы находитесь в месте, где нет электричества, а ваши гаджеты мертвы?

Помогите мне…

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

Алгоритм

  1. Возьмите разумное предположение (приблизительный корень) для квадратного корня.
  2. Сложите приблизительный корень с исходным числом, разделенным на приблизительный корень, и разделите на 2.
    x_i: = (x_i + n / x_i) / 2
  3. Продолжайте шаг 2, пока не будет разница в приблизительном корне на итерациях. меньше желаемого значения (или значения точности).
  4. Приблизительный корень - это квадратный корень, который нам нужен.

Демонстрация интерактивной доски

Давайте посмотрим на нее теперь на доске с n = 4 .

Рис. Метод Ньютона для вычисления квадратного корня из 4

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

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

Python

  def mySqrt (x):

    г = х
    точность = 10 ** (-10)
    
    в то время как abs (x - r * r)> точность:
        г = (г + х / г) / 2
        
    return r  

Почему вы не внедрили это в свою систему?

Метод Ньютона

Метод Ньютона, также известный как метод Ньютона-Рафсона, представляет собой алгоритм поиска корней, который последовательно дает более точные приближения корней вещественнозначной функции. Аппроксимация корня выглядит следующим образом:

x_ (n + 1) = x_n - f (x_n) / f '(x_n)

x_0 - это грубое приближение корня, сделанное в первом и последующем приближения идут как x_1, x_2,….

f (x_n) - это функция, корень которой должен быть определен, а f ’(x_n) - это производная функции.

Описание

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

Уравнение прямой с уклоном м , проходящей через (x_1, y_1) , будет:
y - y_1 = m (x - x_1)

Здесь тангенс - это прямая, производная, f '(x_n) - наклон, а (x_n, f (x_n)) - точка.

Итак, y - f (x_n) = f '(x_n) (x - x_n)

Поскольку лучшим приближением будет пересечение с x касательной, положите y = 0 и решите для х_н .

-f (x_n) = f '(x_n) (x - x_n)
or, x - x_n = -f (x_n) / f' (x_n)
Итак, x = x_n - f (x_n ) / f '(x_n) ………………. (1)

Это метод Ньютона для аппроксимации корня функции f (x).

Давайте теперь посмотрим, сможем ли мы придумать алгоритм, представленный выше, с использованием общей формулы.

Метод Ньютона для вычисления квадратного корня

Если нам нужно найти квадратный корень из числа n , функция будет иметь вид f (x) = x² - N , и нам нужно будет найти корень из числа функция, f (x).

Здесь значение f (x_n) при x = x_n составляет:
f (x_n) = x_n² - N

И производная в точке:
f '(x_n) = 2 * x_n

Теперь лучшее приближение можно найти с помощью (1).

x_ (n + 1) = x_n - (x_n² - N) / (2 * x_n)
x_ (n + 1) = x_n - x_n² / (2 * x_n) + N / (2 * x_n)
x_ (n + 1) = x_n - x_n / 2+ N / (2 * x_n)
x_ (n + 1) = x_n / 2+ N / (2 * x_n)
x_ (n + 1) = ( x_n + N / x_n) / 2

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

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

Целочисленный квадратный корень из числа - это нижний предел квадратного корня. Алгоритм можно немного изменить, чтобы найти целочисленный квадратный корень из числа.Условие и здесь будет приблизительное * приблизительное > N . Алгоритм завершается, когда приблизительный квадрат меньше или равен N.

Итерационное соотношение здесь:
x_ (n + 1) = (x_n + N // x_n) // 2,
где // - целочисленное деление.

Доказательство правильности

Во-первых, давайте докажем правильность для условия while.

Итерационное отношение:
x_ (n + 1) = (x_n + N // x_n) // 2

Его можно записать как:
x_ (n + 1) = floor ((x_n + N / x_n) / 2)

Для a ≥ 0 и b ≥ 0, a + b ≥ 2 * sqrt (a * b) .
Итак, x_ (n + 1) ≥ floor (2 * sqrt (x_n * N / x_n) / 2)
или, x_ (n + 1) ≥ floor (sqrt (N))
Итак, x_ (n + 1) ≥ intsqrt (N)

Следовательно, значение аппроксимации никогда не опускается ниже значения intsqrt (N) .

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

Найдем разницу x_ (n + 1) - x_n.

x_ (n + 1) - x_n = (x_n + N // x_n) // 2 - x_n

As N // x_n меньше или равно x_n (на основе условия while ),
(x_n + N // x_n) // 2 ≤ (2 * x_n) // 2

Итак, x_ (n + 1) - x_n ≤ (2 * x_n) // 2 - x_n

Поскольку x_n является целым числом, (2 * x_n) // 2 = x_n.
то есть x_ (n + 1) - x_n ≤ x_n - x_n
Итак, x_ (n + 1) -x_n ≤ 0

Следовательно, последовательность {x_n} монотонно убывает.

Значения x_ (n + 1) и x_n равны только тогда, когда N // x_n равно x_n , и именно тогда мы находим решение и цикл while останавливается. Во всех остальных случаях последовательность {x_n} строго убывает.

Таким образом, корректность алгоритма вычисления целого квадратного корня доказана.

Численный анализ - EndNote

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

Это пример численного анализа, в котором мы используем метод Ньютона для вычисления корня функции. В числовом анализе меня волнуют две вещи.

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

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

Связанные
Теги
Присоединяйтесь к Hacker Noon

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

Найдите среднее и стандартное отклонение в Python

Среднее и стандартное отклонение - два важных показателя в статистике.

  • Среднее значение - это сумма всех записей, разделенная на количество записей.
  • Стандартное отклонение - это мера степени вариации или разброса набора значений.

Давайте посмотрим на шаги, необходимые для вычисления среднего и стандартного отклонения.

Шаги для расчета среднего

  1. Возьмите сумму всех записей .
  2. Разделите сумму на количество записей .

Этапы расчета стандартного отклонения

  1. Рассчитайте среднее значение , как описано выше.
  2. Вычислить отклонение для каждой записи путем вычитания среднего значения из значения записи.Затем возведите в квадрат каждое из полученных значений и просуммируйте результаты. Затем разделите результат на количество точек данных минус один. Это даст дисперсию .
  3. Затем квадратный корень из дисперсии (рассчитанный выше) используется для определения стандартного отклонения.

Несколько методов для поиска среднего и стандартного отклонения в Python

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

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

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

Начнем с импорта модуля.

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

Давайте объявим массив с фиктивными данными.

данные = [7,5,4,9,12,45]
 

Теперь, чтобы вычислить среднее значение выборки данных, используйте:

статистика.среднее (данные)
 

Этот оператор вернет среднее значение данных. Мы можем вывести среднее значение на выходе, используя:

print ("Среднее значение выборки% s"% (statistics.mean (data)))

 

Мы получаем вывод как:

Среднее значение выборки составляет 13,666666666666666
 

Если вы используете IDE для кодирования, вы можете навести курсор на оператор и получить дополнительную информацию о statistics.mean ().

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

Для расчета стандартного отклонения выборочных данных используйте:

print ("Стандартное отклонение выборки составляет% s"% (statistics.stdev (data)))
 

Мы получаем результат как:

Стандартное отклонение выборки составляет 15,61623087261029.
 

Вот краткая документация по statistics.stdev ().

Полный код для поиска стандартного отклонения и среднего

Полный код приведенных выше фрагментов выглядит следующим образом:

статистика импорта
импортировать numpy как np

данные = np.массив ([7,5,4,9,12,45])

print ("Стандартное отклонение выборки составляет% s"% (statistics.stdev (data)))
print ("Среднее значение выборки% s"% (statistics.mean (data)))
 

2. Напишите свою функцию

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

def означает (данные):
  n = len (данные)
  среднее = сумма (данные) / n
  вернуть среднее
 

Эта функция вычислит среднее значение.

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

Это может быть немного сложно, поэтому давайте рассмотрим его шаг за шагом.

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

  • тот, который вычисляет дисперсию
  • тот, который вычисляет квадратный корень из дисперсии.

Функция расчета отклонения выглядит следующим образом:

def дисперсия (данные):
  
  n = len (данные)
  
  среднее = сумма (данные) / n
  
  отклонения = [(x - среднее) ** 2 для x в данных]
   
  дисперсия = сумма (отклонения) / n
  возврат отклонения
 

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

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

def stdev (данные):
  импорт математики
  var = дисперсия (данные)
  std_dev = math.sqrt (переменная)
  вернуть std_dev
 

Полный код

Полный код выглядит следующим образом:

import numpy as np # для объявления массива

def означает (данные):
  n = len (данные)
  среднее = сумма (данные) / n
  вернуть среднее

def дисперсия (данные):
  n = len (данные)
  среднее = сумма (данные) / n
  отклонения = [(x - среднее) ** 2 для x в данных]
  дисперсия = сумма (отклонения) / n
  возврат отклонения

def stdev (данные):
  импорт математики
  var = дисперсия (данные)
  std_dev = математика.sqrt (var)
  вернуть std_dev

data = np.array ([7,5,4,9,12,45])

print ("Стандартное отклонение выборки% s"% (stdev (data)))
print ("Среднее значение выборки% s"% (среднее (данные)))
 

Заключение

Это руководство было посвящено вычислению среднего и стандартного отклонения в Python. Надеюсь, вам было весело учиться с нами!

Программа

простых чисел на Python

  1. Что такое простое число?
  2. 1 - простое ли число?
  3. Сопростые числа
  4. Наименьшее и наибольшее простые числа
  5. Программа Python для простых чисел

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

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

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

Следовательно, мы не можем включить 1 в список простых чисел. Все списки простых чисел начинаются с 2. Таким образом, наименьшее простое число - это 2, а не 1.

Давайте учиться дальше.Что, если у нас есть два простых числа? Какая связь между любыми двумя простыми числами? Наибольший общий делитель между двумя простыми числами равен 1. Следовательно, любая пара простых чисел приводит к взаимно простым числам. Копростые числа - это пары чисел, наибольший общий делитель которых равен 1. У нас также могут быть пары непростых чисел и пары простых и непростых чисел. Например, рассмотрим количество пар -

  1. (25, 36)
  2. (48, 65)
  3. (6,25)
  4. (3,2)

Проверить, является ли данная строка палиндромом в Python

Теперь, когда мы рассмотрели простые числа, каков диапазон простых чисел? Мы уже знаем, что наименьшее простое число - 2.

Каким может быть наибольшее простое число?

Ну, тут есть несколько интересных мелочей. В 2018 году Патрик Ларош из компании Great Internet Mersenne Prime Search обнаружил наибольшее простое число, 282 589 933 - 1, число, которое состоит из 24 862 048 цифр при записи по основанию 10. Это огромное число.

А пока сосредоточимся на решении различных задач, связанных с простыми числами. Эти постановки задачи следующие:

  1. Распознавание простых чисел
  2. Получение набора простых чисел между диапазоном чисел
  3. Распознавание простых чисел.

Это можно сделать двумя способами. Рассмотрим первый способ. Проверка всех чисел от 2 до самого числа на наличие факторов. Реализуем то же самое. Всегда начинайте со следующего алгоритма:

Алгоритм

  1. Инициализируйте цикл for, начиная с 2 и заканчивая номером
  2. Проверьте, делится ли число на 2
  3. Повторяйте, пока число -1 не будет проверено для
  4. В случае , число делится на любое из чисел, число не простое
  5. Иначе, это простое число
  num = int (input ("Введите число:"))

если число> 1:
# проверить факторы
для i в диапазоне (2, число):
если (число% i) == 0:
print (num, «не простое число»)
print (i, "times", num // i, "is", num)
сломать
еще:
print (num, «простое число»)
# если входной номер меньше чем
# или равно 1, не простое
еще:
print (num, «не простое число»)

  

Рассмотрим эффективное решение, позволяющее сократить вычисление вдвое.Мы проверяем множители только до получения квадратного корня из числа. Рассмотрим 36: его множители равны 1, 2, 3, 4, 6, 9, 12, 18 и 36.

Квадратный корень из 36 равен 6. До 6 есть 4 множителя, кроме 1. Следовательно, он не простой.

Рассмотрим 73. Его квадратный корень равен 8,5. Мы округляем до 9. Нет никаких множителей, кроме 1 для 73–9. Следовательно, это простое число.

Реализуем логику на python–

Алгоритм:

  1. Инициализируем цикл for, начиная с 2, заканчивая целым значением пола квадратного корня числа
  2. Проверяем, делится ли число на 2
  3. Повторяйте до тех пор, пока не будет проверен квадратный корень числа.
  4. В случае, если число делится на любое из чисел, число не простое
  5. В противном случае это простое число
  import math

def primeCheck (x):
sta = 1
для i in range (2, int (math.sqrt (x)) + 1): # range [2, sqrt (num)]
если (x% i == 0):
sta = 0
print ("Not Prime")
сломать
еще:
Продолжить
если (sta == 1):
print ("Prime")
вернуть персонал

num = int (input ("Введите число:"))
ret = primeCheck (число)
  

Мы определяем функцию primeCheck, которая принимает входные данные в качестве проверяемого числа и возвращает статус.Переменная sta - это переменная, которая принимает 0 или 1.

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

Алгоритм:

  1. Инициализировать цикл for между нижним и верхним диапазонами
  2. Используйте функцию primeCheck чтобы проверить, является ли число простым или нет.
  3. Если не простое, прервать цикл до следующего внешнего цикла.
  4. Если число простое, выведите его.
  5. Запустите цикл for, пока не будет достигнут верхний диапазон.
  l_range = int (input ("Enter Lower Range:"))
u_range = int (input ("Введите верхний диапазон:"))
print ("Простые числа между", l_range, "и", u_range, "являются:")
для числа в диапазоне (l_range, u_range + 1):
# все простые числа больше 1
если число> 1:
для i в диапазоне (2, число):
если (число% i) == 0:
сломать
еще:
печать (число)
  

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

Узнайте, как распечатать ряды Фибоначчи в Python.

Курс по искусственному интеллекту и машинному обучению от Great Learning уже сегодня!

2

Корень (числа) - определение математического слова

Корень (числа) - определение математического слова - Math Open Reference

Корень числа x - это другое число, которое при умножении на себя заданное количество раз дает x.

Например, третий корень (также называемый кубическим корнем) из 64 равен 4, потому что если вы умножите три четверки вместе, вы получите 64:

4 × 4 × 4 = 64

Это было бы записано как Вышеупомянутое будет означать "третий корень 64 составляет 4" или "кубический корень 64 равен 4" .
  • Второй корень обычно называют «квадратным корнем».
  • Третий корень числа обычно называют «кубическим корнем»,
  • После этого они называются корнем n-й степени, например корень 5-й, 7-й и т. Д.

Иногда бывает два корня

Для каждого корня четной степени (например, 2-го, 4-го, 6-го....) есть два корня. Это потому, что умножение двух положительных или двух отрицательных чисел дает положительный результат. Например, рассмотрим квадратный корень из 9.

Какое число, умноженное на само себя, даст 9?
Очевидно 3 будут работать:

3 × 3 = 9

Но так будет -3:

-3 × -3 = 9

Когда таких корней два, если не указано иное, мы имеем в виду положительный. Строго говоря, когда мы пишем 4, мы имеем в виду положительный корень, +2.Это называется «главный корень».

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

У отрицательных чисел нет реальных корней четного порядка. Например, квадратного корня из -9 не существует, потому что -3 × -3 = + 9, а также +3 × +3 = + 9. Это относится ко всем корням четного порядка, 2-му (квадратному) корню, 4-му корню, 6-му корню и так далее.

Однако - это корней нечетного порядка отрицательных чисел. Например, –3 - это кубический корень из –27. Это потому что –3 × –3 × –3 = –27.Первые два члена при умножении дают +9, затем следующее умножение дает
+9 × –3 = –27. Это применимо ко всем корням нечетного порядка, таким как 3-й (кубический) корень, 5-й корень, 7-й корень и т. Д.

Мнимые числа

Выше сказано, что действительного квадратного корня из отрицательного числа не существует. Обратите внимание на слово «настоящий». Это говорит о том, что нет настоящий номер это квадратный корень отрицательного числа.

Однако в математике и инженерии нам часто нужно найти квадратный корень из отрицательного числа.Чтобы решить эту проблему, мы вводим понятие «мнимого» числа. Он включает в себя символ i , который обозначает квадратный корень из отрицательного числа. Или, другими словами, i 2 = –1

На практике мы можем использовать его для выражения квадратного корня из любого отрицательного числа. Например Это означает, что квадратный корень из –25 - это квадратный корень из +25, умноженный на квадратный корень из отрицательной единицы.

Подробнее о мнимых числах см. Мнимые числа.

Символы

Радиканд

То, что вы находите корень.

Радикальный символ

Символ , означающий «корень из». Длина турника важна. См. Примечание ниже.

градусов

Сколько раз подкоренное выражение умножается само на себя. 2 означает квадратный корень, 3 означает кубический корень. После этого их называют корень 4-й, 5-й и так далее. Если он отсутствует, предполагается, что это 2 - квадратный корень.

Другой способ записи

Корни также можно записать в экспоненциальной форме. В общем Так, например, кубический корень x будет записан Что будет произноситься как «х в степени одной трети».

Другие экспоненты и основные темы

(C) Открытый справочник по математике, 2011 г.
Все права защищены.

.
Оставить комментарий

Добавить комментарий

Ваш адрес email не будет опубликован. Обязательные поля помечены *

© 2019 Штирлиц Сеть печатных салонов в Перми

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