Корень в питоне и математические действия в Python 3

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

Математические операторы Python 3

Оператор – это символ, который обозначает операцию над значениями. Например, знак + складывает два числа, а ** возводит число в степень.

Тип int хранит целые числа, а float – числа с плавающей точкой. Дробную часть в коде отделяйте точкой: 2.5. Правила работы с ними описывает документация числовых типов Python.

Каждый пример с кодом можно запускать отдельно в Python 3. Функция print() выводит результат выражения на экран.

Сложение и вычитание в Python

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

Сложение двух целых чисел возвращает целое число:

a = 88
b = 103
print(a + b)

Вывод:

191

При сложении int и float Python возвращает float:

print(5 + 2.5)

Вывод:

7.5

Оператор - вычитает правое число из левого:

g = 75.67
h = 32
print(g - h)

Вывод:

43.67

В этом примере мы вычитаем целое число из числа с плавающей точкой. Результат тоже имеет тип float.

Унарные арифметические операции Python

Унарный оператор действует на одно значение. Для встроенных типов int и float плюс сохраняет значение, а минус меняет знак числа.

i = 3.3
j = -19
print(+i)
print(+j)
print(-i)
print(-j)

Вывод:

3.3
-19
-3.3
19

Унарный плюс не делает отрицательное число положительным. Для получения модуля числа используйте функцию abs().

Умножение и деление в питоне

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

k = 100.1
l = 10.1
print(k * l)

Вывод:

1011.0099999999999

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

Деление в питоне через / возвращает float для аргументов int и float. Это правило действует даже при делении без остатка:

m = 80
n = 5
print(m / n)
print(11 / 2)

Вывод:

16.0
5.5

Целочисленное деление Python выполняет оператором //. Оператор округляет частное вниз, к меньшему целому:

