Python 中除法使用 `/` 与 `//`-IT科技

摘要：问题描述：使用其中一个比另一个有什么好处吗？在 Python 2 中，它们似乎都返回相同的结果：>>> 6/3 2 >>> 6//3 2 解决方案 1：在 Python 3.x 中，5 / 2将返回2.5，5 // 2并将返回2。前者是浮点除法，后者是向下取整除法，有时也称...

问题描述：

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

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

解决方案 1：

在 Python 3.x 中，5 / 2将返回2.5，5 // 2并将返回2。前者是浮点除法，后者是向下取整除法，有时也称为整数除法。

在 Python 2.2 或更高版本的 2.x 行中，整数没有区别，除非执行from __future__ import division，这会导致 Python 2.x 采用 3.x 行为。

无论将来如何导入，5.0 // 2都会返回，2.0因为这是操作的底部除法结果。

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

解决方案 2：

Python 2.x 说明：

需要澄清的是，对于 Python 2.x 行，/它既不是向下取整除法，也不是真正的除法。

/当两个参数都是时，就是向下取整除法int，但当其中一个参数是时，就是真除法float。

解决方案 3：

//执行“向下取整除法”，无论类型如何。因此
1.0/2.0将给出0.5，但1/2和1//2都1.0//2.0将给出0。

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

解决方案 4：

/ → 浮点除法

// → 地板除法

让我们看 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

解决方案 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

除法/运算符和//整数除法运算符的运算方式类似。

解决方案 8：

//是向下取整除法。它总是返回结果的整数向下取整。另一种是“常规”除法。

解决方案 9：

双斜线，//是向下除法：

>>> 7//3
2

解决方案 10：

前面的答案都很好。我想补充一点。在某些值之前，它们两个都得出相同的商。之后，向下取整除法运算符 ( //) 可以正常工作，但除法运算符 ( /) 则不行：

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

>>> 755349677599789174 // 2     # Correct answer
377674838799894587

解决方案 11：

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

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

解决方案 12：

Python 3.x 说明

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

需要指出的是：

一个 // b

是地板除法。例如：

数学.floor(a/b)

不是int division。例如：

整数（a/b）

浮点除法不会四舍五入为 0。例如：

圆形（a/b，0）

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

1 // 2 为 0，如下所示：

数学.floor(1/2)

-1 // 2 是 -1，例如：

数学.floor(-1/2)

解决方案 13：

Python 3

手术结果笔记
x / y x与y的商
x // y x和y的底商（1）
笔记：
也称为整数除法。结果值是一个整数，但结果的类型不一定是 int。结果总是向负无穷方向舍入：1//2是0、(-1)//2是-1、1//(-2)是-1和(-1)//(-2)是0。

手术	结果	笔记
`x / y`	x与y的商
`x // y`	x和y的底商	（1）

Python 2

手术结果笔记
x / y x与y的商（1）
x // y （取整）x与y的商 （4）（5）
笔记：
对于（普通或长）整数除法，结果为整数。结果始终向负无穷方向舍入：1/2 为 0，(-1)/2 为 -1，1/(-2) 为 -1，(-1)/(-2) 为 0。请注意，如果任一操作数为长整数，则结果为长整数，无论数值如何。
4.自 2.3 版起已弃用：对于复数，不再定义向下取整除运算符、取模运算符和divmod()函数。相反，如果合适，请使用函数将其转换为浮点数abs()。
也称为整数除法。结果值是一个整数，但结果类型不一定是 int。

手术	结果	笔记
`x / y`	x与y的商	（1）
`x // y`	（取整）x与y的商	（4）（5）

解决方案 14：

概括

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并得到不精确的浮点数 z。

其次，Python 求值表达式int(z)。

当重要性损失不可忽略时，我们会得到错误的结果。

解决方案 15：

//是向下取整除法。它始终会给出结果的向下取整值。
另一个/是浮点除法。

以下是/和之间的区别//；我已经在 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

解决方案 16：

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

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