Числа в Python

В этой статье вы узнаете, какие типы чисел есть в Python, научитесь приводить один тип к другому и производить с числами математические операции.

Какие числа поддерживаются 

Python поддерживает комплексные (complex), целые числа (integer) и числа с плавающей точкой (float).

Целые числа и числа с плавающей точкой отличаются наличием или отсутствием десятичного разделителя. Например, 5 — целое число, а 5.0 — число с плавающей точкой. 

Целые числа могут быть любой длины. Точность чисел с плавающей точкой обеспечивается только до 15 знака, на 16 могут возникать неточности.

Комплексные числа записываются следующим образом: x + yj. Здесь xдействительная часть, а yмнимая.

Чтобы узнать, к какому типу относится переменная, используйте функцию type(). Если вы хотите узнать, принадлежит ли переменная определенному классу, используйте isinstance().

a = 5
print(type(a))
print(type(5.0))

c = 5 + 3j
print(c + 3)
print(isinstance(c, complex))

Вывод:

<class 'int'>
<class 'float'>
(8+3j)
True

Системы счисления

Числа, с которыми мы ежедневно сталкиваемся, представлены в десятичной системе счисления. Но программисты чащего всего работают с двоичной (основанием 2), шестнадцатеричной (основание 16) и восьмеричной (основание 8) системами счисления.

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

Система счисления

Префикс

Двоичная

'0b' или '0B'

Восьмеричная

'0o' или '0O'

Шестнадцатеричная

'0x' или '0X'

Вот как это выглядит:

# выведет 107
print(0b1101011)

# выведет 253, т. к. 251 + 2) = 253
print(0xFB + 0b10)

# выведет 13
print(0o15)

Вывод:

107
253
13

Приведение типов

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

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

>>> 1 + 2.0
3.0

Как видите, при сложении 1 (это целое число) приводится к 1.0 (это число с плавающей точкой). Результат тоже будет числом с плавающей точкой.

Чтобы выполнить явное преобразование, вы можете использовать встроенные функции int(), float(), complex(). С помощью них к численным типам можно приводить даже строки.

>>> int(2.3)
2

>>> int(-2.8)
-2

>>> float(5)
5.0

>>> complex('3+5j')
(3+5j)

При приведении числа с плавающей точкой к целому десятичная часть удаляется. Говорят, что она «обрезается».

Модуль decimal

Встроенный класс float порой может выдавать удивительные результаты. Все мы знаем, что 1.1 + 2.2 = 3.3, но Python, кажется, так не думает. 

Введите в IDLE на своем компьютере такую строку:

>>> (1.1 + 2.2) == 3.3
False

Почему False? Что не так?

Оказывается, что числа с плавающей точкой в памяти компьютера реализованы с помощью двоичных дробей — компьютер понимает только их (0 и 1). Именно поэтому большинство десятичных дробей невозможно со всей точностью хранить в памяти компьютера.

Приведем пример. Мы не можем представить дробь ⅓ в виде десятичного числа. ⅓ = 0.33333333… период — бесконечный. Поэтому хранить можно лишь приблизительное значение этого числа.

То есть десятичная дробь 0.1 — это бесконечная двоичная дробь 0.000110011001100110011… и компьютер может хранить в памяти только конечное число цифр после точки. Это лишь приближенное к 0.1 значение, но не равное ему. Следовательно, это аппаратные ограничения, а не ошибка Python.

>>> 1.1 + 2.2
3.3000000000000003

Для решения этой проблемы мы можем использовать модуль decimal, встроенный в Python. Тип float имеет точность до 15 знаков, а decimal — настраиваемую пользователем.

Разница налицо:

import decimal
print(0.1)
print(decimal.Decimal(0.1))

Вывод:

0.1
0.1000000000000000055511151231257827021181583404541015625

Этот модуль полезен, когда нам нужно вычислять десятичные дроби так же, как в школе. 

Положение точки тоже сохраняется. Мы знаем, что 25.50 кг точнее, чем 25.5 кг, так как у этой дроби два числа после точки.

from decimal import Decimal as D
print(D('1.1') + D('2.2'))
print(D('1.2') * D('2.50'))

Вывод:

3.3
3.000

Обратите внимание на нули в вышеприведенном примере.

Вы можете подумать: почему бы тогда не использовать модуль decimal вместо float постоянно? Справедливый вопрос.

Дело в эффективности. Операции с float происходят гораздо быстрее, чем с decimal

Когда стоит использовать decimal вместо float?

  • При создании приложения для работы с финансами. Здесь нужна точность.
  • Когда нужно держать уровень точности на определенном уровне.
  • Когда нужно реализовать дробь с определенным числом цифр после точки.

Модуль fractions

В Python есть модуль fractions, он производить операции с дробными числами.

У дробей есть числитель и знаменатель — это целые числа. Также этот модуль позволяет производить операции с рациональными числами.

Создать fraction-объект можно разными способами. Давайте их разберем:

import fractions
print(fractions.Fraction(1.5))
print(fractions.Fraction(5))
print(fractions.Fraction(1,3))

Вывод:

3/2
5
1/3

При создании fraction-объекта из float могут возникнуть неожиданные результаты. Происходит это, как говорилось выше, из-за несовершенного двоичного представления чисел с плавающей точкой. 

К счастью, fraction позволяет создать экземпляр из строки. Настоятельно рекомендуем использовать именно этот способ, когда аргументом является десятичное число. 

import fractions

# Число с плавающей точкой
# Вывод: 2476979795053773/2251799813685248
print(fractions.Fraction(1.1))

# Строка
# Вывод: 11/10
print(fractions.Fraction('1.1'))

Вывод:

2476979795053773/2251799813685248
11/10

Этот тип данных поддерживает все базовые математические операции. 

from fractions import Fraction as F
# со всеми работает
print(F(1, 3) + F(1, 3))
print(1 / F(5, 6))
print(F(-3, 10) > 0)
print(F(-3, 10) < 0)

Вывод:

2/3
6/5
False
True

Модуль math и random

Для решения тригонометрических, логарифмических, вероятностных и статистических задач Python располагает встроенными модулями math и random

import math

print(math.pi)
print(math.cos(math.pi))
print(math.exp(10))
print(math.log10(1000))
print(math.sinh(1))
print(math.factorial(6))

Вывод:

3.141592653589793
-1.0
22026.465794806718
3.0
1.1752011936438014
720

👉Полный список функций и атрибутов модуля math.

import random

print(random.randrange(10, 20))

x = ['а', 'б', 'в', 'г', 'д']

# Получаем случайный набор из х
print(random.choice(x))

# Перемешиваем x
random.shuffle(x)

# Выводим в консоль перемешанный список x
print(x)

# Выводим в консоль случайный элемент
print(random.random())

Примечание. Ваш вывод может отличать, поскольку функции модуля random выбирают элементы случайно. 

Вывод:

13
а
['г', 'б', 'д', 'а', 'в']
0.038881285348306704

👉Полный список функция и атрибутов модуля random.

codechick

СodeСhick.io - простой и эффективный способ изучения программирования.

2024 ©