pythonfloor

❶ python Floor除法怎麼算

從Python2.2開始，增加了一個操作符 // ，以執行地板除：//除法不管操作數為何種數值類型，總是會捨去小數部分，返回數字序列中比真正的商小的最接近的數字。

123456
>>>1//20>>>1.0//20>>>-1//2.0-1

❷ python3.5中的地板除問題

對最佳回答進行一些修改：在python3.X中利用/即可直接進行浮點運隱除法運算，即精確除法。而//的規則是：旁並廳先對被除數進蔽絕行四捨五入取整（除數不動），然後運算除法，對運算結果進行無條件截斷，只保留到整數部分，小數點後不保留。這個類似floor()，所以也叫地板除。

#加粗部分為修改部分

❸ PYTHON里的負數求余是怎麼算的

在python中想搞清楚取余就要先搞清楚咐蔽謹整除

因為在python中取余遵循

a % b = a - (a // b) * b

那麼

r = m // n, 而且始終取下, 即math.floor(r),且同號正, 異號負, 5 // -3 = -2, 5 // 3 = 1

那麼, 令r = floor(a // b)

a > 0, b > 0, a - (a // b) * b = a - {取下值的正數, 故a > r * b} * b = 正數

a > 0, b < 0, a - (a // b) * b = a - {取下值衡基的負數, 故a < r * b} * b = 負數

a < 0, b > 0, a - (a // b) * b = a - {取下值的負數, 故a > r * b} * b = 正數

a < 0, b < 0, a - (a // b) * b = a - {取下值的正數, 故a < r * b} * b = 負數

所並棗以, 取余和被除數有關

❹ 為什麼Python中//和math.floor運算結果會不同

先說結論：這個問題是由於cpython的地板除運算符（//）的實現不是 浮點除清啟改法+floor 來實現而是用了（被除數 - 余數）/除數 導致的。

PS：Jython下可以得到20.0，而PEP里規定了a // b應該等於round(a/b)，所以似乎這是cpython實現的一個bug？

首先先分析下1 / 0.05究竟應該等於多少。答案就是旁此精確的20.0。

簡單解釋下：IEEE754浮點數規定，如果一個浮點數的值不能被精確記錄，那麼它的值會被記成與這個數距離最近的可以被IEEE浮點數表示的數。
首先，0.05在二進制下是無限循環小數，自然不能被精確記錄，因此0.05這個浮點數的實際值是不等於0.05的，實際值是約為0.05 + 2.7e-18。
之後做浮點除法，實際上做的是1 / (0.05+2.7...e-18)，這個除法的結果大約是20 - 1.1e-15。這個值也不能被精確表示，恰好離這個數最近的可以表示的值就是20.0，因此即使有浮點數誤差結果也是精確的20.0。
既然1/0.05就是20.0，那麼對他做floor運算自然也是20了。

現在的問題就是為什麼1 // 0.05會變成19.0，要解決這個問題只能翻源碼看//運算符的實現。
直接把cpython/floatobject.c at · python/cpython · GitHub 中實現//運算的一段貼上來答判：

static PyObject *
float_divmod(PyObject *v, PyObject *w)
{
double vx, wx;
double div, mod, floordiv;
CONVERT_TO_DOUBLE(v, vx);
CONVERT_TO_DOUBLE(w, wx);
if (wx == 0.0) {
PyErr_SetString(PyExc_ZeroDivisionError, "float divmod()");
return NULL;
}
PyFPE_START_PROTECT("divmod", return 0)
mod = fmod(vx, wx);
/* fmod is typically exact, so vx-mod is *mathematically* an
exact multiple of wx. But this is fp arithmetic, and fp
vx - mod is an approximation; the result is that div may
not be an exact integral value after the division, although
it will always be very close to one.
*/
div = (vx - mod) / wx;
if (mod) {
/* ensure the remainder has the same sign as the denominator */
if ((wx < 0) != (mod < 0)) {
mod += wx;
div -= 1.0;
}
}
else {
/* the remainder is zero, and in the presence of signed zeroes
fmod returns different results across platforms; ensure
it has the same sign as the denominator. */
mod = sign(0.0, wx);
}
/* snap quotient to nearest integral value */
if (div) {
floordiv = floor(div);
if (div - floordiv > 0.5)
floordiv += 1.0;
}
else {
/* div is zero - get the same sign as the true quotient */
floordiv = sign(0.0, vx / wx); /* zero w/ sign of vx/wx */
}
PyFPE_END_PROTECT(floordiv)
return Py_BuildValue("(dd)", floordiv, mod);
}

可以發現cpython中x // y的實現實際上是

round((x - fmod(x, y)) / y)

，其中fmod函數是求兩個浮點數相除的余數。

這樣一來就解釋的通了：在十進制下，顯然1除以0.05的余數應該是0.0。然而在IEEE浮點數環境中，0.05的實際值是約0.05 + 2.7e-18，略大於0.05，這樣一來1除以這個數的余數就成了約0.05 - 5e-17，從1中減掉這么多之後就只剩0.95了，除以0.05再round後變成19.0。

❺ python裡面地板除法是什麼意思

// 稱為地板除，兩個整數的除法仍然是整數，它總是會捨去小數部分，返回數字序列中比真正的商小的，最接近的數字。
簡單來說就是求商。
兩個整數相除，返回整數
3 // 2
> 1
兩個數的區中一個是浮點數，返回浮點數
3 // 2.0
> 1.0
負數除以正整數是負數自己本身
-1 // 2.0
> -1
負數除以負整數是0
-1//-4
> 0

❻ Python中floor的用處（功能）是什麼

浮點型數據類型，也就是數學中的小數，它的精度可以通過print(sys.float_info)查看

❼ python中，取模運算是怎樣的

對於整型數a，b來說，取模運算或者求余運算的鍵悔方法都是：
1.求 整數商： c = a/b;
2.計算模或者余數： r = a - c*b.
求模運算和扒簡求余運算在第一步不同: 取余運算在取c的值時，向0 方向舍入(fix()函數)；而取模運算在計算c的值時，向負無窮方向舍入(floor()函數)。
例如：計算-7 Mod 4
那麼：a = -7；b = 4；
第一步：求整數商c，如進行求模運算c = -2（向負無窮方向舍入），求余c = -1（向0方向舍入）；
第二步：計算模和余數的公式相同，但因c的值不同，求模時r = 1，求余時r = -3。
歸納：當a和b符號春亮褲一致時，求模運算和求余運算所得的c的值一致，因此結果一致。
當符號不一致時，結果不一樣。求模運算結果的符號和b一致，求余運算結果的符號和a一致。
另外各個環境下%運算符的含義不同，比如c/c++，java 為取余，而python則為取模。

❽ python取模是什麼意思

Python中的旁祥取模運算符用於求余數。它通常寫作%，並用於計算兩個整數相除時的余數。例如，如果我們將9除以4，得到2，余數為1，因此9 % 4等於1。

>>> 9 % 4
1

在Python中，取模運算符可用於任何整數，包括正整數、負整數和0。例如，以下代碼演示了使用取模運算符來計算幾個負整數的余數：

>>>友燃 -9 % 4
3
>>> -8 % 3
2
>>>好啟虛 -7 % 2
1

❾ python中取整

定義：大於或等於 x 的最大整數 math.ceil(x)
向上取整運算為Ceiling，用數學符號⌈⌉表示

定義：小於或等於 x 的最大整數 math.floor(x)
向上取整運算為Floor，用數學符號⌊⌋表示

其實反斜杠 // 也能實現向下取整:

但是在某些情況下 // 和 math.floor(x) 的實現結果又不一樣：

還是因為浮點數在計算機中存儲值並不是0.05而是0.05...125，具體解釋還是看這里吧 為什麼Python中//和math.floor運算結果會不同 。

向0取整：x為負數時向上取整，x為正數時向下取整。
python中可用 int(x) 實現，也可以用 math.modf(x) 返回一個包含小數部分和整數部分的元組。

有人可能會對 math.modf(-2.36) 結果感到好奇，按理說它應該返回 (0.36, 2.00) 才對。這里涉及到了另一個問題，即浮點數在計算機中的表示，在計算機中是無法精確的表示小數的，至少目前的計算機做不到這一點。上例中最後的輸出結果只是 0.36 在計算中的近似表示。
Python和C一樣, 採用IEEE 754規范來存儲浮點數，更詳細解釋，可以參考知乎話題：
為什麼0.1+0.2=0.30000000000000004而1.1+2.2=3.3000000000000003

從官方文檔得知，Python中 round(x) 採用銀行進位法而非傳統的四捨五入。

銀行進位規則：
① 如果保留數最後一位不等於5，則執行四捨五入，例如 round(5.234, 2)=5.23 round(5.236, 2)=5.24
② 如果保留數最後一位等於5，則取決於5的位置和狀態：⑴ 如果5後有數，不論奇偶都要進位，例如 round(5.2354, 2)=5.24 ；⑵ 如果5後沒有數，則需要看5的前一位奇偶性，奇進偶舍，例如 round(5.235, 2)=5.24 , round(5.225, 2)=5.22
但是！注意！：

內心中一片烏鴉飛過，說好的奇進偶舍呢？？？其實我內心也是奔潰的，繼續找答案：
我們都知道，計算機所存儲的浮點數並不是表面這么簡單，他並不是一個精確值，可以用decimal模塊的Decimal對象，將float數據映射為底層的更精確的表示。：

round還是那個round，過錯就在於float對象「眼見而非實」上，那到底如何實現真正意義四捨五入呢？？
decimal模塊是Python的一個標准庫，是專門為十進制小數的精確計算而設計的,使用decimal模塊的介面，可以實現小數精確的四捨五入，具體不多做展開了，可以參考官方文檔...暫時我也用不到decimal
一路寫下來，結論就是float心機好深，操作真的要小心點...

❿ python中如何進行開方運算

1、python中使用pow函數求n的n方根。首先打開python的編輯器，新建一個python 3的文件：