Python Математика

Операции с числами

В Python достаточно просто работать с числами, ведь сам язык является простым и одновременно мощным. Он поддерживает всего три числовых типа:

• int (целые числа)
• float (числа с плавающей точкой)
• complex (комплексные числа)

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

Целые и числа с плавающей точкой в Python

В программирование целые числа — это те, что лишены плавающей точкой, например, 1, 10, -1, 0 и так далее. Числа с плавающей точкой — это, например, 1.0, 6.1 и так далее.

Создание int и float чисел

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

var1 = 25

Здесь мы присваиваем значение 25 переменной var1.

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

Рассмотрим следующий код.

var1 = "25"
# или
var1 = '25'

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

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

var1 = 0.001

Здесь также не стоит использовать кавычки.

Проверить тип данных переменной можно с помощью встроенной функции type().

Можете проверить результат выполнения, скопировав этот код в свою IDE.

var1 = 1  # создание int
var2 = 1.10  # создание float
var3 = "1.10"  # создание строки
print(type(var1))
print(type(var2))
print(type(var3))

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

# создание 1,000,000
var1 = 1,000,000  # неправильно

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

# создание 1,000,000
var1 = 1_000_000  # правильно
print(var1)

Значение выведем с помощью функции print:

1000000

Арифметические операции над целыми и числами с плавающей точкой

Сложение

В Python сложение выполняется с помощью оператора +.

В терминале Python выполните следующее.

1+3

Результатом будет сумма двух чисел, которая выведется в терминале.

Теперь запустим такой код.

1.0 + 2

результат

3.0

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

Вычитание

В Python для операции вычитания используется оператор -. Рассмотрим примеры.

>>> 3 - 1
2
>>> 1 - 5
-4
>>> 3.0 - 4.0
-1.0
>>> 3 - 1.0
2.0

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

Умножение

Для умножения в Python применяется оператор *.

>>> 8 * 2
16
>>> 8.0 * 2
16.0
>>> 8.0 * 2.0
16.0

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

Деление

В Python деление выполняется с помощью оператора /.

>>> 3 / 1
3.0
>>> 4 / 2
2.0
>>> 3 / 2
1.5

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

>>> 1 / 0
Traceback (most recent call last):
File "", line 1, in 
ZeroDivisionError: division by zero

Деление без остатка

При обычном делении с использованием оператора / результатом будет точное число с плавающей точкой. Но иногда достаточно получить лишь целую часть операции. Для этого есть операции интегрального деления. Стоит рассмотреть ее на примере.

>>> 2 // 1
2
>>> 4 // 3
1
>>> 5 // 2
2

Результатом такой операции становится частное. Остаток же можно получить с помощью модуля, о котором речь пойдет дальше.

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

Для получения остатка деления двух чисел используется оператор деления по модулю %.

>>> 5 % 2
1
>>> 4 % 2
0
>>> 3 % 2
1
>>> 5 % 3
2

На этих примерах видно, как это работает.

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

Число можно возвести в степень с помощью оператора **.

>>> 3**2
9
>>> 2**4
16
>>> 3**3
27

Комплексные числа

Комплексные числа — это числа, которые включают мнимую часть.

Python поддерживает их «из коробки». Их можно запросто создавать и использовать.

Пример:

# создание двух комплексных чисел
var1 = 2 + 2j
var2 = 3 + 4j
# сложение двух комплексных чисел
sum = var1 + var2
print("Сумма двух комплексных чисел равна: ", sum)

В этом примере были созданы два комплексных числа a+bj. После этого было выполнено их сложение с помощью оператора +. Результат вывели на экран с помощью функции print().

Сумма двух комплексных чисел равна: (5+6j)

Конвертация типов чисел

Конвертация типа — это метод конвертации числа из одного типа в другой.

Для этого можно использовать функции float(), int() и complex().

x = 1  # создание целого числа
y = 2.0  # создание числа с плавающей точкой
z = 2+3j  # создание комплексного числа

