Есть ли преимущество в использовании одного из них перед другим? В Python 2 они оба, похоже, возвращают одинаковые результаты:
>>> 6/3
2
>>> 6//3
2
В Python 3.0, 5 / 2
вернет 2.5
и 5 // 2
вернет 2
. Бывший делением с плавающей запятой, а последний этаж отдел, иногда также называется целочисленное деление.
В Python 2.2 или более поздней версии в 2.линия х, нет никакой разницы для целых чисел, если выполняется из будущее импорт отдела, что вызывает в Python 2.X, чтобы принять поведение 3.0
Независимо от будущего импорта, 5.0 // 2
вернет 2.0
, так что'с результатом этаж отдел эксплуатации.
Вы можете найти детальное описание на https://docs.python.org/whatsnew/2.2.html#pep-238-changing-the-division-operator
Это помогает прояснить для 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.
Питон 2.7.10 и питон 3.5
print (2/3) ----> 0 Python 2.7
print (2/3) ----> 0.6666666666666666 Python 3.5
Питон 2.7.10 и питон 3.5
print (4/2) ----> 2 Python 2.7
print (4/2) ----> 2.0 Python 3.5
Теперь, если вы хотите иметь (в Python 2.7) же вывод, что и в Python 3.5, вы можете сделать следующее:
Питон 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 версий.
Поведение /
может меняться в зависимости от:
импорт__будущее__
или нет (модуль-местные)-вопрос старый
или -Q новый
>>> 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
В этом ответе я не только ответа, но и преимущества //.
Большинство из вас, кто использует 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")
Для приведенного выше кода, мир будет напечатано, а не привет. Это потому, что 10000000000000000000006 / 2 вернется 5е + 21, но 10000000000000000000006 // 2 вернет правильный ответ 5000000000000000000003. Даже инт(10000000000000000000006 / 2) вернет 5000000000000000000000, который является неправильным.
Поэтому даже если вы хотите делить большие числа, использовать // оператор.
Например : если вы хотите найти сумму первых 100000000000000000000000010002 цифры, с формулой : Н(Н + 1)/2, обычный оператор деления(/) даст вам неправильный ответ, но // оператор даст вам правильный ответ.
//
- это деление с полом, оно всегда дает пол целого числа в результате. Другое - 'обычное' деление.
Выше ответы-это хорошо. Я хочу добавить еще один момент. До какого-то значения обоих из них результат в тот же коэффициент. После этого оператор деления пола (//
) работает нормально, но не оператор деления ( /
).
- > int(755349677599789174/2)
- > 377674838799894592 #wrong answer
- > 755349677599789174 //2
- > 377674838799894587 #correct answer
//
- деление пол, он всегда даст вам значение слово результата./
с плавающей точкой деления.Ниже приведены разница между /
и //
;
Я бежал эти арифметические операции в Python 3.7.2
``
печать (11 / 3) 3.6666666666666665
печать (11 // 3) 3
печать (11.3 / 3) 3.7666666666666667
печать (11.3 // 3) 3.0 ``
5.0/результаты/2
в 2.0
, а не 2
, потому что тип возвращаемого значения от возвращаемого значения оператор / / ` следует питона принуждения (типа литье) правила.
Питон способствует превращению нижнего типа данных (целое число) получить высшее тип данных (поплавок), чтобы избежать потери данных.