Как найти целое от деления в python

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

Деление в Python разделяется на три вида: обычное, целочисленное и взятие остатка. Программисту не нужно заботиться о типах операндов, Python сам определяет их и приводит результат к нужному виду. Как это делается, разберемся в этой статье.

Оператор деления

Деление в Python обозначается косой чертой «/». Примечательно, что результат в консоле всегда приводится к типу «float», даже если оба операнда были целочисленного типа, об этом свидетельствует появление «.0» у полученного значения.

Это появилось в 3-ей версии Python, ранее результатом деления целых чисел было только целое число, чтобы получить дробный результат, программисты явно указывали одному из операндов тип «float», в противном случае дробная часть просто отбрасывалась.

Важно понимать, что деление в Python, как и другие операции, работает медленнее, чем в более низкоуровневых языках программирования. Это связано с высоким уровнем автоматизации и абстракции, из-за динамической типизации интерпретатор вынужден приводить числа к дробному типу «float», который требует большего количества памяти.

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

Примеры:

print(int(1) / int(2))
print(5 / 5)
print(1 / 3)

0.5
1.0
0.3333333333333333

Из примера видно, что не смотря на то, что во всех случаях операция была между целыми числами, результатом деления в Python 3 является вещественное число. В первом случае мы даже специально использовали приведение к типу int.

Дополнительно хотелось бы отметить, что если точности типа данных float не достаточно, можно воспользоваться библиотекой decimal. В частности мы её использовали при написании программы «калькулятор» в отдельной статье.

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

Чтобы выполнить деление на цело в Python, можно воспользоваться целочисленным делением. В этом случае результатом будет целое число, без остатка. Целочисленное деление в Python обозначается двумя косыми чертами «//».

В отличие от других языков программирования Python позволяет результату целочисленного деления быть как целым (int), так и дробным (float) числом. В обоих случаях дробная часть отбрасывается и получается число с окончанием «.0».

Примеры нахождения целой части от деления:

