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

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

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

Ответ 1

В 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#pep-238-changing-the-division-operator

Ответ 2

Это помогает уточнить для строки Python 2.x, / не является ни разделением полов, ни истинным делением. Нынешний принятый ответ на это не ясен. / - это разделение полов, когда оба args являются int, но являются истинным делением, когда один или оба аргумента являются float.

Вышеизложенное говорит намного больше правды и намного понятнее второго абзаца в принятом ответе.

Ответ 3

// реализует "разделение полов" независимо от вашего типа. Так 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

Ответ 4

/ → Деление с плавающей запятой

// → Отдел пола

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

Ответ 5

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

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

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

Активный __future__ импорт или нет (модуль-локальный)
Параметр командной строки Python, либо -Q old, либо -Q new

Ответ 6

>>> print 5.0 / 2
2.5

>>> print 5.0 // 2
2.0

Ответ 7

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

Отдел (/)

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

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

Этажное деление (//)

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

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

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

Ответ 8

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

>>> 7//3
2

Ответ 9

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

Ответ 10

В этом ответе я расскажу не только ответ, но и преимущества //.

Большинство из вас, кто использует Python, должны знать об операторе деления пола (//) в Python. Для тех, кто не знает, этот оператор возвращает минимальное значение после деления. Например: 5/2 = 2,5, но 5//2 = 2 (2 - минимальное значение 2,5)

Но оператор деления обычно ведет себя ненормально для чисел больше 10 ^ 17.

x = 10000000000000000000006
if x / 2 == x // 2:
    print("Hello")
else:
    print("World")

Для приведенного выше кода World будет напечатан, а не Hello. Это связано с тем, что 10000000000000000000006/2 вернет 5e + 21, но 10000000000000000000006//2 вернет правильный ответ 5000000000000000000003. Даже int (10000000000000000000006/2) вернет 5000000000000000000000, что неверно.

Поэтому, даже если вы хотите разделить большие числа, используйте оператор //.

Например: если вы хотите найти сумму первых 100000000000000000000000010002 с формулой: n (n + 1)/2, обычный оператор деления (/) даст вам неправильный ответ, а оператор//даст вам правильный ответ.

Ответ 11

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

Ответ 12

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

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

Ответ 13

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

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

Ответ 14

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

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

Ответ 15

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

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