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

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

>>> 6/3
2
>>> 6//3
2

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

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

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

Подробное описание можно найти по адресу https://docs.python.org/whatsnew/2.2.html#pep-238-changing-the-division-operator.

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

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

/деление по полу, когда оба аргумента равны int, но это истинное деление, когда один или оба аргумента равны float.

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

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

См. Https://docs.python.org/whatsnew/2.2.html#pep-238-changing-the-division-operator для получения подробной информации.

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

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

Давайте рассмотрим некоторые примеры как в 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

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

• Отдел ( /)

Делит левый операнд на правый операнд

Пример: 4 / 2 = 2

• Этаж Отдел ( //)

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

Примеры: 9//2 = 4и 9.0//2.0 = 4.0, -11//3 = -4,-11.0//3 = -4.0

И /дивизион, и //оператор дивизиона пола работают аналогичным образом.

Двойная косая черта //, это напольное деление:

>>> 7//3
2

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

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

>>>print 5//2
2
>>> print 5.0//2
2.0
>>>print 5//2.0
2.0
>>>print 5.0//2.0
2.0

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

 - > int(755349677599789174/2)
 - > 377674838799894592      #wrong answer
 - > 755349677599789174 //2
 - > 377674838799894587      #correct answer

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

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

• // Это разделение по полу, оно всегда даст вам минимальное значение результата.
• А другой /- деление с плавающей точкой.

Ниже приведены различия между /и //; Я выполнил эти арифметические операции в 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