538

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

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

16 回答 16

734

在 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，因为那是楼层划分的运算结果。

您可以在PEP 238：更改除法运算符中找到详细说明。

于 2008-10-08T17:21:37.910 回答
75

Python 2.x 说明：

为了澄清 Python 2.x 行，/既不是地板划分也不是真正的划分。

/当两个args都为时是地板除法int，但当任何一个 args 都是时是真正的除法float。

于 2012-07-22T21:50:35.450 回答
37

//实现“地板分割”，无论您的类型如何。所以 1.0/2.0会给予，0.5但两者都会给予。1/21//21.0//2.00

有关详细信息，请参阅PEP 238：更改除法运算符。

于 2008-10-08T17:19:59.410 回答
31

/ → 浮点除法

// → 楼层划分

让我们看看 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
于 2016-07-24T12:39:19.667 回答
23

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

为什么这很重要，这//是在所有 Python 2.2 版本（包括 Python 3.x 版本）中明确地划分。

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

  • 是否主动__future__导入（模块本地）
  • Python 命令行选项，-Q old或者-Q new
于 2009-11-09T23:55:18.570 回答
13 
>>> print 5.0 / 2
2.5

>>> print 5.0 // 2
2.0
于 2014-03-18T18:23:48.113 回答
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

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

于 2017-02-05T14:27:48.270 回答
5

//是楼层划分。它总是会给你结果的整数下限。另一个是“常规”划分。

于 2008-10-08T17:19:15.887 回答
5

双斜线 ,//是地板除法：

>>> 7//3
2
于 2008-10-08T17:19:42.953 回答
3

前面的答案很好。我想补充一点。直到某些值，它们都导致相同的商。在那个楼层除法运算符 ( //) 工作正常但除法 ( /) 运算符之后：

>>> int(755349677599789174 / 2) # Wrong answer
377674838799894592

>>> 755349677599789174 // 2     # Correct answer
377674838799894587
于 2019-06-06T02:27:01.320 回答
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
于 2015-06-03T15:26:43.160 回答
1

概括

  • 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)。
当重要性的损失不容忽视时，我们会得到错误的结果。

于 2021-07-29T15:43:39.810 回答
0
  • //是楼层划分。它总是会给你结果的底值。
  • 另一个/是浮点除法。

/以下是和之间的区别//；我已经在 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
于 2019-03-23T19:15:38.297 回答
0

Python 3.x 说明

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

重要的是要注意：

a // b

  • 是楼师。如：

    数学.floor(a/b)

  • 不是int除法。如：

    整数（a/b）

  • 不是四舍五入到 0 浮点除法。如：

    圆形(a/b,0)

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

1 // 2 为 0，如：

数学.地板（1/2）

-1 // 2 是 -1，如：

数学.地板（-1/2）

于 2021-02-13T20:25:01.043 回答
0

蟒蛇 3

手术 结果 笔记
x / y x和y的商
x // y x和y的底商 (1)

笔记：

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

蟒蛇2

手术 结果 笔记
x / y 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。

于 2021-03-27T19:01:12.310 回答
-1

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

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

于 2018-11-09T22:27:34.480 回答