当用于除法时，'/'和'//'之间有什么区别？

Question

使用一个比另一个好吗？在Python 2中，它们似乎都返回相同的结果：

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

Answer 1

在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

找到详细说明

Answer 2

有助于澄清Python 2.x行，/既不是分部也不是真正的分区。目前接受的答案尚不清楚。当两个args都是int时，/是一个分区，但当其中一个或两个arg都是float时，它是真正的除法。

以上说明了更多的事实，并且比接受答案中的第2段更清晰。

Answer 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

Answer 4

/ - ＆gt;浮点除法

// - ＆gt;地板部门

让我们看一下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中的Floor division之间没有区别

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

Answer 5

正如大家已经回答的那样，//是分区。

为什么这很重要的是//在2.2版的所有Python版本中都是明确的分区，包括Python 3.x版本。

/的行为可能会因以下原因而改变：

• 有效__future__是否导入（模块本地）
• Python命令行选项，-Q old或-Q new

Answer 6

>>> print 5.0 / 2
2.5

>>> print 5.0 // 2
2.0

Answer 7

**

1. Python 2.7和其他即将推出的python版本：

** / Division 用左手操作数除左手操作数 恩:: 4/2 = 2

Floor Division（//） - 操作数的除法，其中结果是删除小数点后的数字的商。但是如果其中一个操作数是负数，则结果会被消除，即从零开始（向负无穷大）舍入： 例子： 9 // 2 = 4和9.0 // 2.0 = 4.0，-11 // 3 = -4，-11.0 // 3 = -4.0

两个/ Division和// floor division运营商都以类似的方式运营

Answer 8

双斜线//是地板分割：

>>> 7//3
2

Answer 9

等式的答案四舍五入到下一个较小的整数或浮点数，小数点为.0。

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

Answer 10

//是分区，它总是会给你结果的整数层。另一个是“常规”分工。

Answer 11

在这个答案中，我不仅会讲答案，而且还会讲// //的好处。

大多数使用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，则正常除法运算符（/）将为您提供错误的答案，但是//运算符将为您提供正确的答案答案。

Answer 12

以上答案是好的。我想补充一点。最多两个值都导致相同的商。之后，该楼层除法运算符（//）可以正常工作，但除法（/）运算符则无法正常工作。

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

Answer 13

5.0//2的结果为2.0，而不是2，因为//运算符返回值的返回类型遵循python强制（类型投射）规则。

Python促进将较低数据类型（整数）转换为较高数据类型（浮点数），以避免数据丢失。

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

Answer 15

Python 3.x 澄清

只是为了补充之前的一些答案。

需要注意的是：

<块引用>

a // b

• 是楼层划分。如：

  <块引用>

  math.floor(a/b)

• 不是int师。如：

  <块引用>

  int(a/b)

• 不是舍入到 0 浮点数。如：

  <块引用>

  轮(a/b,0)

因此，当涉及正数和负数时，行为方式是不同的，如下例所示：

1 // 2 为 0，如：

<块引用>

math.floor(1/2)

-1 // 2 是 -1，如：

<块引用>

math.floor(-1/2)

Answer 16

Python 3

<块引用>

<头> 的商 的底商

操作	结果	注意事项
x / y	x 和 y
x // y	x 和 y	(1)

注意事项：

1. 也称为整数除法。结果值是一个整数，尽管结果的类型不一定是 int。结果总是向负无穷大舍入：1//2 是 0，(-1)//2 是 -1，1//(-2) 是 -1，而 {{1} } 是 (-1)//(-2)。

Python 2

<块引用>

<头> 的商 的商

操作	结果	注意事项
0	x 和 y	(1)
x / y	（落地）x 和 y	(4)(5)

注意事项：

1.对于（普通或长）整数除法，结果为整数。结果总是向负无穷大舍入：1/2 为 0，(-1)/2 为 -1，1/(-2) 为 -1，(-1)/(-2) 为 0。请注意如果任一操作数是长整数，则无论数值如何，结果都是长整数。

<头> <第>4。 自 2.3 版起已弃用： 地板除法运算符、模运算符和 divmod() 函数不再为复数定义。相反，如果合适，请使用 abs() 函数转换为浮点数。

5.也称为整数除法。结果值是一个整数，尽管结果的类型不一定是 int。

Answer 17

总结

• x//y : 精确整数除法
• int(x/y) OR math.floor(x/y)：不精确整数除法（但几乎正确）
• x/y：浮点除法（失去意义）

显着的计算结果

import math
N = 1004291331219602346 # huge number 

print(N//100) #=> 10042913312196023 is correct answer
print(math.floor(N/100)) #=> 10042913312196024 is wrong answer
print(math.ceil(N/100)) #=> 10042913312196024 is wrong answer
print(int(N/100)) #=> 10042913312196024 is wrong answer

考虑

我想到了对int(x/y)的评价。
首先，Python 计算表达式 x/y 并得到 INEXACT 浮点数 z。
其次，Python 计算表达式 int(z).
当显着性损失不可忽视时，我们得到了错误的结果。