Математические вычисления в Python 3
Программирование невозможно представить без работы с числами. Размеры экрана, выбор цвета путем присвоения числовых кодов, географическое расположение, деньги и очки, продолжительность видео – для всего этого используются числа.
Потому умение выполнять математические операции очень важно для программирования. Конечно, чем выше у вас навык математических вычислений, тем лучше для вас; однако совсем не обязательно уметь выполнять сложнейшие вычисления, чтобы быть хорошим программистом. Если у вас нет опыта работы в области математики, старайтесь представлять математику как инструмент или как способ улучшить ваше логическое мышление.
Данное руководство научит вас работать с двумя наиболее распространёнными числовыми типами данных Python:
- целыми числами (бывают положительными, отрицательными или равными нулю (…, -1, 0, 1, …)).
- и числами с плавающей точкой (числа с десятичными знаками (например, 9.0 или -2.25)).
Операторы Python
Оператор – это символ или функция, которая выполняет то или иное действие над данными. К примеру, символ + – это оператор сложения.
В Python присутствуют как общие, так и специальные математические операторы.
Ниже приведена таблица наиболее распространённых математических операторов Python.
| Операция | Результат |
| x + y | Сложение (сумма x и y) |
| x – y | Вычитание (разница между x и y) |
| -x | Смена знака x |
| +x | Тождественность x |
| x * y | Умножение x на y |
| x / y | Деление x на y |
| x // y | Получение целой части от деления x на y |
| x % y | Остаток от деления x / y |
| x ** y | Возведение в степень |
Также руководство охватывает использование операторов присваивания.
Сложение и вычитание
Операции сложения и вычитания в Python выполняются точно так же, как и в обычной математике. Вы даже можете использовать Python вместо калькулятора.
Также вы можете объявить переменные и указать их в функции print:
a = 88
b = 103
print(a + b)
191
Целые числа бывают положительными и отрицательными. Попробуйте сложить следующие числа:
c = -36
d = 25
print(c + d)
-11
Числа с плавающей точкой складываются аналогичным образом:
e = 5.5
f = 2.5
print(e + f)
8.0
В результате сложения чисел с плавающей точкой также получается число с плавающей точкой, потому Python выводит 8.0, а не 8.
Синтаксис вычитания отличается от сложения только оператором. Попробуйте отнять 32 из 75.67:
g = 75.67
h = 32
print(g — h)
43.67
Примечание: Если в операции присутствует хотя бы одно число с плавающей точкой, в результате Python также выведет число с плавающей точкой.
Унарные арифметические операции
Унарное математическое выражение состоит только из одного компонента или элемента. В Python плюс и минус вместе со значением могут быть использованы в качестве одного элемента, это позволяет показать тождественность значения (+) или изменить его знак (-).
Тождественность используется нечасто. Плюс можно использовать с положительными числами:
Если вы используете плюс с отрицательным числом, он также вернёт тождественное (в этом случае – отрицательное) число.
Минус позволяет изменить знак. Если вы добавите минус к положительному значению, в результате будет отображено отрицательное значение:
Если добавить минус к отрицательному значению, в результате получится положительное число:
Умножение и деление
Операции умножения и деления, как сложение и вычитание, выполняются в Python так же, как в обычной математике. Для умножения Python использует *, для деления – /.
k = 100.1
l = 10.1
print(k * l)
1011.0099999999999
При делении в Python 3 частное всегда возвращается в виде числа с плавающей точкой, даже если вы делите целые числа:
m = 80
n = 5
print(m / n)
16.0
Это одно из главных различий между Python 2 и Python 3. Python 3 возвращает дробный результат, потому при делении 11 на 2 вы получите 5.5. В Python 2 деление привязано к типам данных, потому при делении целого числа невозможно получить число с плавающей точкой; поэтому при делении 11 на 2 Python 2 возвращает 5.
Читайте также: Python 2 vs Python 3
Когда числа по обе стороны символа деления являются целыми, выполняется деление floor, то есть, для фактора х Python 2 возвращает наибольшее целое число меньше или равное х. К примеру, при делении 5 / 2 таким числом будет 2.
Чтобы выполнить деление floor и получить только целую часть числа, Python 3 использует оператор //. К примеру, разделив 100//40, вы получите 2.
Деление по модулю
Оператор % – это модуль, который возвращает остаток от деления. К примеру, это позволяет найти числа, кратные одному и тому же числу.
o = 85
p = 15
print(o % p)
10
При делении 85 на 15 получается 5 и 10 в остатке.
Попробуйте разделить числа с плавающей точкой:
q = 36.0
r = 6.0
print(o % p)
0.0
Число 36.0 делится на 6.0 без остатка, потому в результате получился 0.0.
Возведение в степень
Оператор ** в Python возводит число в степень. Например, выражение 5 ** 3 значит, что 5 нужно возвести в третью степень. В математике это выглядит так: 5³. В Python можно получить тот же результат (125), умножив 5*5*5.
s = 52.25
t = 7
print(s ** t)
1063173305051.292
Приоритет операций
Как и в математике, в Python нужно помнить о том, что операции выполняются в порядке их приоритета, а не по порядку справа налево.
Сначала выполняется умножение (10*5=50), а затем сложение (10+50). Потому результат будет такой:
Чтобы сначала выполнить операцию сложения, а затем умножить полученный результат на 5, нужно взять сложение в скобки:
u = (10 + 10) * 5
print(u)
100
Математические операции имеют такой приоритет:
- Выражение в скобках;
- Экспоненты;
- Умножение;
- Деление;
- Сложение;
- Вычитание.
Операторы присваивания
Наиболее распространённым оператором присваивания является знак равенства (=). Он присваивает переменной слева значение справа. К примеру, в выражении v = 23 переменной v было присвоено значение 23.
В программировании часто используются составные операторы присваивания, которые выполняют операцию со значением переменной, а затем присваивают этой переменной полученное новое значение. Составные операторы объединяют арифметический оператор с оператором =. Например:
Составной оператор += выполнил сложение, а затем присвоил переменной w, значение, полученное в результате сложения.
Составные операторы часто используются в циклах.
for x in range (0, 7):
x *= 2
print(x)
0
2
4
6
8
10
12
Это позволяет автоматизировать процесс умножения чисел в заданном диапазоне.
В Python есть составные операторы присваивания для каждой математической операции:
y += 1 # сложение и присваивание
y -= 1 # вычитание и присваивание
y *= 2 # умножение и присваивание
y /= 3 # деление и присваивание
y // = 5 # деление floor и присваивание
y **= 2 # возведение в степень и присваивание
y %= 3 # вывод остатка и присваивание
Операторы присваивания позволяют постепенно увеличить или уменьшить значение, а также автоматизировать некоторые вычисления.
Заключение
Теперь вы умеете выполнять вычисления в Python. Читайте также:
- Типы данных в Python 3
- Преобразование типов данных в Python 3
Математические (арифметические) операторы. Примеры
Язык Python имеет ряд математических (арифметических) операторов для проведения вычислений в арифметических выражениях. Перечень этих операций в порядке убывания приоритета следующий:
- ** – возведение в степень;
- –x – унарный минус;
- / , // – обычное деление, деление с округлением вниз (одинаковый приоритет);
- % – остаток от деления;
- * – умножение;
- – – вычитание;
- + – сложение.
2. Для каких категорий числовых типов можно применять математические операторы?
Математические операторы можно применять для любых числовых типов, а именно:
- целочисленных (типов);
- вещественных;
- комплексных.
3. Каким образом вычисляется тип результата операции в случае если операция есть бинарной и содержит операнды различных типов?
Каждая операция возвращает результат некоторого типа. Если операция бинарная, то тип результата зависит от типа операндов.
Здесь возможны два случая:
- операнды имеют одинаковый тип. В этом случае тип результата операции есть этот же тип. Исключение составляет операция деления / целочисленных операндов. Если оба операнда целого типа, то результат операции деления будет иметь вещественый тип (число с плавающей запятой);
- операнды имеют разные типы. В этом случае тип результата операции будет определяется в следующей последовательности: сначала тип обоих операндов приводится к типу более сложного операнда; затем для операндов применяется математика, специфическая для этого типа.
Интерпретатор Python определяет сложность типов в такой последовательности (от простого к более сложному):
- целый тип;
- вещественный тип;
- комплексный тип.
В Python 2.6 (при необходимости) обычные целые числа могут быть преобразованы в длинные целые числа. В Python 3.0 и выше этого ранжирования уже нет и все целые числа представлены как длинные целые числа.
Пример. При использовании двух операндов разных типов возможны следующие ситуации.
Если один операнд целого типа, а другой вещественного типа, то тип результата будет вещественный тип (так как вещественный тип считается более сложным).
Если один операнд вещественного типа, а другой комплексного типа, то результат будет комплексного типа.
4. Операция возведения в степень ** . Пример
Операция возведения в степень обозначается ** и используется для операндов любых числовых типов (целочисленных, вещественных, комплексных).
# Операция ** - возведение в степень # 1. Для целых чисел a = 3 b = 2 c = a**b # c = 9 print("c color: #ff0000;"># 2. Для вещественных чисел a = 2.5 b = 3 c = a**b # c = 15.625 print('c = ', c) # 3. Для комплексных чисел x = 1 - 2j y = -4j z = x**y # z = (-0.011895629765035814+0.0009211666704635043j) print('z = ', z) # 4. В 16-й системе исчисления a = 0xA1 b = 0x03 c = a**b # c = 4173281 - результат в 10-й системе исчисления d = hex(c) # d = 0x3fade1 - результат в 16-й системе исчисления print('c = ', c) print('d = ', d) # 5. В 8-й системе исчисления a = 0o356 b = 0o2 c = a**b # c = 56644 - результат в 10-й системе исчисления d = oct(c) # d = 0o156504 - результат в 8-й системе исчисления print('c = ', c) print('d = ', d) # 6. В 2-й системе исчисления a = 0b101 b = 0b110 c = a**b # c = 15625 - результат в 10-й системе исчисления d = bin(c) # d = 0b11110100001001 - результат в 2-й с/и print('c = ', c) print('d = ', d)
5. Операции сложения ( + ), вычитания ( – ). Примеры
Операции сложения + и вычитания – являются бинарными и используются для любого числового типа.
# Операция сложения +, вычитания - # 1. Сложение, вычитание целых чисел a=3 b=5 c = a+b #c = 8 d = a-b # d = -2 # 2. Сложение, вычитание целого и вещественного чисел a = 2.5 b = 7 c = a + b # c = 9.5 - результат - вещественное число d = a - b # d = -4.5 - результат - вещественное число # 3. Сложение, вычитание вещественных чисел x = 8.99902 y = 9.112356 z = x+y # z = 18.111376 v = x-y # v = -0.11333600000000033 # 4. Сложение, вычитание комплексных чисел, результат - комплексное число a = 7+8j b = 3-2j c = a + b # c = (10+6j) d = a - b # d = (4+10j) # 5. Сложение, вычитание чисел в шестнадцатеричной системе исчисления a = 0xFF5 b = 0xC9 c = a + b # c = 4286 - в десятичной системе исчисления d = a - b # d = 3884 # 6. Сложение, вычитание чисел в восьмеричной системе исчисления a = 0o730 b = 0o50 c = a + b # c = 512 d = a - b # d = 432 # 7. Сложение, вычитание чисел в двоичной системе исчисления a = 0b0110110 b = 0b0001010 c = a + b # c = 64 - результат в десятичной системе исчисления d = a - b # d = 44
6. Операции умножения ( * ) и обычного деления ( / ). Пример
Операции умножения * и деления / есть бинарными. Эти операции используются с операндами любого числового типа (целого, вещественного, комплексного).
# Операции умножения * и обычного деления / # 1. Для целых чисел a = 7 b = 4 c = a*b # c = 28 - целый результат d = a/b # d = 1.75 - вещественный результат # 2. Для вещественных чисел a = 7.5 b = 3.2 c = a*b # c = 24.0 - вещественный результат d = a/b # d = 2.34375 # 3. Для комплексных чисел x = 2 + 2j y = 3 - 1j z = x*y # z = (8+4j) v = x/y # v = (0.4+0.7999999999999999j) # 4. В 16-й системе исчисления a = 0xaff b = 0x5b c = a*b # c = 256165 - результат в 10-й системи исчисления d = a/b # d = 30.934065934065934 - вещественное число # 5. В 8-й системе исчисления a = 0o356 b = 0o2 c = a*b # c = 476 d = a/b # d = 119.0 # 6. В 2-й системе исчисления a = 0b111 # a = 35 b = 0b101 # b = 5 c = a*b # c = 35 - результат в 10-й системе исчисления d = a/b # d = 1.4 - результат в 2-й системе исчисления
7. Особенности операции деления / для различных типов чисел. Пример
Если в операции деления / один из операндов является вещественного типа, то результат будет также вещественного типа (дробное число).
При использовании операции деления для целочисленных операндов в таких языках как C/C ++, C#, Java результат операции будет целочисленным. В версиях Python 2.6 и ниже операция деления целочисленных операндов также дает целочисленный результат, то есть после деления
a = 9/6 # a = 1 - версии Python 2.6 и ниже
переменная a = 1.
В версии Python 3.0 и выше результат операции деления / всегда будет вещественное число (независимо от типов операндов), то есть после деления
a = 9/6 # a = 1.5 - версии Python 3.0 и выше
переменная a имеет вещественный тип (a = 1.5). Если в версии Python 3.0 и выше при делении целочисленных операндов нужно вернуть целое число, то для этого используется операция деления с округлением вниз // (см. п. 8).
Пример.
# Для целых чисел (целочисленных операндов) a = 7 b = 4 c = a/b # c = 1.75 - результат вещественный a = 9 b = 3 c = a/3 # c = 3.0 - результат также вещественный
8. Операция деления с округлением вниз // . Пример
В версиях Python 2.2 и выше введена операция // деления с округлением вниз, которая в случае целочисленных операндов возвращает результат целого типа. В версиях Python 3.0 и выше эта операция заменяет целочисленное деление с возвращением целочисленного результата.
Пример.
# Операция деления // с округлением вниз, Python 3.7.0 # 1. Для целых чисел a = 8 b = 5 c = a // b # c = 1 a = 17 b = 3 c = a//b # c = 5 - целый результат с округлением вниз # 2. Для вещественного и целого числа x = 6.0 y = 2 z = x//y # z = 3.0 - вещественный результат # 3. Для вещественных чисел x = 5.5 y = 2.5 z = x//y # z = 2.0 - вещественный результат с округлением вниз x = 13.7 y = 2.3333 z = x//y # z = 5.0 - вещественный результат с округлением вниз
9. Операция «унарный» минус ( –x ). Пример
Операция «унарный минус» делает из положительного числа отрицательное, а из отрицательного числа положительное. Операция применяется к любому числовому типу.
# Унарный минус -x a = 15 b = -a # b = -15 - унарный минус a = -12.35 b = -a # b = 12.35 a = 0xFF b = -a # b = -255 - десятичная система исчисления c = hex(b) # c = -0xff a = 0o775 # восьмеричная система исчисления b = -a c = oct(b) # c = -0o775 a = 0b1111001 b = -a # b = -121 - десятичная система исчисления c = bin(b) # c = -0b1111001 - двоичная система исчисления # Комплексное число z = 2 - 8j z = -z # z = (-2+8j)
10. Операция взятия остатка от деления ( % ). Пример
# Операция взятия остатка от деления # 1. Для целых чисел a = 7 b = 4 c = a%b # c = 3 a = 5 b = 9 c = a % b # c = 5 # 2. Для вещественных чисел a = 5.5 b = 2.1 c = a%b # c = 1.2999999999999998 a = -8.1 b = -1.01 c = a%b # c = -0.019999999999999574 # 3. Для шестнадцатеричных чисел a = 0xA8 b = 0x0F c = a%b # c = 3 - результат в десятичной системе d = hex(c) # d = 0x3 - результат в 16-й системе # 4. Для восьмеричных чисел a = 0o15 b = 0o25 c = a % b # c = 13 d = oct(c) # d = 0o15 # 5. Для двоичных чисел a = 0b10011 b = 0b101 c = a%b # c = 4 d = bin(c) # d = 0b100
Связанные темы
- Операторы (операции) для работы с числовыми объектами. Таблица приоритетности операторов
- Смешивание типов. Преобразование типов в операторах
- Операторы сравнения
Как перевернуть знак?
В python, чтобы поменять знак какого-либо числа в переменной num , надо записать -num :
print(-a) # -5 print(-b) # 2 Как сделать положительное число?
Быстрый способ
Чтобы перевести любое число в ранг положительных, нужно написать abs(num) :
print(abs(a)) # 5 print(abs(b)) # 2 Почему этот способ самый быстрый?
Этот способ самый быстрый, т.к. здесь используется встроенная функция, написанная на быстром Си, и она будет быстрее любого другого способа с использованием других встроенных функций.
Математический способ
Это более медленный и длинный в написании способ. Для этой задачи не рекомендую его использовать.
Записать можно по-разному, но я приведу два различных способа:
print((a**2)**0.5) # 5 print((b**2)**0.5) # 2 from math import pow, sqrt print(sqrt(pow(a, 2))) # 5 print(sqrt(pow(b, 2))) # 2 Как это работает?
Чтобы получить модуль числа (то же число, только всегда положительное) число надо возвести в квадрат и извлечь квадратный корень.
В питоне можно по-разному записать эти операции, один способ — ** (возведение в степень), другой — воспользоваться встроенной библиотекой math .
Возведение в 2 степень — возведение в квадрат, а в 0.5 — эквивалентно извлечению квадратного корня.
Также для возведения в степень можно использовать функцию math.pow , а для извлечения квадратного корня — math.sqrt .
Вывод
Наш выбор для создания положительного числа — использовать функцию abs !
Соединяя инверсию знака с созданием положительного числа мы получаем следующее:
Чтобы перевести любое число num в ранг отрицательных, надо записать -abs(num)
print(-abs(a)) # -5 print(-abs(b)) # -2 Ремарки
- Для простоты понимания я опустил деталь, что при использования математического способа результат — float , а не int , и при выводе .0 добавляется к числу.
- Изначально в вопросе просилось сделать отрицательное число.
Как написать минус в питоне
Пусть у нас выполняется следующее выражение:
number = 3 + 4 * 5 ** 2 + 7 print(number) # 110
Здесь начале выполняется возведение в степень (5 ** 2) как операция с большим приоритетом, далее результат умножается на 4 (25 * 4), затем происходит сложение (3 + 100) и далее опять идет сложение (103 + 7).
Чтобы переопределить порядок операций, можно использовать скобки:
number = (3 + 4) * (5 ** 2 + 7) print(number) # 224
Следует отметить, что в арифметических операциях могут принимать участие как целые, так и дробные числа. Если в одной операции участвует целое число (int) и число с плавающей точкой (float), то целое число приводится к типу float.
Арифметические операции с присвоением
Ряд специальных операций позволяют использовать присвоить результат операции первому операнду:
- += Присвоение результата сложения
- -= Присвоение результата вычитания
- *= Присвоение результата умножения
- /= Присвоение результата от деления
- //= Присвоение результата целочисленного деления
- **= Присвоение степени числа
- %= Присвоение остатка от деления
number = 10 number += 5 print(number) # 15 number -= 3 print(number) # 12 number *= 4 print(number) # 48
Округление и функция round
При операциях с числами типа float надо учитывать, что результат операций с ними может быть не совсем точным. Например:
first_number = 2.0001 second_number = 5 third_number = first_number / second_number print(third_number) # 0.40002000000000004
В данном случае мы ожидаем получить число 0.40002, однако в конце через ряд нулей появляется еще какая-то четверка. Или еще одно выражение:
print(2.0001 + 0.1) # 2.1001000000000003
В случае выше для округления результата мы можем использовать встроенную функцию round() :
first_number = 2.0001 second_number = 0.1 third_number = first_number + second_number print(round(third_number)) # 2
В функцию round() передается число, которое надо округлить. Если в функцию передается одно число, как в примере выше, то оно округляется до целого.
Функция round() также может принимать второе число, которое указывает, сколько знаков после запятой должно содержать получаемое число:
first_number = 2.0001 second_number = 0.1 third_number = first_number + second_number print(round(third_number, 4)) # 2.1001
В данном случае число third_number округляется до 4 знаков после запятой.
Если в функцию передается только одно значение — только округляемое число, оно округляется то ближайшего целого
# округление до целого числа print(round(2.49)) # 2 - округление до ближайшего целого 2 print(round(2.51)) # 3
Однако если округляемая часть равна одинаково удалена от двух целых чисел, то округление идет к ближайшему четному:
print(round(2.5)) # 2 - ближайшее четное print(round(3.5)) # 4 - ближайшее четное
Округление производится до ближайшего кратного 10 в степени минус округляемая часть:
# округление до двух знаков после запятой print(round(2.554, 2)) # 2.55 print(round(2.5551, 2)) # 2.56 print(round(2.554999, 2)) # 2.55 print(round(2.499, 2)) # 2.5
Однако следует учитывать, что функция round() не идеальный инструмент. Например, выше при округление до целых чисел применяется правило, согласно которому, если округляемая часть одинаково удалена от двух значений, то округление производится до ближайшего четного значения. В Python в связи с тем, что десятичная часть числа не может быть точно представлена в виде числа float, то это может приводить к некоторым не совсем ожидаемым результатам. Например:
# округление до двух знаков после запятой print(round(2.545, 2)) # 2.54 print(round(2.555, 2)) # 2.56 - округление до четного print(round(2.565, 2)) # 2.56 print(round(2.575, 2)) # 2.58 print(round(2.655, 2)) # 2.65 - округление не до четного print(round(2.665, 2)) # 2.67 print(round(2.675, 2)) # 2.67
Подобно о проблеме можно почитать к документации.