'/' 和 '//' 用於除法時有什么區別？

Question

使用一個比另一個有好處嗎？ 在 Python 2 中，它們似乎都返回相同的結果：

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

Answer 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因為這是操作的樓層划分結果。

您可以在https://docs.python.org/whatsnew/2.2.html#pep-238-changed-the-division-operator找到詳細說明

Answer 2

Python 2.x 說明：

為了澄清 Python 2.x 行， /既不是樓層划分也不是真正的划分。

/當兩個args 都是int時是地板除法，但當任何一個 args 都是float時是真正的除法。

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-changed-the-division-operator

Answer 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 中的輸出相同，您可以執行以下操作：

蟒蛇 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

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

Python 2.7 和其他即將推出的 Python 版本：

• 分區 ( / )

將左手操作數除以右手操作數

示例： 4 / 2 = 2

• 樓層划分 ( // )

操作數的除法，結果是去除小數點后數字的商。 但如果其中一個操作數為負，則結果為底，即從零舍入（向負無窮大）：

示例： 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

在這個答案中，我不僅會講答案，而且還會講解//的好處。

你們大多數使用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 10

//是地板除法，它總是會給你結果的整數地板。 另一種是“常規”划分。

Answer 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

Answer 12

上面的回答都很好。 我想補充一點。 直到某些值，它們都會導致相同的商。 在該樓層除法運算符 ( // ) 工作正常但除法 ( / ) 運算符之后：

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

>>> 755349677599789174 // 2     # correct answer
377674838799894587

Answer 13

• //是地板除法，它總是會給你結果的地板值。
• 另一個/是浮點除法。

以下是/和//之間的區別； 我已經在 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 14

Python 3.x 澄清

只是為了補充一些以前的答案。

重要的是要注意：

一//二

• 是地師。 如：

  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)

Answer 15

蟒蛇 3

手術	結果	筆記
x / y	x和y 的商
x // y	x和y 的底商	(1)

筆記：

1. 也稱為整數除法。 結果值是一個整數，盡管結果的類型不一定是 int。 結果總是向負無窮大舍入： 1//2是0 ， (-1)//2是-1 ， 1//(-2)是-1 ， (-1)//(-2)是0 .

蟒蛇 2

手術	結果	筆記
x / y	x和y 的商	(1)
x // y	(floored) 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 16

概括

• x//y :精確整數除法
• int(x/y) OR math.floor(x/y): INEXACT整數除法（但幾乎正確）
• 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) 。
當顯着性損失不可忽視時，我們會得到錯誤的結果。

Answer 17

5.0//2導致2.0 ，而不是2因為//運算符的返回值的返回類型遵循 python 強制（類型轉換）規則。

Python 提倡將較低的數據類型（整數）轉換為較高的數據類型（浮點數）以避免數據丟失。