print(5 // 2)
print(0 // 2)
print(1234 // 5.0)

2
0
246.0

В первых двух случаях деление осуществлялось между целыми числами. Поэтому в результате было получено целое число. В третьем примере одно из чисел вещественное. В этом случае в результате получаем так же вещественное число (типа float), после запятой у которого 0.

Остаток

Для получения остатка от деления в Python 3 используется операция, обозначающаяся символом процента «%». Остаток — это оставшаяся после целочисленного деления часть числа. Операция взятия остатка используется для решения различных видов задач.

Примеры:

print(10 % 3)
print(5 % 10)
print(5 % 0.25)

1
5
0.0

Определение остатка от деления очень часто используется в программах для нахождения, допустим, чётных чисел. Или, например, если обработка данных выполняется в цикле, и нужно выводить в консоль сообщение о ходе обработки не каждый раз, а на каждой 10-ой итерации.

Вот пример вывода чётных чисел из списка в консоль:

example_list = [3, 7, 2, 8, 1, 12]
for value in example_list:
    if value % 2 == 0:
        print(value)

2
8
12

Проблемы чисел с плавающей точкой

Компьютер устроен так, что на аппаратном уровне понимает только две цифры: один и ноль. Из-за этого при делении и других операциях с дробями часто возникают проблемы. Например, 1/10 в двоичном представлении является неправильной бесконечной дробью. Её нельзя написать полностью, поэтому приходится округлять, а выбор значения при округлении ограничен нулем и единицей.

Что говорить о делении, если ошибки возникают и при операции сложения. Если сложить число «0.1» с самим собой четырнадцать раз, то получиться 1.400…01. Откуда взялась эта единица? Она появилась при переводе числа из двоичного вида в десятичный.

a = 0.1
for i in range(13):
    a += 0.1
print(a)

1.4000000000000001

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

Деление комплексных чисел

Комплексные числа — это числа вида «a + b·i». Они занимают наивысшую ступень в иерархии чисел, арифметические операции над ними существенно отличаются от операций над обычными числами.

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

Пример:

print((5 + 8j) / 2)

(2.5+4j)

Сокращенные операции деления

Чтобы упростить жизнь программистов, разработчики Python включили в язык «сокращенные операции». Их используют если надо выполнить операцию над переменной и полученный результат записать в эту же переменную.  То, что записывается в длинной форме, можно записать в более короткой по следующим правилам:

Приведём пример:

a = 245
a %= 17
print(a)

7

Деление на ноль

Если попробовать в Python выполнить деление на 0, то мы получим исключение ZeroDivisionError.

Исключение следует обрабатывать, это можно сделать так:

try:
    print(24 / 0)
except Exception as e:
    print(e)

division by zero

Но в этом случае мы обрабатываем все исключения. Зачастую так делать не совсем корректно. Мы знаем, что в нашем коде возможно деление на 0 и, чтобы отловить именно эту ошибку, следует заменить except Exception as e: на except ZeroDivisionError as e:.
Но можно и проверять перед выполнением операции, что делитель не равен 0. Например так:

a = 14
b = None
if a == 0:
    print('делитель равен нулю!')
else:
    b = 345/a
    print('Операция выполнена, результат = ' + str(b))

Операция выполнена, результат = 24.642857142857142

Числа очень часто применяются в программирование для ведения счета в играх, представления данных в визуализации, хранение информации и т.д.

1. Типы чисел в Python.

В Python числа делятся на несколько категорий в соответствии со способом их использования. Основные это целые числа (int) и вещественные (float) или числа с плавающей точкой. Чтобы узнать к какому типу относится число или переменная, можно воспользоваться встроенной функцией type(). Запустите командную строку и активируйте Python. В скобках введите число или переменную, чтобы узнать ее тип.

Значение 12,5 является числом с плавающей точкой, поэтому Python выводит строку float. Переменная x содержит целое число 10, поэтому Python выводит тип int (сокращение от integer). 

2. Арифметические операторы Python.

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

2.1. Сложение и  вычитание в Python.

Сложение и  вычитание в целом выполняется и записывается, как и обычно в алгебре. 

>>> 5 + 2
7
>>> 5 — 2
3

2.2. Умножение в Python( * )

В Python в качестве оператора умножения используется знак * (звездочка)

>>> 5 * 5
25

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

В Python для возведения в степень используются два знака **. 

>>> 5 ** 6
15625
>>> 81 **(1/2)
9.0

Для вычисления квадратного корня можно воспользоваться показателем степени 1/2. Корень 81 = 9.

2.4. Деление в Python ( / )

Оператор деления ( / ) делит числитель на знаменатель

>>> 10 / 2
5.0
>>> 10 / 8
1.25

♦ Важно, при делении двух любых чисел — даже если это целые числа, частным от деления которых является целое число, вы всегда получаете вещественное число. 

2.5. Деление с округлением в Python( // )

Операция целочисленное деление ( // ) делит числитель на знаменатель, в результате получается наибольшее целое число, не превышающее результат. В Python дробная часть отсекается. 

>>> 10 // 8
1
>>> 20 // 8
2
>>> — 17 // 4
-5

При обычном деление 10 на 8, получается результат 1,25. Python отсекает дробную часть и в итоге получаем 1.

2.6. Оператор вычисления остатка от деления ( % )

Для вычисления остатка от  деления в Python используется оператор вычисления остатка от деления %

В данных примерах при делении 21 на 5, получается частное 4 и остаток 1. Во втором случае при делении 18 на 4, получается 4 и остаток 2. Этот оператор чаще работает с целыми числами, но также может использоваться и с другими типами. 

3. Исключения и трассировка.

В Python также как и в алгебре деление на 0 запрещено.  При попытке выполнения такой операции  происходит исключение. Сообщая об исключение, Python выдает трассировку стека. В трассировке указано, что произошло исключение типа ZeroDivisionError, большая часть исключений заканчивается суффиксом Error. Ошибка division by zero — деление на ноль.

>>> 5 / 0
Traceback (most recent call last):
  File «<stdin>», line 1, in <module>
ZeroDivisionError: division by zero

Далее: Строки и функция print в  Python

Назад: Запуск  программ Python  в командной строке

>>> 5 -? 

>>> 255 + 34
289
>>> 5 * 2
10
>>> 20 / 3
6.666666666666667
>>> 20 // 3
6
>>> 20 % 3
2
>>> 3 ** 4
81
>>> pow(3, 4)
81
>>> pow(3, 4, 27)
0
>>> 3 ** 150
369988485035126972924700782451696644186473100389722973815184405301748249

>>> n = -37
>>> bin(n)
'-0b100101'
>>> n.bit_length()
6

>>> (1024).to_bytes(2, byteorder='big')
b'x04x00'
>>> (1024).to_bytes(10, byteorder='big')
b'x00x00x00x00x00x00x00x00x04x00'
>>> (-1024).to_bytes(10, byteorder='big', signed=True)
b'xffxffxffxffxffxffxffxffxfcx00'
>>> x = 1000
>>> x.to_bytes((x.bit_length() // 8) + 1, byteorder='little')
b'xe8x03'

>>> int.from_bytes(b'x00x10', byteorder='big')
16
>>> int.from_bytes(b'x00x10', byteorder='little')
4096
>>> int.from_bytes(b'xfcx00', byteorder='big', signed=True)
-1024
>>> int.from_bytes(b'xfcx00', byteorder='big', signed=False)
64512
>>> int.from_bytes([255, 0, 0], byteorder='big')
16711680

>>> a = int('19') # Переводим строку в число
>>> b = int('19.5')  # Строка не является целым числом
Traceback (most recent call last):
  File "", line 1, in
ValueError: invalid literal for int() with base 10: '19.5'
>>> c = int(19.5)  # Применённая к числу с плавающей точкой, отсекает дробную часть
>>> print(a, c)
19 19
>>> bin(19)
'0b10011'
>>> oct(19)
'0o23'
>>> hex(19)
'0x13'
>>> 0b10011  # Так тоже можно записывать числовые константы
19
>>> int('10011', 2)
19
>>> int('0b10011', 2)
19

>>> 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1
0.9999999999999999

>>> a = 3 ** 1000
>>> a + 0.1
Traceback (most recent call last):
  File "", line 1, in
OverflowError: int too large to convert to float

>>> c = 150
>>> d = 12.9
>>> c + d
162.9
>>> p = abs(d - c)  # Модуль числа
>>> print(p)
137.1
>>> round(p)  # Округление
137

>>> (10.5).hex()
'0x1.5000000000000p+3'
>>> float.fromhex('0x1.5000000000000p+3')
10.5

>>> import math
>>> math.pi
3.141592653589793
>>> math.sqrt(85)
9.219544457292887

>>> import random
>>> random.random()
0.15651968855132303

>>> x = complex(1, 2)
>>> print(x)
(1+2j)
>>> y = complex(3, 4)
>>> print(y)
(3+4j)
>>> z = x + y
>>> print(x)
(1+2j)
>>> print(z)
(4+6j)
>>> z = x * y
>>> print(z)
(-5+10j)
>>> z = x / y
>>> print(z)
(0.44+0.08j)
>>> print(x.conjugate())  # Сопряжённое число
(1-2j)
>>> print(x.imag)  # Мнимая часть
2.0
>>> print(x.real)  # Действительная часть
1.0
>>> print(x > y)  # Комплексные числа нельзя сравнить
Traceback (most recent call last):
  File "", line 1, in
TypeError: unorderable types: complex() > complex()
>>> print(x == y)  # Но можно проверить на равенство
False
>>> abs(3 + 4j)  # Модуль комплексного числа
5.0
>>> pow(3 + 4j, 2)  # Возведение в степень
(-7+24j)

Для вставки кода на Python в комментарий заключайте его в теги <pre><code class=»python3″>Ваш код</code></pre>

Все числовые типы, кроме сложных, поддерживают следующие операции согласно их приоритетам выполнения:

• x + y
  Результатом будет сумма чисел x и у
• x - y
  Результатом будет разница чисел x и у
• x * y
  Результатом будет произведение чисел x и у
• x / y
  Результатом будет частное чисел x и у
• x // y
  Результатом будет деление x / y с округлением результата до ближайшего целого в меньшую сторону. Операцию называют «целочисленным делением».
  Результирующее значение является целым целым числом, хотя тип результата не обязательно является int.
  Результат всегда округляется до минус бесконечности:
  1 // 2 равно 0,
  (-1) // 2 равно -1,
  1 // (-2) равно -1,
  (-1) // (-2) равно 0.
• x % y
  Результатом будет остаток от деления чисел x / y.
• -x
  Результатом будет отрицательное значение x.
• +x
  В результате число x останется без изменений.
• abs(x)
  Результатом будет абсолютное значение или величина x.
• int(x)
  В результате число x преобразуется в целое число int.
  В качестве аргумента допускается использовать принятые числовые литералы включающие цифры от 0 до 9 или любой эквивалент Юникода.
  Преобразование вещественного числа в целое число может округляться или усекаться, как в C. Для четко определенных преобразований используйте math.floor() и math.ceil()
• float(x)
  В результате число x преобразуется в число с плавающей точкой float.
  В качестве аргумента допускается использовать принятые числовые литералы включающие цифры от 0 до 9 или любой эквивалент Юникода.
  Функция также принимает строки 'nan' — не число и 'inf' — положительная или отрицательная бесконечность, с необязательным префиксом + или -.
• complex(real, image)
  Результатом будет комплексное число с вещественной частью real, мнимой частью image.
  В качестве аргумента допускается использовать принятые числовые литералы включающие цифры от 0 до 9 или любой эквивалент Юникода.
• c.conjugate()
  Результатом будет сопряженное комплексное число с.
• divmod(x, y)
  Результатом будет пара (x // y, x % y).
• pow(x, y)
  Результатом будет число x в степени у. Python определяет 0 ** 0 как равное 1, как это обычно бывает для языков программирования.
• x ** y
  Результатом будет число x в степени у. Python определяет pow(0, 0) как равное 1, как это обычно бывает для языков программирования.

Внимание!. Комплексным числам (тип complex) недоступны операции: // — деление без остатка , % — остаток от деления, int(), float(), divmod().

Примеры использования:

Синтаксис арифметических выражений прост. Операторы +, -, * и / работают так же, как и в большинстве других языков программирования, круглые скобки () могут быть использованы для группировки выражений.

>>> 2 + 2
# 4
>>> 50 - 5*6
# 20
>>> (50 - 5*6) / 4
# 5.0

# деление всегда возвращает тип float
>>> 8/5
# 1.6

Целые числа, например 2, 4, 20 имеют тип int, числа с дробной частью, например 5.0, 1.6 имеют тип float.

Деление / всегда возвращает тип float (число с плавающей запятой). Для получения целой части числа, полученного в результате деления (floor division — округление результата до ближайшего целого в меньшую сторону) вы можете использовать оператор //, для расчета остатка вы можете использовать оператор %

# классическое деление
>>> 17 / 3 
# 5.666666666666667

# целочисленное деление
>>> 17 // 3  
# 5

# возвращает остаток от деления
>>> 17 % 3
# 2

С помощью Python можно использовать оператор ** для вычисления степеней

# 5 в квадрате
>>> 5 ** 2  
# 25

# 2 в степени 7
>>> 2 ** 7
# 128

Знак равенства = используется для присвоения значения переменной.

>>> width = 20
>>> height = 5 * 9
>>> width * height
# 900

Если переменная не определена, т. е. ей не присвоено значение, попытка использовать ее приведет к ошибке.

# переменная 'x' не определена
# ей не присвоено значение, а значит 
# Python ничего про нее не знает
>>> x
# Traceback (most recent call last):
#   File "<stdin>", line 1, in <module>
# NameError: name 'x' is not defined

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

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

>>> tax = 12.5 / 100
>>> price = 100.50
>>> price * tax
# 12.5625
>>> price + _
# 113.0625
>>> round(_, 2)
# 113.06

Переменная _ должна рассматриваться как доступная только для чтения. Не присваивайте ей явно значение, иначе вы создадите независимую локальную переменную с тем же именем, маскируя встроенную переменную с ее магическим поведением. Эта магическая переменная нередко используется в коде для скрытия неиспользуемых данных.

client = [(1, 'shopkeeper', 'Michael Palin'), 
          (2, 'client', 'John Cleese'), 
          (3, 'sketch', 'Cheese Shop Sketch')]
for num, _, name in client:
    print(num, name)

# 1 Michael Palin
# 2 John Cleese
# 3 Cheese Shop Sketch

Помимо int и float, Python поддерживает другие типы чисел, такие как Decimal и Fraction. Python также имеет встроенную поддержку комплексных complex чисел и использует суффикс j или J для обозначения мнимой части, например, 3+5j.