В данном уроке мы изучим работу с числовыми данными в Питоне. Python очень зрелый язык и, естественно, работа с числами в нём сделана удобно, но позволяет сделать очень многое. В данном языке, в отличие от многих других, типов числовых данных достаточно мало. Это целочисленный тип, реальные и комплексные числа. И если первые два типа представлены в любом языке, то комплексные числа – изюминка именно Пайтона.
- Вещественные числа в Python
- Создание int и float чисел
- Арифметические операции над целыми и числами с плавающей точкой
- Сложение
- Вычитание
- Умножение
- Деление
- Деление без остатка
- Остаток от деления
- Возведение в степень
- Комплексные числа
- Конвертация типов чисел
- Случайные числа
- Встроенные математические функции
- round()
- abs()
- pow()
- Библиотека math
Вещественные числа в Python
Вещественные числа это:
— Числа без дробной части. Могут быть как положительными, так и отрицательными. В Python представлены типом int. Пример: 0, -22, 48947364316
— Числа с дробной частью. Могут быть как положительными, так и отрицательными. В Python представлены типом float. Пример: 0.15, -5445454.45456465, 0.0
Создание int и float чисел
Питон помогает нам в работе с типами переменных. В этом его удобство, но это же и таит опасности. Огромная часть ошибок, возникающих в программном обеспечении, связана именно с типами данных.
Когда мы присваиваем переменной значение, Python сам определяет её тип:
i = 5
x = 0.0
print('type(i):', type(i))
print('type(x):', type(x))
# Вывод:
type(i): <class 'int'>
type(x): <class 'float'>
Если честно, определение типа происходит раньше, ещё когда интерпретатор доходит до самого значения.
print('type(7):', type(7))
print('type(-1.2):', type(-1.2))
# Вывод:
type(7): <class 'int'>
type(-1.2): <class 'float'>
Будьте внимательны: если указать значение в кавычках, интерпретатор воспримет их как строки.
print('type(\'7\'):', type('7'))
print('type("-1.2"):', type("-1.2"))
# Вывод:
type('7'): <class 'str'>
type("-1.2"): <class 'str'>
Как Вы уже видели выше, тип любого объекта можно проверить используя функцию type(). Даже тип самой функции type(). Даже тип типа))
print('type(7):', type(7))
print('type(type):', type(type))
print('type(type(7)):', type(type(7)))
# Вывод:
type(7): <class 'int'>
type(type): <class 'type'>
type(type(7)): <class 'type'>
Интересной особенностью языка является то, что интерпретатор Python игнорирует нижние подчёркивания в составе чисел. Это помогает визуально разделять разряды больших чисел в тексте программы.
a = 7_7
b = 999_999_999
c = 123_456.789_123
print('a:', a)
print('b:', b)
print('c:', c)
# Вывод:
a: 77
b: 999999999
c: 123456.789123
Арифметические операции над целыми и числами с плавающей точкой
Естественно, со всеми числовыми типами данных можно совершать арифметические операции.
Сложение
В Пайтоне сложение выполняется с помощью оператора +(странно, правда?).
print('1+1:', 1 + 1)
print('1+0.0:', 1 + 0.0)
print('1.0 + 1.0:', 1.0 + 1.0)
# Вывод:
1+1: 2
1+0.0: 1.0
1.0 + 1.0: 2.0
Примечательно то, что если в любой арифметической операции участвует число с дробной частью, то результат приводится к типу float. Обратите внимание, что в числах с дробной частью, которые лежат в диапазоне от 1 до -1, ноль слева от точки можно опускать.
print('0.12+0.1:', 0.12 + 0.1)
print('.12+.1:', .12 + .1)
# Вывод:
0.12+0.1: 0.22
.12+.1: 0.22
Вычитание
В Python для операции вычитания используется оператор -. Рассмотрим примеры.
print('1 - 1.1:', 1 - 1)
print('1.1 - 1.1:', 1.1 - 1.1)
print('1 - 1.1:', 1 - 1.1)
print('1.1 - 1:', 1.1 - 1)
# Вывод:
1 - 1.1: 0
1.1 - 1.1: 0.0
1 - 1.1: -0.10000000000000009
1.1 - 1: 0.10000000000000009
Положительные числа получаются в случае вычитания маленького числа из более крупного. Если же из маленького наоборот вычесть большое, то результатом будет отрицательно число. По аналогии с операцией сложения при вычитании если один из операндов является числом с плавающей точкой, то и весь результат будет такого типа. И да, с типом float бывают проблемы. Подробнее об этом мы рассказывали в одном из предыдущих уроков.
Умножение
Для умножения в Python применяется оператор *.
print('1 * 1.1:', 1 * 1)
print('1.1 * 1.1:', 1.1 * 1.1)
print('1 * 1.1:', 1 * 1.1)
print('1.1 * 1:', 1.1 * 1)
# Вывод:
1 * 1.1: 1
1.1 * 1.1: 1.2100000000000002
1 * 1.1: 1.1
1.1 * 1: 1.1
Если перемножить два целых числа, то результатом будет целое число. Если же использовать число с плавающей точкой, то результатом будет также число с плавающей точкой.
Деление
В Python деление выполняется с помощью оператора /.
print('1 / 1.1:', 1 / 1)
print('1.1 / 1.1:', 1.1 / 1.1)
print('1 / 1.1:', 1 / 1.1)
print('1.1 / 1:', 1.1 / 1)
# Вывод:
1 / 1.1: 1.0
1.1 / 1.1: 1.0
1 / 1.1: 0.9090909090909091
1.1 / 1: 1.1
В отличие от трех предыдущих операций при делении результатом всегда будет число с плавающей точкой. Также нужно помнить о том, что на 0 делить нельзя, иначе Python вернет ошибку ZeroDivisionError. Вот пример такого поведения.
print('1 / 0:', 1 / 0)
# Вывод:
Traceback (most recent call last):
File "C:\Users\ivand\AppData\Roaming\JetBrains\PyCharm2021.2\scratches\scratch.py", line 1, in
print('1 / 0:', 1 / 0)
ZeroDivisionError: division by zero
Process finished with exit code 1
Деление без остатка
При обычном делении с использованием оператора / результатом будет точное число с плавающей точкой. Но иногда достаточно получить лишь целую часть операции. Для этого есть операции интегрального деления. Стоит рассмотреть ее на примере.
print('1 // 1.1:', 1 // 1)
print('1.1 // 1.1:', 1.1 // 1.1)
print('1 // 1.1:', 1 // 1.1)
print('1.1 // 1:', 1.1 // 1)
# Вывод:
1 // 1.1: 1
1.1 // 1.1: 1.0
1 // 1.1: 0.0
1.1 // 1: 1.0
Результатом такой операции становится частное. Остаток же можно получить с помощью модуля, о котором речь пойдет дальше.
Остаток от деления
Для получения остатка деления двух чисел используется оператор деления по модулю %.
print('1 % 1.1:', 1 % 1)
print('1.1 % 1.1:', 1.1 % 1.1)
print('1 % 1.1:', 1 % 1.1)
print('1.1 % 1:', 1.1 % 1)
# Вывод:
1 % 1.1: 0
1.1 % 1.1: 0.0
1 % 1.1: 1.0
1.1 % 1: 0.10000000000000009
На этих примерах видно, как это работает.
Возведение в степень
Число можно возвести в степень с помощью оператора **.
print('1 ** 1.1:', 1 ** 1)
print('1.1 ** 1.1:', 1.1 ** 1.1)
print('1 ** 1.1:', 1 ** 1.1)
print('1.1 ** 1:', 1.1 ** 1)
# Вывод:
1 ** 1.1: 1
1.1 ** 1.1: 1.1105342410545758
1 ** 1.1: 1.0
1.1 ** 1: 1.1
Комплексные числа
Комплексные числа — это числа, которые включают мнимую часть. Python поддерживает и их.
первая_переменная = 2 + 2j
вторая_переменная = 3 + 4j
сумма = первая_переменная + вторая_переменная
print("Сумма двух комплексных чисел равна: ", сумма)
# Вывод:
Сумма двух комплексных чисел равна: (5+6j)
В этом примере были созданы два комплексных числа. После этого было выполнено их сложение с помощью оператора +. Результат вывели на экран с помощью функции print().
Конвертация типов чисел
Конвертация типа — это метод конвертации числа из одного типа в другой. Для этого можно использовать функции float(), int() и complex().
целое = 147
дробное = 147.741
комплексное = 147+741j
print('целое:', целое, 'тип:', type(целое))
print('дробное:', дробное, 'тип:', type(дробное))
print('комплексное:', комплексное, 'тип:', type(комплексное))
a = float(целое) # преобразование целого числа в число с плавающей точкой
b = int(дробное) # преобразование числа с плавающей точкой в целое число
c = complex(целое) # преобразование целого числа в комплексное
d = complex(дробное) # преобразование числа с плавающей точкой в комплексное
print('дробное:', a, 'тип:', type(a))
print('целое:', b, 'тип:', type(b))
print('комплексное:', c, 'тип:', type(c))
print('комплексное:', d, 'тип:', type(d))
# Вывод:
целое: 147 тип: <class 'int'>
дробное: 147.741 тип: <class 'float'>
комплексное: (147+741j) тип: <class 'complex'>
дробное: 147.0 тип: <class 'float'>
целое: 147 тип: <class 'int'>
комплексное: (147+0j) тип: <class 'complex'>
комплексное: (147.741+0j) тип: <class 'complex'>
Можно увидеть, как числа изменились за счет использования простых встроенных функций Python.
Случайные числа
Случайные числа используются в играх, криптографии и так далее. В Python нативной поддержки случайных чисел нет, но есть встроенный модуль random, который используется для работы с целыми числами. Рассмотрим пример генерации случайных чисел с помощью такого модуля.
import random
print(random.randrange(1, 99999))
# Вывод:
5214
Встроенные математические функции
В Python есть множество встроенных функций для работы с числами. Вот самые важные из них.
round()
Функция round() используется для округления чисел с плавающей точкой до ближайшего целого. Пр этом тип данных не меняется. Целое число — это также число с плавающей точкой. Пример:
целое = 147
дробное = 147.741
print('целое округлять нет смысла:', round(целое))
print('округлённое дробное:', round(дробное))
# Вывод:
целое округлять нет смысла: 147
округлённое дробное: 148
В выводе можно увидеть, что все числа с плавающей точкой были округлены до ближайшего целого.
А вот комплексное число округлять нельзя.
комплексное = 147+741j
print('округлённое комплексное:', round(комплексное))
# Вывод:
Traceback (most recent call last):
File "C:\Users\ivand\AppData\Roaming\JetBrains\PyCharm2021.2\scratches\scratch.py", line 2, in
print('округлённое комплексное:', round(комплексное))
TypeError: type complex doesn't define __round__ method
Process finished with exit code 1
abs()
Эта функция используется для генерации абсолютного значения числа. Оно всегда положительное, хотя число можно быть как положительным, так и отрицательным. Пример:
целое = -147
дробное = -147.741
комплексное = -147+741j
print('целое:', целое)
print('дробное:', дробное)
print('комплексное:', комплексное)
print('=' * 30)
print('целое по модулю:', abs(целое))
print('дробное по модулю:', abs(дробное))
print('комплексное по модулю:', abs(комплексное))
# Вывод:
целое: -147
дробное: -147.741
комплексное: (-147+741j)
==============================
целое по модулю: 147
дробное по модулю: 147.741
комплексное по модулю: 755.4402689822671
pow()
Функция pow() используется для возведения числа в степень. Она повторяет то, что можно сделать и с помощью оператора **.
Функции pow() нужно передать два параметра. Первый — число, которое нужно возвести в степень, а второе — сама степень. Пример:
исходное_число = 8
степень = 2
print(pow(исходное_число, степень))
print(pow(исходное_число, степень) is исходное_число**степень)
# Вывод:
64
True
Библиотека math
В Python есть полноценная библиотека, с помощью которой можно выполнять почти любую математическую операцию — math. Все это есть в стандартной библиотеке, поэтому дополнительные действия выполнять не нужно. В модуле есть кое-какие константы, среди которых PI, e и так далее. Есть и кое-какие математические методы: log(), exp(), sqrt(), тригонометрические функции и так далее.
