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

474

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

>>> 6/3
2
>>> 6//3
2
луч
источник
1
Пожалуйста, обратитесь к «Задаче с// целочисленным делением», чтобы узнать, почему оператор вводит целочисленное деление.
Шрирам

Ответы:

651

В 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.2! (Просто прочитайте связанный PEP)
u0b34a0f6ae
2
также python -Qnew. другие варианты деления: -Qold( по умолчанию), -Qwarn,-Qwarnall
Джон Ла Роого
2
Стоит отметить, что 5.0 / 2возвращается 2.5во всех версиях, как и в предыдущем случае 5 / 2.0- старое поведение отличается только тогда, когда оба операнда int.
Крис
2
А когда цифры отрицательные? Одинаково ли поведение для отрицательных целых чисел?
Аарон Франке
1
@Srinivasu Ваш пример не помогает. Лучше было бы 5 // 2 (что дает 2) и -5 // 2 (что дает -3).
Марвин
67

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

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

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

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

Yichun
источник
33

//реализует «разделение на пол», независимо от вашего типа. Так 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 для получения подробной информации.

Кена
источник
Это хороший ответ. PEP ссылка полезна. Кроме того, рассмотрите возможность использования math.floor()или, math.fmod()если вы не уверены, что происходит с унарными операторами.
Скотт Лоури
/и //являются би-ни капли операторов (два операнда, левый и правый, числитель и знаменатель)
ионосферные
28

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

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

Давайте рассмотрим некоторые примеры как в 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
N Randhawa
источник
это то же самое, что int (5/2)?
PirateApp
А когда цифры отрицательные? Одинаково ли поведение для отрицательных целых чисел?
Аарон Франке
1
Re: Негативы - Поведение такое же, но помните, что результат равен полу, поэтому округление всегда идет вниз в сторону более негативного . Несколько примеров: -100 // 33=> -4 ; 100 // -33=> -4 ; но из-за направления округления функции пола, следующий может показаться нелогичным по сравнению с предыдущим: -100 // -33=> 3 .
Erdős-Bacon
22

Как все уже ответили, //это напольное деление.

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

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

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

>>> print 5.0 // 2
2.0
Улица Джонаса Скиангула
источник
1
Не понял, что разделение по этажам тоже работает с нецелыми числами. Спасибо!
Майк
5

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

  • Отдел ( /)

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

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

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

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

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

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

Абрар Ахмад
источник
2
К бесконечности и вдали от нуля - разные вещи. Пример для (-1.2 и 3.4): «настил» - к отрицательной бесконечности (-2 и 3), «усечение» - к нулю (-1 и 3), «насыщение» - от нуля (-2 и 4), и «потолок» - к положительной бесконечности (-1 и 4).
Черность
4

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

>>> 7//3
2
Марк Родди
источник
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
G.Ant
источник
2

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

 - > int(755349677599789174/2)
 - > 377674838799894592      #wrong answer
 - > 755349677599789174 //2
 - > 377674838799894587      #correct answer
Джая Баран
источник
-1

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

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

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

Ниже приведены различия между /и //; Я выполнил эти арифметические операции в 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
Фатема Т. Зухора
источник
2
Как этот ответ добавляет что-то, что другие идеи не охватывают? Или как этот ответ лучше, чем другие ответы?
Рори Донтон
2
Ниже приведен вывод программы. Это ничего не объясняет.
Маркиз Лорн