Целочисленное деление питон: Целочисленное деление в Python

Ниже показан пример этого:

 print("Обычное деление")
print(2 / 2, "\это число с плавающей запятой")
print("\nРазделение этажа")
print(15 // 4, "\это целое число")
print(15. 0 // 4, "\tis a float.") 

Out:

 Обычное деление
1.0 — это число с плавающей запятой.
Разделение этажа
3 является инт.
3.0 - плавающий. 

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

 печать(15/4)
печать (15 // 4)
print(-15 // 4) 

Выход:

 3,75
3
-4 

Глядя на результат обычного деления, когда оба числа положительны, $\frac{15}{4}=3,75$, деление по полу возвращает $3$, так как это наибольшее целое число, меньшее или равное $3,75$. Когда один из операндов отрицательный, результат нормального деления отрицательный ($-3,75$), поэтому наибольшее целое число, меньшее или равное, равно $-4$.

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

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

 для значения в диапазоне (25/5):
    print(value) 

Out:

 ------------------------------------------------------- --------------------------------------------------
TypeError Traceback (последний последний вызов)
 в ()
----> 1 для значения в диапазоне (25/5):
      2 печать (значение)
TypeError: объект 'float' не может быть интерпретирован как целое число 

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

 для значения в диапазоне (25 // 5):
    печать(значение) 

Выход:

 0
1
2
3
4 

Еще одна область, в которой вы можете захотеть использовать оператор Floor, — это индексирование списков:

 x = list(range(100))
x[len(x) / 10] 

Выход:

 -------------------------------------------------- ----------------------------------------
TypeError Traceback (последний последний вызов)
 в <модуле>
      1 х = список (диапазон (100))
      2
----> 3 х [длина (х) / 10]
TypeError: индексы списка должны быть целыми числами или срезами, а не числами с плавающей запятой 

Один из способов решить эту проблему — использовать оператор деления пола:

 x[len(x) // 10] 

Исходящий:

 10 

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

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

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

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

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

Одним существенным отличием использования math.floor() является то, что он всегда выводит целое число, независимо от типа входных данных. При работе как с целыми числами, так и с числами с плавающей запятой math.floor() более полезен, поскольку обеспечивает более согласованный вывод.

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

 импорт математики
math.floor(15 / 4) 

Как и при использовании оператора Floor, math.floor по-прежнему будет округлять в меньшую сторону, когда ввод отрицательный.

В качестве альтернативы math.floor() мы также можем использовать math.ceil() , который всегда будет округлять до ближайшего целого числа, а не вниз.

Например:

 math.ceil(15 / 4) 

Подобно math. floor , math.ceil всегда выдает выходные данные в виде целого числа, независимо от типов данных аргументов. math.ceil будет округлять отрицательные числа в большую сторону, поэтому math.ceil(-15 / 4) даст в результате -3 .

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

В следующем примере $\frac{15}{4}=3,75$, но приведение к целому числу отрезает $.75$:

 int(15 / 4) 

int() работает аналогично math.floor() , за исключением того, что int() эффективно округляет отрицательные числа вверх, а не вниз:

 print(math. floor(-15 / 4))
печать (целое (-15 / 4)) 

Выход:

 -4
-3 

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

Отличие от round() заключается в том, что будет использоваться обычное округление, т. е. любое десятичное число .5 и больше округляется в большую сторону.

Ниже показано использование round() :

 round(3.5) 

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

В приведенном ниже примере показано, как можно округлить результат деления 15 на 4 ( 3,75 ) до 1 десятичной цифры: Добавление 1 после запятой означает, что мы хотели бы, чтобы результат имел 1 десятичную точку, но мы могли бы использовать любое число. Например, мы можем округлить число пи до девяти знаков после запятой: 9.0008

 round(math.pi, 9) 

Out:

 3.141592654 

Оператор деления пола ( // ) в основном используется, когда вам требуется целое число или нужно вернуть наименьшее целое число, меньшее или равное вход.

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

Строки, использующие оператор // , легко читаются и идиоматичны, но в случаях, когда вы работаете с непоследовательными и беспорядочными наборами данных, может быть лучше использовать math.floor() , math.ceil() , int() или round() .

Что означает // в Python?

Что делает оператор Python // ? Чем он отличается от оператора /?

Оператор

Оператор / является оператором деления в Python.

Когда / используется между двумя числами, вы всегда получите точный (настолько точный, насколько Python может управлять) результат обратно:

 >>> 5 / 2
2,5
 

В отличие от некоторых языков программирования, / в Python не действуют иначе при использовании между целыми числами; в Python 3 то есть. В Python 2 деление на два целых числа приведет к уменьшению до ближайшего целого числа:

 >>> 5 / 2 # Python 2
2
 

Но в Python 3 деление двух целых чисел всегда возвращает число с плавающей запятой с точным результатом:

 >>> 4 / 2
2.0
 

Оператор

Оператор // — это оператор деления пола в Python. Когда // используется между двумя целыми числами, вы всегда получите целое число:

 >>> 5 // 2
2
 

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

При использовании // с числом с плавающей запятой, вы получите обратно число с плавающей запятой:

 >>> 5.0 // 2
2.0
 

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

Когда следует использовать

Если вы когда-нибудь видели такой код:

 >>> n = 5
>>> целое(n / 2)
2
 

Тогда вы, вероятно, видели возможность использовать // оператор. Если вы делите, а затем сразу же конвертируете результат в целое число, вы, вероятно, могли бы использовать вместо этого оператор // .

В этой функции split_in_half мы используем функцию int , чтобы убедиться, что значение mid_point является целым числом:

 def split_in_half(sequence):
    """Вернуть две половины заданной последовательности (список, строка и т. д.)"""
    mid_point = int (len (последовательность) / 2)
    возвращаемая последовательность[:mid_point], последовательность[mid_point:]
 

Оба числа, которые мы делим, являются целыми, поэтому мы могли бы использовать // , чтобы получить целочисленный результат:

 def split_in_half(sequence):
    """Вернуть две половины заданной последовательности (список, строка и т.д.)"""
    mid_point = len(последовательность) // 2
    возвращаемая последовательность[:mid_point], последовательность[mid_point:]
 

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

Обратите внимание, что

Прежде чем вы замените все случаи использования int(a / b) в вашем коде на a // b , вы должны отметить, что эти два действия действуют по-разному, когда результат деление является отрицательным числом:

Допустим, мы делим и получаем -2,5 :

 >>> a = -5
>>> б = 2
>>> а/2
-2,5
 

При использовании / и int мы получим -2 , но при делении на // вместо этого получим -3 :

 >>> int(a / 2)
-2
>>> а // 2
-3
 

Оператор // всегда округляет в меньшую сторону. Он действует не столько как встроенная функция int , сколько как math.floor :

 >>> from math import floor
>>> этаж(а/2)
-3
>>> а // 2
-3
 

Также помните, что a // b возвращает число с плавающей запятой, когда либо a , либо b — числа с плавающей запятой.

 >>> а = 52,0
>>> б = 4
>>> а // б
13,0
 

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

Использование

Что делать, если вам нужно целочисленное деление (с // ) и остаток от этого деления (с % ):

 >>> duration = 500
>>> минуты = продолжительность // 60
>>> секунды = продолжительность % 60
>>> print(f"{минуты}:{секунды}")
8:20
 

Вместо того, чтобы использовать // и % по отдельности, вы можете использовать функцию divmod , чтобы получить оба результата одновременно:

 >>> duration = 500
>>> минуты, секунды = divmod(длительность, 60)
>>> print(f"{минуты}:{секунды}")
8:20
 

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

Иногда divmod может значительно улучшить читаемость кода. Например, здесь мы используем // и % , чтобы получить часы, минуты и секунды:

 >>> duration = 9907
>>> часы = продолжительность // (60 * 60)
>>> минуты = (длительность // 60) % 60
>>> секунды = продолжительность % 60
>>> print(f"{часы}:{минуты:02d}:{секунды:02d}")
2:46:07
 

Но мы могли бы использовать divmod дважды вместо этого:

 >>> продолжительность = 9907
>>> минуты, секунды = divmod(длительность, 60)
>>> часы, минуты = divmod(минуты, 60)
>>> print(f"{часы}:{минуты:02d}:{секунды:02d}")
2:46:07
 

Я считаю, что подход divmod намного понятнее, чем альтернативное использование // и % . Если вам нужно как частное (если использовать математический термин), так и остаток от деления, рассмотрите возможность использования divmod .