В чем разница между '/' и '//' при использовании для деления?

Есть ли польза от использования одного над другим? В Python 2 они, похоже, возвращают одинаковые результаты:

>>> 6/3
2
>>> 6//3
2
Источник

16 ответов

Решение

В Python 3.0 5 / 2 вернусь 2.5 а также 5 // 2 вернусь 2, Первый - это деление с плавающей запятой, а второй - деление по полу, иногда также называемое целочисленным делением.

В Python 2.2 или новее в строке 2.x нет разницы для целых чисел, если вы не выполните from __future__ import division, что заставляет Python 2.x принять поведение 3.0

Независимо от будущего импорта, 5.0 // 2 вернусь 2.0 так как это результат деления на этаж.

Вы можете найти подробное описание на https://docs.python.org/whatsnew/2.2.html

Источник

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

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

Источник

// реализует "разделение на пол", независимо от вашего типа. Так1.0/2.0 дам 0.5, но оба 1/2, 1//2 а также 1.0//2.0 дам 0,

См. https://docs.python.org/whatsnew/2.2.html для получения подробной информации.

Источник

/ -> Деление с плавающей точкой

// -> Этажное деление

Давайте рассмотрим некоторые примеры как в Python 2.7, так и в Python 3.5.

Python 2.7.10 против Python 3.5

print (2/3)  ----> 0                   Python 2.7
print (2/3)  ----> 0.6666666666666666  Python 3.5

Python 2.7.10 против Python 3.5

  print (4/2)  ----> 2         Python 2.7
  print (4/2)  ----> 2.0       Python 3.5

Теперь, если вы хотите иметь (в python 2.7) тот же вывод, что и в python 3.5, вы можете сделать следующее:

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.2, включая версии Python 3.x.

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

  • активный __future__ импортировать или нет (модуль-локальный)
  • Опция командной строки Python, либо -Q old или же -Q new
Источник 
>>> print 5.0 / 2
2.5

>>> print 5.0 // 2
2.0
Источник

**

  1. Python 2.7 и другие будущие версии python:

**/ Деление Делит левый операнд на правый операнд ex:: 4/2 = 2

Floor Division (//) - Деление операндов, где результатом является частное, в котором удаляются цифры после десятичной точки. Но если один из операндов отрицателен, результат получен с плавающей запятой, т. Е. Округлен от нуля (к отрицательной бесконечности): примеры: 9//2 = 4 и 9.0//2.0 = 4.0, -11//3 = -4, -11,0//3 = -4,0

Операторы / Division и // Floor Division работают одинаково

Источник

// Это деление по этажам, оно всегда даст вам целое число результата. Другое "регулярное" деление.

Источник

Двойной слеш, //, этажное подразделение:

>>> 7//3
2
Источник

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

 - > int(755349677599789174/2)
 - > 377674838799894592      #wrong answer
 - > 755349677599789174 //2
 - > 377674838799894587      #correct answer
Источник

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

>>>print 5//2
2
>>> print 5.0//2
2.0
>>>print 5//2.0
2.0
>>>print 5.0//2.0
2.0
Источник

Разъяснение Python 3.x

Просто чтобы дополнить некоторые предыдущие ответы.

Важно отметить, что:

а // б

  • Есть этажное разделение. Как в:

    math.floor(а / б)

  • Не является внутренним делением. Как в:

    int (а / б)

  • Не округляется до 0 с плавающей точкой. Как в:

    раунд (а / б,0)

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

1 // 2 равно 0, как в:

math.floor(1/2)

-1 // 2 равно -1, как в:

math.floor(-1/2)

Источник

Python 3

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

Источник

Резюме

  • x // y: ТОЧНОЕ целочисленное деление
  • int (x / y) OR math.floor (x / y): НЕЧИСЛЕННОЕ целочисленное деление (но почти правильное)
  • x / y: деление с плавающей запятой (теряет значение)

Замечательный результат расчета

      import math
N = 1004291331219602346 # huge number 

print(N//100) #=> 10042913312196023 is correct answer
print(math.floor(N/100)) #=> 10042913312196024 is wrong answer
print(math.ceil(N/100)) #=> 10042913312196024 is wrong answer
print(int(N/100)) #=> 10042913312196024 is wrong answer

Рассмотрение

Я думаю об оценке int(x/y).
Сначала Python оценивает выражение x/yи получите НЕЧТО Плавающее число z.
Во-вторых, Python оценивает выражение int(z).
Мы получаем неверный результат, когда нельзя игнорировать потерю значимости.

Источник

Ниже приведены различия между "/" и "//"; Я выполнил эти арифметические операции в Python 3.7.2

>>> print 11 / 3
3.6666666666666665

>>> print 11 // 3
3

>>> print 11.3 / 3
3.7666666666666667

>>> print 11.3 // 3
3.0
Источник

5.0//2 результаты в 2.0, и не 2 потому что тип возвращаемого значения из // Оператор следует правилам приведения Python (приведение типов).

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

Источник
Другие вопросы по тегам