print(100 // 40)
print(-7 // 2)
print(7.0 // 2)

Вывод:

2
-4
3.0

Для отрицательного частного округление вниз отличается от отбрасывания дробной части. Частное -3.5 превращается в -4. Если один аргумент имеет тип float, результат // тоже будет float.

Операторы /, // и % вызывают ZeroDivisionError при нулевом делителе. Пример перехватывает исключение и выводит его название:

for operation in (
    lambda: 7 / 0,
    lambda: 7 // 0,
    lambda: 7 % 0,
):
    try:
        operation()
    except ZeroDivisionError as error:
        print(type(error).__name__)

Вывод:

ZeroDivisionError
ZeroDivisionError
ZeroDivisionError

Деление с остатком Python

Оператор % возвращает остаток от деления. Например, число 85 содержит пять полных частей по 15:

o = 85
p = 15
print(o % p)

Вывод:

10

Для аргументов float остаток тоже имеет тип float:

q = 36.0
r = 6.0
print(q % r)

Вывод:

0.0

Ненулевой остаток в Python имеет тот же знак, что и делитель. Для целых чисел действует равенство a == (a // b) * b + a % b, если b не равен нулю.

print(-7 // 2)
print(-7 % 2)
print(7 % -2)
print((-7 // 2) * 2 + (-7 % 2))

Вывод:

-4
1
-1
-7

Функция divmod(a, b) возвращает частное и остаток одной парой:

quotient, remainder = divmod(-7, 2)
print(quotient, remainder)

Вывод:

-4 1

Как проверить четность и получить цифры числа

Остаток от деления Python использует, например, для проверки четности. Если n % 2 равен нулю, целое число четное:

n = 28
print(n % 2 == 0)

Вывод:

True

Операторы % и // помогают разбить число на цифры. Для неотрицательного целого % 10 возвращает последнюю цифру. Оператор // 10 удаляет эту цифру:

n = 472
print(n % 10)
print(n // 10)

Вывод:

2
47

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

Возведение в степень Python

Оператор ** возводит левое число в степень, указанную справа. Например, степень в питоне 5 ** 3 означает произведение 5 * 5 * 5.

print(5 ** 3)
print(5 * 5 * 5)

Вывод:

125
125

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

s = 52.25
t = 7
print(s ** t)

Вывод:

1063173305051.292

Функция pow(x, y) выполняет ту же операцию, что x ** y. Отрицательная целая степень ненулевого целого основания возвращает float:

print(pow(5, 3))
print(2 ** -3)

Вывод:

125
0.125

Для целых аргументов pow(x, y, mod) вычисляет степень по модулю. Такая запись позволяет не создавать полный промежуточный результат степени:

print(pow(2, 10, 7))
print((2 ** 10) % 7)

Вывод:

2
2

Тип int поддерживает длинную арифметику без фиксированной разрядности. Целая степень не переполняется при достижении границы машинного целого. Размер вычислений ограничивают доступная память и время:

print(2 ** 100)

Вывод:

1267650600228229401496703205376

Как вычислить корень в питоне

Функция math.sqrt(x) вычисляет квадратный корень неотрицательного действительного числа. Сначала подключите модуль math через import math. Описание функций содержит документация модуля math.

import math

print(math.sqrt(25))
print(25 ** 0.5)

Вывод:

5.0
5.0

Для положительного числа корень n-й степени можно вычислить выражением x ** (1 / n). В примере Python вычисляет корень четвертой степени из числа 81:

x = 81
n = 4
print(x ** (1 / n))

Вывод:

3.0

Функция math.isqrt(x) возвращает целую часть квадратного корня неотрицательного целого. Она работает с целыми напрямую, без преобразования в float:

import math

print(math.isqrt(26))
print(math.isqrt(10 ** 100) == 10 ** 50)

Вывод:

5
True

В действительных числах квадратного корня из отрицательного числа нет. Поэтому math.sqrt(-1) вызывает ValueError. Для комплексного результата используйте cmath.sqrt():

import math
import cmath

try:
    math.sqrt(-1)
except ValueError as error:
    print(type(error).__name__)

print(cmath.sqrt(-1))

Вывод:

ValueError
1j

Дробная степень отрицательного основания тоже может вернуть комплексное число. Не используйте (-8) ** (1 / 3) для получения действительного кубического корня.

Модуль числа в Python

Функция abs() вычисляет модуль числа Python без импорта модулей. Для int и float она возвращает абсолютное значение с сохранением типа:

print(abs(-19))
print(abs(-3.5))

Вывод:

19
3.5

Модуль комплексного числа – расстояние от начала координат до точки. Функция abs() возвращает его как float. Функция math.fabs() также возвращает float, но комплексные числа не принимает:

import math

print(abs(3 + 4j))
print(math.fabs(-19))

Вывод:

5.0
19.0

Модуль числа и деление по модулю обозначают разные действия. Функция abs(-7) возвращает 7, а выражение -7 % 2 возвращает остаток 1.

Операторы сравнения и «не равно» в питоне

Операторы сравнения возвращают логическое значение True или False. Оператор Python != проверяет, что значения не равны.

a = 5
b = 3
print(a == b)
print(a != b)
print(a < b)
print(a > b)
print(a <= 5)
print(b >= 5)

Вывод:

False
True
False
True
True
False

Оператор = присваивает значение переменной, а == сравнивает значения. В примере присваивание сохраняет число 5, затем сравнение возвращает True:

x = 5
print(x == 5)

Вывод:

True

Для сравнения результатов дробных вычислений используйте math.isclose() с подходящими допусками. В примере оператор == видит различие между результатом сложения и 0.3. Поэтому сравнение возвращает False:

import math

result = 0.1 + 0.2
print(result == 0.3)
print(math.isclose(result, 0.3, rel_tol=1e-9, abs_tol=1e-12))

Вывод:

False
True

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

Округление и точность float

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

print(0.1 + 0.2)
print(100.1 * 10.1)

Вывод:

0.30000000000000004
1011.0099999999999

Функция round(x, n) округляет число до указанного количества десятичных разрядов. При точном попадании посередине она выбирает ближайший четный вариант. Такой способ называют банковским округлением:

print(round(2.5))
print(round(3.5))
print(round(100.1 * 10.1, 2))

Вывод:

2
4
1011.01

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

price = 12.5
print(f"{price:.2f}")

Вывод:

12.50

Для десятичных расчетов используйте Decimal из модуля decimal. Создавайте значения из строк, чтобы не переносить погрешность float. Режим округления можно задать явно:

from decimal import Decimal, ROUND_HALF_UP

print(Decimal("0.1") + Decimal("0.2"))
print(Decimal("2.5").quantize(Decimal("1"), rounding=ROUND_HALF_UP))

Вывод:

0.3
3

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

Приоритет операторов

Операторы Python выполняются в порядке приоритета. Скобки позволяют изменить порядок вычислений и сделать выражение понятнее:

u = 10 + 10 * 5
print(u)
u = (10 + 10) * 5
print(u)

Вывод:

60
100

Умножение выполняется первым в выражении без скобок. Во втором выражении Python сначала вычисляет сумму внутри скобок.

Цепочка степеней вычисляется справа налево: 2 ** 3 ** 2 означает 2 ** (3 ** 2). Минус слева от основания применяется после возведения в степень:

print(2 ** 3 ** 2)
print(-2 ** 2)
print((-2) ** 2)
print(2 ** -2)

Вывод:

512
-4
4
0.25

У степени есть особенность: унарный минус справа относится к показателю. Поэтому 2 ** -2 означает 2 ** (-2). Полный порядок содержит таблица приоритета операторов в документации Python.

Операторы присваивания Python

Оператор = присваивает значение, расположенное справа, переменной слева. Составное присваивание объединяет вычисление и сохранение результата в той же переменной:

w = 5
w += 1
print(w)

Вывод:

6

Для числовой переменной запись w += 1 соответствует w = w + 1. До выполнения составного присваивания переменная должна получить начальное значение.

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

total = 1
for x in range(3):
    total *= 2
    print(total)

Вывод:

2
4
8

Оператор total *= 2 удваивает накопленное значение на каждой итерации. Изменение переменной x внутри тела не изменило бы последовательность range(3).

Все арифметические операторы имеют соответствующую форму составного присваивания:

y = 10
y += 1          # прибавить 1
y -= 1          # вычесть 1
y *= 2          # умножить на 2
y /= 3          # разделить на 3
y //= 5         # разделить на 5 с округлением вниз
y **= 2         # возвести в квадрат
y %= 3          # сохранить остаток от деления на 3
print(y)

Вывод:

1.0

Операции в этом примере выполняются последовательно над одной переменной. После /= значение получает тип float и сохраняет его до конца.

Число пи и целая часть в модуле math

Модуль math содержит математические константы и функции для действительных чисел. Константа math.pi хранит приближение числа пи:

import math

radius = 2
print(round(math.pi, 5))
print(round(math.pi * radius ** 2, 2))

Вывод:

3.14159
12.57

Функция math.floor() округляет вниз, а math.ceil() – вверх. Функция math.trunc() отбрасывает дробную часть, двигаясь к нулю:

import math

print(math.floor(-3.7))
print(math.ceil(-3.7))
print(math.trunc(-3.7))
print(int(-3.7))

Вывод:

-4
-3
-3
-3

Для отрицательных чисел целая часть через int() отличается от округления вниз. Выбирайте функцию по требуемому направлению округления.

Комплексные числа и битовые операции

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

Как записать комплексное число

Python обозначает мнимую единицу суффиксом j. Число можно создать записью 3 + 4j или вызовом complex(3, 4):

z = complex(3, 4)
print(z)
print(z + (1 - 2j))
print(z * 2)
print(abs(z))

Вывод:

(3+4j)
(4+2j)
(6+8j)
5.0

Комплексные числа поддерживают сложение, вычитание, умножение, обычное деление и степень. Операторы //, % и упорядочивающие сравнения для них не определены.

Какие операторы работают с битами

Битовые операторы обрабатывают двоичные разряды целых чисел. Знак ^ обозначает исключающее ИЛИ; для степени используйте **.

Число 5 записывается в двоичной системе как 101, число 3 – как 011. Операторы сопоставляют их разряды:

print(5 & 3)
print(5 | 3)
print(5 ^ 3)
print(~5)
print(5 << 1)
print(5 >> 1)

Вывод:

1
7
6
-6
10
2

Для целых чисел Python инверсия подчиняется равенству ~x == -x - 1. Поэтому результат ~5 равен -6.

Как выбрать оператор или функцию

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

Совет от нашей редакции: для точного целочисленного квадратного корня используйте math.isqrt(n) вместо int(math.sqrt(n)). Так большое целое число не потеряет точность при преобразовании в float.