Python 中的地板除法

在下面的教程中，我们将学习如何使用 Python 编程语言进行整除（Floor Division）运算。

但在开始之前，让我们先简要了解一下什么是整除。

理解整除

整除是一种特殊的除法运算，它返回不大于结果的最大整数。这个整数要么小于普通除法的结果，要么等于它。

在数学术语中，向下取整函数由符号 ⌊ ⌋ 表示。

现在让我们来理解整除运算的工作原理。例如：

⌊36/5⌋

第 1 步： 首先执行除法。我们将 36 除以 5。

36 ÷ 5 = 7.2

第 2 步： 现在，我们将对除法得到的值，即 7.2，执行向下取整函数。

⌊7.2⌋=7

结果我们得到 7，这是 7.2 的向下取整值。因此，整除意味着先做除法，然后向下舍入到最接近的整数。

不同的编程语言提供了特定的内置函数或运算符来计算整除。一些例子如下：

1. 在 C++ 编程语言中，我们可以使用 floor() 方法。
2. 在 Java 编程语言中，我们可以使用 floor() 方法。
3. 在 Python 编程语言中，我们可以使用 // 运算符。

然而，本文我们将只讨论在 Python 中借助双反斜杠 (//) 运算符来使用整除运算。

使用 Python 理解整除

在 Python 编程语言中，整除用于将两个数相除，并将结果向下舍入到最接近的整数。

在深入探讨整除的概念之前，让我们简要回顾一下除法的含义以及 Python 中 math.floor() 函数的工作原理。

在 Python 中执行常规除法

在 Python 中，我们可以使用反斜杠 (/) 除法运算符来将两个数相除。让我们看下面的例子来演示这一点：

示例 1

输出

13 / 4 = 3.25

说明

在上面的代码片段中，我们定义了两个变量 a = 13 和 b = 4。然后我们使用反斜杠 (/) 除法运算符执行了除法运算，并将结果值存储在一个新变量 c 中。最后，我们打印了 c 的值。

正如我们所见，Python 中的除法与数学中的除法工作方式相同。

理解 Python 中的 math.floor() 函数

Python 中有一个内置的 math 模块，其中包含各种有用的数学工具用于计算。

math 模块的一个内置函数是 math.floor() 函数。该函数接受一个数值输入，并通过向下舍入到最接近的整数来返回其向下取整值。

让我们看下面的例子来演示这一点：

示例 2

输出

Floor value of 5.34 = 5
Floor value of -5.34 = 6

说明

在上面的代码片段中，我们从 math 模块导入了 floor() 函数。然后我们声明了两个变量 a = 5.34 和 b = -5.34。接着我们使用 floor() 函数计算了这两个变量的向下取整值，并将它们存储在新变量 c 和 d 中。最后，我们为用户打印了结果。

现在我们已经理解了在 Python 中除法和向下取整的概念。让我们接着看 Python 中与整除相关的细节。

在 Python 中执行整除

整除是 Python 中的一种运算，它允许我们将两个数相除，并将结果值向下舍入到最接近的整数。整除通过双反斜杠 (//) 运算符实现。其语法如下所示：

语法

其中

• res 是整除的结果值
• var_1 是被除数
• var_2 是除数

我们可以将整除看作是常规除法与 math.floor() 函数调用的结合。

注意：整除可以将任何数字向下舍入到最接近的整数。例如，3.99 仍然会被舍入为 3。

现在让我们看一个演示整除工作原理的例子。

示例 3

输出

Floor Division: 13 // 5 = 2
Regular Division: 13 / 5 = 2.6

说明

在上面的代码片段中，我们声明了两个变量 a = 13 和 b = 5。然后我们使用 // 运算符计算了整除值，并将结果存储在一个新变量 c 中。接着我们使用 / 运算符执行了常规除法，并将值存储在另一个变量 d 中。最后，我们打印了两个结果并进行了比较。

现在，让我们看另一个使用 math.floor() 函数的例子。

示例 4

输出

Floor Division using floor() function: 3
Floor Division using // operator: 3

说明

在上面的代码片段中，我们从 math 模块导入了 floor() 函数。然后我们声明了两个变量 a = 17 和 b = 5。接着我们使用 floor() 函数，将 a 除以 b，并将结果存储在变量 c 中。然后我们使用 // 运算符计算了整除值，并将结果存储在新变量 d 中。最后，我们打印了两个值并进行了比较。

对负数执行整除

我们也可以对负数执行整除。

对于负数，结果值仍然是向下舍入到最接近的整数。有些人可能会对“向下舍入”负数感到困惑，这意味着向远离零的方向舍入。例如，-2.3 向下取整为 -3。

让我们看一个演示对负数进行整除的例子。

示例 5

输出

Floor Division: -10 // 4 = -3

说明

在上面的代码片段中，我们声明了两个变量 a = -10 和 b = 4。然后我们使用 // 运算符计算了整除值，并将其存储在新变量 c 中。最后，我们为用户打印了该值。

使用常规除法，-10 / 4 会返回 -2.5；然而，使用整除，这个数字会被向下舍入到最接近的负整数，即 -3。

对浮点数执行整除

在 Python 中，我们也可以对浮点数执行整除。当对浮点数进行整除时，结果是一个表示最接近整数的浮点数。

让我们看下面的例子来演示使用浮点数进行整除。

示例 6

输出

17.5 // 3.3 = 5.0
10 // 2.5 = 4.0
13.4 // 3 = 4.0

说明

在上面的代码片段中，我们初始化了两个列表。然后我们使用 for 循环遍历这些列表的元素，计算每次整除运算的值，并为用户打印结果。

结果表明，我们可以观察到使用浮点数以及浮点数与整数进行的整除运算，返回的值是向下舍入到最接近整数的浮点数表示。

Python 中的整除和取模

在数学中，取模（modulo）是一个主要与整除相关的概念。我们也可以说，取模就是两个数相除后的余数。换句话说，我们可以用它来计算剩余的数量。

在 Python 中，我们可以使用百分号 (%) 运算符来计算取模。

让我们看一个例子来说明 Python 中整除和取模之间的关系。

示例 7.1

假设有 13 颗糖果和 4 个食客，我们可以借助整除来计算每个食客能得到多少颗糖果。

代码

输出

Number of Candies: 13
Number of Eaters: 4
The number of candies each eater gets: 3

说明

在上面的代码片段中，我们声明了一些变量来表示糖果和食客的数量。然后我们使用 // 运算符执行整除，以计算每个食客得到的糖果数量。最后，我们为用户打印了这些值。

现在让我们计算一下团队中总共分享了多少颗糖果。这一点不是很重要。

示例 7.2

我们将每人得到的糖果数量乘以食客的数量。

代码

输出

The total number of candies being shared among the group: 12

说明

在上面的代码片段中，我们通过将每人得到的糖果数乘以食客数，计算出团队中被分享的糖果总数，并为用户打印了结果值。

总共分享的完整糖果数量是 12 颗。然而，总糖果数是 13 颗。这句话意味着会剩下一颗糖果，并且不会被吃掉。

上面的例子描述了一种计算剩余数量的方法。然而，如果我们只对剩余数量感兴趣，我们可以直接使用取模来计算。

示例 7.3

假设有 13 颗糖果和 4 个食客，剩余的糖果数量是多少？

代码

输出

Number of Candies: 13
Number of Eaters: 4
Total number of Leftover Candies: 1

说明

在上面的代码片段中，我们声明了存储糖果和食客数量的变量。然后我们使用表示取模运算的 % 运算符计算了剩余的糖果数量。最后，我们为用户打印了一些语句和结果值。结果显示，剩余的糖果是 1 颗。

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

在 Python 中，整除和取模通过以下等式相关联：

其中

• a 是被除数。
• b 是除数。

例如，让我们用 13 颗糖果和 4 个食客来验证上述等式是否成立。

13 = 4 * (13 // 4) + (13 % 4)
13 = 4 * 3 + 1
13 = 13

至此，我们已经理解了 Python 中整除和取模的概念。现在，我们将看一个可以同时计算这两者的内置函数。

理解 Python 中的 divmod() 函数

Python 提供了一个名为 divmod() 的内置函数，它允许我们同时计算两个数值之间的整除和取模。

divmod() 函数的语法如下所示：

语法

其中

• res 是一个元组形式的结果。这个元组包含整除的结果和取模得到的余数。
• var_1 是被除数。
• var_2 是除数。

现在让我们看下面的例子来演示 divmod() 函数。

示例 8

假设有 13 颗糖果和 4 个食客，每个食客能得到多少颗完整的糖果，还剩下多少颗糖果？

代码

输出

Number of Candies: 13
Number of Eaters: 4
Number of Candies per eater: 3
Total number of Leftover Candies: 1

说明

在上面的代码片段中，我们声明了一些变量。我们使用 divmod() 函数为给定的变量计算了整除值和取模值。然后我们为用户打印了这些值。

理解整除的优先级

在 Python 中，整除运算符 // 与乘法 (*)、除法 (/) 和取模 (%) 具有相同的优先级水平。

这句话意味着，如果我们先乘法，然后整除，会先完成乘法，然后是整除，反之亦然。

然而，如果我们例如先将两个数相减，然后执行整除，整除运算将优先执行。

让我们看一个例子来演示这一点。

示例 9.1

输出

3 * 5 // 6 - 7 = -5

说明

在上面的代码片段中，我们声明了一些变量 a = 3, b = 5, c = 6, 和 d = 7。然后我们执行了一个运算，并将结果值存储在一个新变量 e 中。最后，我们为用户打印了这个值。

为了理解这个结果是如何计算出来的，我们可以按照正确的优先顺序在各项周围加上括号。

下面的例子描述了同样的情况：

示例 9.2

输出

(( 3 * 5 ) // 6 ) - 7 = -5

说明

在上面的代码片段中，我们声明了一些变量 a = 3, b = 5, c = 6, 和 d = 7。然后我们执行了相同的运算，但加上了括号，并将结果值存储在一个新变量 e 中。最后，我们为用户打印了这个值。

正如我们观察到的，我们得到了与前一个例子相同的结果，这意味着计算顺序是：

乘法 → 整除 → 减法

以下是上述计算的分步过程：

3 * 5 // 6 - 7
((3 * 5) // 6) - 7
(15 // 6) - 7
2 - 7
-5

我们已经正确地理解了整除及其在 Python 编程语言中的使用。

最后，我们将看一个整除的高级用例。在这种情况下，高级并不意味着困难，而是相当不寻常。

理解整除的高级用法

我们中有些人可能知道，在 Python 中我们也可以创建支持整除运算的自定义对象。这可以通过一个名为 __floordiv__() 的特殊方法来实现。

Python 中的 __floordiv__() 方法

Python 中的整除运算用于将两个数相除，并将结果向下舍入到最接近的整数。

它之所以能在底层工作，是因为数值类型实现了一个名为 __floordiv__() 的特殊方法。然后，每当我们在两个对象之间调用 // 运算符时，就会调用 __floordiv__() 方法。

在 Python 中，我们也可以直接调用 __floordiv__() 方法。让我们看下面的例子来演示这一点：

示例 10

输出

Using the // operator:
 31 // 7 = 4
Using the __floordiv__() method:
 ( 31 ).__floordiv__( 7 ) = 4

说明

在上面的代码片段中，我们声明了两个变量 a = 31 和 b = 7。然后我们分别使用 // 运算符和 __floordiv__() 方法执行了整除，并将它们的结果值存储在两个变量 c 和 d 中。最后，我们为用户打印了结果。

从上面显示的输出中，我们可以观察到两个表达式都产生了相同的结果。这是因为第一个表达式被转换成了第二个表达式。换句话说，这些调用是等效的。

现在，事情会变得有趣。让我们看下面的例子。

示例 11.1

在下面的例子中，我们将创建一个自定义类，用字符串表示整数值。然后我们将创建这个自定义类的两个对象，并对它们执行整除运算。

代码

输出

Traceback (most recent call last):
  File "D:\Python_programs\pycase.py", line 11, in 
    print(intOne // intTwo)
TypeError: unsupported operand type(s) for //: 'IntStr' and 'IntStr'

说明

在上面的代码片段中，我们定义了一个名为 IntStr 的类，它用字符串表示整数值。然后我们创建了 IntStr 类的两个对象。最后，我们尝试用 intOne 对象整除 intTwo 对象，并打印结果。

然而，上面的输出显示了一个 TypeError。这个错误消息揭示了 IntStr 对象不支持整除。这个错误是合理的。自定义类型怎么会知道如何对字符串对象进行整除呢？

然而，事实证明，我们可以让 IntStr 对象支持整除。

之前，我们学到每当我们调用 // 运算符时，我们实际上是在调用 __floordiv__() 方法。这个方法在对象的类的某个地方执行。例如，int 对象支持整除，因为 int 类应用了 __floordiv__() 方法。

像 __floordiv__() 这样的特殊方法有一个惊人的共同点，那就是我们可以将这些方法实现到自定义类中。换句话说，我们可以让自定义对象在 Python 编程语言中支持整除。

现在让我们看下面的例子来演示这一点。

示例 11.2

在下面的例子中，我们将把 __floordiv__() 方法实现到 IntStr 类中。然后我们将创建这个自定义类的两个对象，并对它们执行整除运算。

代码

输出

17 // 4 = 4

说明

在上面的代码片段中，我们定义了一个名为 IntStr 的类，它用字符串表示整数值。我们还在这个类中实现了 __floordiv__() 方法。这个方法从自身和另一个对象接受数值字符串值。我们将这些字符串值转换为整数，并对它们执行整除。然后我们将结果转换回字符串，并创建了一个新的 IntStr 对象。我们用两个对象实例化了 IntStr 类，并对它们执行了整除运算。最后，我们为用户打印了结果值。

现在我们成功地理解了如何让自定义类支持整除的方法。

如果我们不喜欢必须调用 object.val 才能看到结果，我们可以实现 __str__() 方法，以便在打印时直接返回值。

让我们看下面的例子来演示这一点。

示例 11.3

输出

17 // 4 = 4

说明

在上面的代码片段中，我们定义了一个名为 IntStr 的类，它用字符串表示整数值。我们还在这个类中实现了 __floordiv__() 方法。然后我们定义了 __str__() 方法，它在打印时直接返回字符串值。我们用两个对象实例化了 IntStr 类，并对它们执行了整除运算。最后，我们为用户打印了结果值。