Базовые математические операции в Python

upd:

11.05.2023

52.5K

Базовые математические операции в Python

Содержание

Сложение (+)
Вычитание (-)
Умножение (*)
Деление (/)
Целочисленное деление (//)
Остаток от деления (%)
Возведение в степень (**)

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

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

Сложение (+)

И самая простая и понятная из них — сложение. Никаких "подводных камней": берём два или более чисел, пишем между ними знак "+" и присваиваем результат выражения переменной (или сразу выводим сумму на экран):

x = 5
y = 3
z = x + y

print(z)
> 8

Сложим несколько вещественных чисел и выведем их на экран без предварительной инициализации результирующей переменной:

q = 4.5
w = 2.5
e = 2.5
r = 0.5

print(q + w + e + r)
> 10.0

Вообще говоря, если хотя бы одно из слагаемых — число вещественное, то вещественным будет и весь результат.

num1 = 10
num2 = 15
num3 = 10.0
sum = num1 + num2 + num3

print(sum)
> 35.0

print(type(sum))
> <class 'float'>

Вычитание (-)

Вычитание – это обратная операция сложению. Оператором выступает знак "-":

a = 15
b = 25
c = a - b

print(c)
> -10

С вещественными числами здесь та же ситуация: если хотя бы один операнд имеет тип float, то и результат будет float:

i = 10
j = 5
k = 0.0  # вещественный ноль

print(i - j - k)
> 5.0

print(type(i - j - k))
> <class 'float'>

Умножение (*)

Как и две предыдущие операции, умножение в Python не таит в себе никаких скрытых или неочевидных особенностей. Умножаем два или более чисел при помощи оператора "звёздочка" (*):

# в этот раз обойдёмся без создания переменных
print(2 * 2)
> 4

print(2 * 2.0)
> 4.0

print(10000 * 0)
> 0

print(-33 * 3)
> -99

Деление (/)

Сложение, вычитание и умножение тривиальны, а вот с делением не всё так просто. В Python существует три вида деления и столько же разных операторов. Начнём с истинного деления, за которое отвечает оператор "/". Его главным отличием является то, что, вне зависимости от типов операндов, будет возвращен вещественный результат (float).

print(8/2)
> 4.0

# делимое и делитель — int числа, а частое — float
print(type(8/2))
> <class 'float'>

print(8/3)
> 2.6666666666666665

Этот вид деления наиболее близок к обычному и знакомому нам математическому. И здесь тоже нельзя делить на ноль:

print(8/0)
> ZeroDivisionError: division by zero

💁 Немного истории. В старых версиях Питон оператор "/" выполнял операцию классического деления: т.е. он делил целочисленно и усекал дробную часть в том случае, когда делимое и делитель были целыми. Если же операнды принадлежали к множеству вещественных чисел, то проводилось деление с сохранением дробной части, и результат был float.

Разработчики отказались от классического деления в Python 3.0 и вместо него добавили истинное деление. Архитекторы языка пошли на такой шаг по той причине, что в предыдущей модели классического деления результаты напрямую зависели от типов операндов. Из-за этого возникали трудности с их предварительной идентификацией и оценкой, что было особенно критично для Питона, как для языка с динамической типизацией.

Целочисленное деление (//)

Оператор "//" возвращает int, если оба операнда — целые числа, и float — если хотя бы один операнд является вещественным числом. В любом из вариантов дробная часть будет отброшена, а результат округлён вниз.

print(15//2)
# видно, что результат округлился в меньшую сторону
> 7

# и остался целочисленным, поскольку и делимое, и делитель — int числа
print(type(15//2))
> <class 'int'>

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

print(15//3.1)
> 4.0

print(type(15//3.1))
> <class 'float'>

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

print(5//-2)
> -3

print(5//2)
> 2

На ноль всё ещё нельзя делить:

print(15//0)
> ZeroDivisionError: integer division or modulo by zero

Остаток от деления (%)

Остаток от деления ещё называют делением по модулю. Оператор "%" сначала делит, а затем возвращает остаток.

print(21 % 3)
> 0

print(21 % 5)
> 1

print(21 % 0)
> ZeroDivisionError: integer division or modulo by zero

Остаток может не быть целочисленным:

print(21.3 % 3)
> 0.3000000000000007

Но вся прелесть данного оператора заключается не в возвращаемом им значении остатка.

Главная фишка деления по модулю в том, что с его помощью легко проверяется факт делимости одного числа на другое

А отсюда вытекают и проверки на чётность/нечётность:

import random


def parity_check(num):
    """
    функция, проверяющая четность числа.
    Любое четное число делится на 2 без остатка.
    """
    if num % 2 == 0:
        return 'Число чётное'
    else:
        return 'Число нечётное'


# сгенерируем случайное число и проверим работу функции
rnum = random.randint(0, 100)
print(rnum)
print(parity_check(rnum))

> 62
> Число чётное

💭 Проверка числа на чётность/нечётность будет часто встречаться в вашей работе.

Возведение в степень (**)

Нетипичный оператор для большинства других языков программирования. Тем он и удобен. Парная "звёздочка" (**) выполняет классическое математическое возведение числа "a" в степень "b":

a = 2
b = 10

print(a ** b)
> 1024

И показатель степени, и основание могут быть отрицательными:

a = 10
b = -2

print(a ** b)
> 0.01

a = -10
b = 3

print(a ** b)
> - 1000

И дробными:

# степень 0.5 аналогична квадратному корню
a = 100
b = 0.5

print(a ** b)
> 10.0

a = 0.5
b = 2

print(a ** b)
> 0.25

Операндов у возведения в степень также может быть несколько. В таком случае, оператор "**" работает, как право-ассоциативный (т.е. операции выполняются справа-налево):

print(2 ** 2 ** 3)
# Сначала выполняется 2 ** 3, а затем уже 2 ** 8.
> 256

В завершении — про приоритет операций. Если в выражении используются разные операторы, то порядок их выполнения будет следующим:

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