a = float(x)  # преобразование целого числа в число с плавающей точкой
b = int(x)  # преобразование числа с плавающей точкой в ​​целое число
c = complex(x)  # преобразование целого числа в комплексное
d = complex(y)  # преобразование числа с плавающей точкой в комплексное

print(a, type(a))
print(b, type(b))
print(c, type(c))
print(d, type(d))

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

1.0 
1 
(1+0j) 
(2+0j) 

Случайные числа

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

Копировать

import random
print(random.randrange(1, 1000))

Результатом будет новое число от 1 до 1000, у каждого свое.

Встроенные математические функции

В Python есть множество встроенных функций для работы с числами. Вот самые важные из них.

round()

Функция round() используется для округления чисел с плавающей точкой до ближайшего целого.

Пр этом тип данных не меняется.

Целое число — это также число с плавающей точкой. Пример:

# создание чисел
a = 0.01
b = 1.45
c = 2.25
d = 3.7
e = 4.5

# округление чисел
print(round(a))
print(round(b))
print(round(c))
print(round(d))
print(round(e))

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

0
1
2
4
4

abs()

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

# создание чисел
a = 1.1
b = -1.5
c = 2
d = -3
e = 0

# отображение абсолютного значения
print(round(a))
print(round(b))
print(round(c))
print(round(d))
print(round(e))

Вывод:

1.1
1.5
2
3
0

pow()

Функция pow() используется для возведения числа в степень. Она повторяет то, что можно сделать и с помощью оператора **.

Функции pow() нужно передать два параметра.

Первый — число, которое нужно возвести в степень,

а второе — сама степень.

Пример:

base = 8
power = 2

print(pow(base, power))

Возведем 8 в степень 2. Вывод:

64

Библиотека math

Не забываем подключить библиотеку.

import math

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

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

В модуле есть кое-какие константы, среди которых PI, e и так далее.

Есть и кое-какие математические методы: log(), exp(), sqrt(), тригонометрические функции и так далее.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

math.exp(X) – e^X.

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

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

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

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

math.log2(X) – логарифм X по основанию 2.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

math.pi – pi = 3,1415926…

math.e – e = 2,718281…

Число Пи из библиотеки math

Первой важной математической константой является число Пи (π). Оно обозначает отношение длины окружности к диаметру, его значение 3,141592653589793. Чтобы получить к нему доступ, сначала импортируем библиотеку math следующим образом:

import math

Затем можно получить доступ к константе, вызывая pi:

math.pi

Вывод

3.141592653589793

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

import math

radius = 2

print(‘Площадь окружности с радиусом 2 равна:’, math.pi * (radius ** 2))

Вывод

Площадь окружности с радиусом 2 равна: 12.566370614359172

Мы возвели радиус во вторую степень и умножили значение на число Пи, как и следовало сделать в соответствии с формулой πr².

Сокращенные выражения

Сложение и присваивание (+=)

Суммирует значение обеих сторон и присваивает его выражению слева. a += 10 — это то же самое, что и a = a + 10.

То же касается и все остальных операторов присваивания.
Пример:

>>> a += 2
>>> print(a)

9 

Вычитание и присваивание (-=)

Вычитает значение справа из левого и присваивает его выражению слева.
Пример:

>>> a -= 2
>>> print(a)

7

Деление и присваивание (/=)

Делит значение слева на правое. Затем присваивает его выражению слева.
Пример:

>>> a /= 7
>>> print(a)

1.0

Умножение и присваивание (*=)

Перемножает значения обеих сторон. Затем присваивает правое левому.
Пример:

>>> a *= 8
>>> print(a)

8.0

Деление по модулю и присваивание (%=)

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

>>> a %= 3
>>> print(a)

2.0

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

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

>>> a **= 5
>>> print(a)

32.0

Деление с остатком и присваивание (//=)

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

>>> a //= 3
>>> print(a)

10.0

Это один из важных операторов Python

https://www.youtube.com/watch?v=k9gIUAdEjYc&list=PLA0M1Bcd0w8xIdFNA95aQrwJ_GQJEV8ko

Ссылка