'/'和& # 39;/ / & # 39;什么时候用于除法?

//是楼层划分。它总是会给你结果的整数底。另一种是“常规”除法。

双斜杠，//，是楼层划分:

>>> 7//3
2

//实现“楼层划分”，无论您的类型。所以 1.0/2.0将给出0.5，但1/2， 1//2和1.0//2.0将给出0

详见PEP 238:改变除法运算符。

在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.2开始的所有Python版本中，包括Python 3，都是明确的楼层划分。x版本。

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

• 是否激活EYZ0导入(module-local)
• Python命令行选项，-Q old或-Q new

Python 2。x澄清:

为Python阐明2。x行，/既不是地板除法也不是真除法。

当这两个的参数为int时，/是地板除法，但当<强> < / >强的参数为float时，/是真正的除法。

>>> print 5.0 / 2
2.5


>>> print 5.0 // 2
2.0

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

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

/→浮点除法

//→楼层划分

让我们看看Python 2.7和Python 3.5中的一些例子。

Python 2.7.10 vs. Python 3.5

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

Python 2.7.10 vs. 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

Python 2.7和其他即将推出的Python版本:

• 部门(# EYZ0)

左手操作数除以右手操作数

例如:# EYZ0

• 楼层划分(//)

操作数的除法，其结果为除小数点后数的商。但如果其中一个操作数是负的，结果会被取整，即从零四舍五入(直到负无穷):

例如:9//2 = 4和9.0//2.0 = 4.0， -11//3 = -4， -11.0//3 = -4.0

/层划分和//层划分操作符以类似的方式操作。

5.0//2的结果是2.0，而不是2，因为//操作符返回值的返回类型遵循Python强制(类型强制转换)规则。

Python促进低数据类型(整数)到高数据类型(浮点数)的转换，以避免数据丢失。

• //是楼层划分。它总是会给你结果的底值。
• 另一个，/，是浮点除法。

以下是/和//之间的差异; 我已经在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

前面的答案都很好。我想再补充一点。在某些情况下，它们会得到相同的商。之后，除法运算符(//)可以正常工作，但除法运算符(/)不行:

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

>>> 755349677599789174 // 2     # Correct answer
377674838799894587

Python 3。x澄清

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

必须指出的是:

A // b

• < p > # EYZ0。如:

  math.floor (a / b)

• 不是整数除法。如:

  int (a / b)

• 不是四舍五入为0的浮点除法。如:

  轮(a / b, 0)

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

1 // 2为0，即:

math.floor (1/2)

-1 // 2为-1，即:

math.floor (1/2)

Python 3

操作	结果	笔记
# EYZ0	x和y的商
# EYZ0	x和y的底商	(1）

注:

1. 也称为整数除法。结果值是一个整型，尽管结果的类型不一定是int。结果总是趋近于负无穷:1//2是0， (-1)//2是-1， 1//(-2)是-1， (-1)//(-2)是0。

Python 2

操作	结果	笔记
# EYZ0	x和y的商	(1）
# EYZ0	(取底)x和y的商	(4) (5)

注:

1. 对于(普通或长)整数除法，结果是一个整数。结果总是趋近于负无穷:1/2等于0，(-1)/2等于-1,1/(-2)等于-1，(-1)/(-2)等于0。注意，如果任一操作数为长整数，则结果为长整数，无论数值如何。

4. 不再为复数定义整除运算符、模运算符和divmod()函数。相反，如果合适的话，使用abs()函数将其转换为浮点数。

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

总结

• 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

考虑