关于python：当用于除法时，’/’和’//’之间有什么区别？


What is the difference between '/' and '//' when used for division?

使用一个对另一个有好处吗？在Python2中，它们似乎都返回相同的结果：

1
2
3
4
>>> 6/3
2
>>> 6//3
2
相关讨论

在python 3.0中，5 / 2将返回2.5，5 // 2将返回2。前者是浮点除法，后者是楼层除法，有时也称为整数除法。

在2.x行中的python 2.2或更高版本中，整数没有区别，除非执行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上找到详细的描述。

相关讨论

这有助于澄清python 2.x行中，/既不是楼层划分，也不是真正的划分。目前接受的答案不清楚。当两个参数都为int时，/是楼层划分，但当其中一个或两个参数都为float时，则是真正的划分。

上面讲的是更多的事实，比公认答案中的第二段更清楚。

//实现"楼层划分"，无论您的类型如何。所以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

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

。

python 2.7.10与python 3.5

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

现在，如果希望(在python 2.7中)与python 3.5中的输出相同，可以执行以下操作：

Python2.7.10

1
2
3
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中的楼层划分没有区别

1
2
3
4
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

。

相关讨论

正如大家已经回答过的那样，//是楼层划分。

这一点之所以重要，是因为在2.2版本(包括python 3.x版本)的所有python版本中，//都是明确的楼层划分。

/的行为可以根据以下情况而改变：

  • 是否导入激活的__future__(模块本地)
  • python命令行选项，可以是-Q old或-Q new。
1
2
3
4
5
>>> 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。

/部门和//楼层部门的运营商都以类似的方式运营。

相关讨论

双斜线//是楼层划分：

1
2
>>> 7//3
2

方程的答案被四舍五入到下一个较小的整数或以0为小数点的浮点。

1
2
3
4
5
6
7
8
>>>print 5//2
2
>>> print 5.0//2
2.0
>>>print 5//2.0
2.0
>>>print 5.0//2.0
2.0

//是楼层划分，它总是给出结果的整数楼层。另一个是"常规"部门。

在这个答案中，我不仅要告诉你答案，而且要告诉你//的好处。

大多数使用python的人必须知道python中的floor division操作符(//)。对于不知道的人，此运算符在除法后返回下限值。例如：5/2=2.5，但5//2=2(2是2.5的下限值)

但是对于大于10^17的数字，除法运算符的行为通常不正常。

1
2
3
4
5
x = 10000000000000000000006
if x / 2 == x // 2:
    print("Hello")
else:
    print("World")

对于上面的代码，世界将被打印，而不是你好。这是因为1000000000000000006/2将返回5e+21，但100000000000000000000006//2将返回正确的答案5000000000000000000003。即使是int(100000000000000000006/2)，也会返回500000000000000000000，这是不正确的。

因此，即使要分割大数字，也要使用//运算符。

例如：如果要查找第一个10000000000000000000000000000010002数字的和，公式为：n(n+1)/2，则普通除法运算符(/)会给出错误的答案，但//运算符会给出正确的答案。

以下是'/'和'/'之间的区别；我已经在python 3.7.2中运行了这些算术运算。

1
2
3
4
5
6
7
8
9
10
11
>>> print 11 / 3
3.6666666666666665

>>> print 11 // 3
3

>>> print 11.3 / 3
3.7666666666666667

>>> print 11.3 // 3
3.0
相关讨论

以上答案都很好。我想再加一点。在某些值中，这两个值的商相同。在此之后，楼层划分操作员(//工作正常，而不是划分操作员(/工作)。

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

。

5.0//2导致2.0，而不是2，因为//运算符返回值的返回类型遵循python强制(类型转换)规则。

python将较低的数据类型(integer)转换为较高的数据类型(float)，以避免数据丢失。