`/` против `//` для деления в Python

Пояснение по Python 2.x:

Чтобы прояснить ситуацию по поводу версии Python 2.x, операция / не является ни целочисленным делением, ни истинным делением.

Операция / выполняет целочисленное деление, когда оба аргумента являются int, но выполняет истинное деление, когда хотя бы один из аргументов является float.

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

• / — деление с плавающей точкой
• // — целочисленное деление

Давайте посмотрим на несколько примеров, где сравниваются Python 2.7 и Python 3.5.

Python 2.7.10 vs. Python 3.5

print (2/3)  # Вывод: 0                   (Python 2.7)
print (2/3)  # Вывод: 0.6666666666666666  (Python 3.5)

Python 2.7.10 vs. Python 3.5

print (4/2)  # Вывод: 2         (Python 2.7)
print (4/2)  # Вывод: 2.0       (Python 3.5)

Если вам нужно получить такое же поведение, как в Python 3.5, в Python 2.7 вы можете сделать следующее:

Python 2.7.10

from __future__ import division
print (2/3)  # Вывод: 0.6666666666666666   (Python 2.7)
print (4/2)  # Вывод: 2.0                  (Python 2.7)

Что касается целочисленного деления, то между Python 2.7 и Python 3.5 разницы нет.

138.93//3  # Вывод: 46.0        (Python 2.7)
138.93//3  # Вывод: 46.0        (Python 3.5)
4//3      # Вывод: 1           (Python 2.7)
4//3      # Вывод: 1           (Python 3.5)

Таким образом, если вам необходима обратная совместимость с новым поведением деления, просто используйте импорты из будущего в Python 2.7.

Как уже ответили все, оператор // выполняет целочисленное деление (floor division).

Почему это важно, так это то, что // однозначно обозначает целочисленное деление и работает так во всех версиях Python, начиная с 2.2 и включая версии 3.x.

Поведение оператора / может изменяться в зависимости от:

• Наличия активного импорта __future__ (локально для модуля)
• Опции командной строки Python, либо -Q old, либо -Q new

В Python 5.0 / 2 выполняет обычное деление, возвращая результат в виде числа с плавающей запятой, в данном случае 2.5.

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

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

В Python 2.7 и других предстоящих версиях Python существует два основных оператора деления: обычное деление (/) и целочисленное деление (//).

Обычное деление (/)

Оператор / выполняет деление левого операнда на правый.

Пример:

4 / 2  # Результат: 2

Целочисленное деление (//)

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

Примеры:

9 // 2     # Результат: 4
9.0 // 2.0 # Результат: 4.0
-11 // 3   # Результат: -4
-11.0 // 3 # Результат: -4.0

Таким образом, операторы / и // работают схожим образом, но дают разные результаты в зависимости от характера деления. Обратите внимание, что в Python 2.7 обычное деление при использовании целых чисел также ведет к целочисленному результату, если оба операнда — целые числа. Для получения вещественного результата вам нужно использовать хотя бы один дробный операнд. В Python 3.x / всегда возвращает вещественное число независимо от типов операндов.