Python中的地板除法|极客笔记

Python中的地板除法

在接下来的教程中，我们将使用Python编程语言来学习关于地板除法操作。

但在开始之前，让我们简单了解一下什么是地板除法。

理解地板除法

地板除法是一种常规的除法运算，只不过它返回的是最大可能的整数。这个整数可以小于常规除法的输出，也可以等于它。

地板函数在数学术语中用⌊ ⌋符号表示。

现在让我们来理解一下地板除法的工作原理。例如，⌊36/5⌋

步骤1: 首先进行除法运算。我们将 36 除以 5 。

36 ÷ 5 = 7.2

步骤2: 现在，我们将对除法后得到的值 7.2 进行地板函数运算。

⌊7.2⌋ = 7

结果是 7 ，它是 7.2 的地板值。因此，地板除法意味着除以并向下取整到最近的整数。

不同的编程语言提供特定的内置函数或操作符来计算地板除法。一些示例可能包括：

我们可以在C++编程语言中使用 floor() 方法。
我们可以在Java编程语言中使用 floor() 方法。
我们可以在Python编程语言中使用 // 操作符。

然而，我们只会讨论在Python中使用地板除法操作，使用 双反斜杠（//）操作符 。

使用Python理解地板除法

在Python编程语言中，地板除法用于除两个数，并将结果四舍五入到最近的整数。

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

在Python中进行常规除法

我们可以使用斜杠（ / ）除法运算符在Python中除两个数。让我们考虑以下示例来演示相同的功能：

示例1：

# declaring variables
a = 13
b = 4

# performing regular division
c = a / b

# printing the result
print(a, "/", b, "=", c)

输出:

13 / 4 = 3.25

说明：

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

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

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

Python中有一个内置的数学模块，包含了各种有用的数学工具来进行计算。

其中一个内置函数是 math.floor() 函数。该函数接受一个数值输入，并返回将其向下四舍五入为最接近的整数的结果。

让我们看一下下面的示例来演示这个函数：

示例2：

# importing the floor() function from the math module
from math import floor

# declaring the variables
a = 5.34
b = -5.34
# using the floor() function
c = floor(a)
d = floor(b)
# printing the values
print("Floor value of", a, "=", c)
print("Floor value of", b, "=", d)

输出:

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

在此例中：

res 是地板除法的结果值
var_1 是被除数
var_2 是除数

我们可以将地板除法视为常规除法与 math.floor() 函数调用的结合。

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

现在让我们来看一个演示地板除法工作原理的示例。

示例3：

# declaring the variables
a = 13
b = 5

# using the // operator
c = a // b
# comparing the floor value with regular division
d = a / b

# printing the values
print("Floor Division:", a, "//", b, "=", c)
print("Regular Division:", a, "/", b, "=", d)

输出：

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

解释：

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

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

示例4：

# importing the floor() function from the math module
from math import floor

# declaring the variables
a = 17
b = 5

# using the floor() function
c = floor(a / b)
# comparing the floor() function with // operator
d = a // b

# printing the values
print("Floor Division using floor() function:", c)
print("Floor Division using // operator:", d)

输出：

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

解释：

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

使用负数进行地板除法

我们也可以使用负数进行地板除法。

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

让我们来看一个演示使用负数进行地板除法的示例。

示例5：

# declaring the variables
a = -10
b = 4

# calculating floor value using // operator
c = a // b

# printing the value
print("Floor Division:", a, "//", b, "=", c)

输出：

Floor Division: -10 // 4 = -3

说明:

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

使用普通除法， -10 / 4 将返回 -2.5 ；然而，使用地板除法，这个数会向下取整到最近的负整数，即 -3 。

对浮点数执行地板除法

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

让我们考虑下面的示例，演示了使用浮点数进行地板除法。

示例6:

# initializing the lists
a = [17.5, 10, 13.4]
b = [3.3, 2.5, 3]

# using for-loop to iterate through the list
for i in range(0, 3):
    # calculating the floor division value
    c = a[i] // b[i]
    # printing the result
    print(a[i], "//", b[i], "=", c)

输出：

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

解释:

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

结果是，我们可以观察到，整除操作使用浮点数进行计算，并且浮点数与整数相除时，返回四舍五入到最近整数表示的浮点数。

在Python中的整除和取模

在数学中，取模是与整除密切相关的概念。我们还可以说，取模意味着两个数之间的除法余数。换句话说，我们可以用它来计算剩下的数量。

我们可以使用百分号（ % ）运算符在Python中计算模。

让我们来看一个示例，说明整除和取模在Python中的关系。

示例7.1：

给定13个糖果和4个吃货，我们可以使用整除来计算每个吃货得到的糖果数量。

代码：

# declaring variables
numberOfCandies = 13
numberOfEaters = 4

# using floor division to calculate the number of candies each eater gets
candiesPerEater = numberOfCandies // numberOfEaters

# printing values
print("Number of Candies:", numberOfCandies)
print("Number of Eaters:", numberOfEaters)
print("The number of candies each eater gets:", candiesPerEater)

输出：

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

说明：

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

现在让我们计算在群体中分享的糖果总数。这并不是非常重要。

示例7.2：

我们将每个人的糖果数量乘以食用者的数量。

代码：

# calculating the total number of candies being shared among the group
totalCandiesShared = candiesPerEater * numberOfEaters

# printing values
print("The total number of candies being shared among the group:", totalCandiesShared)

输出：

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

解释：

在上面的代码片段中，我们通过将每个人的糖果数量乘以吃糖果的人数来计算分组中共享的糖果总数，并将结果值打印给用户。

共享的完整糖果总数为 12 。然而，糖果的总数是 13 。这个陈述意味着会剩下一颗糖果没有被吃掉。

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

示例7.3：

给定 13 颗糖果和 4 个吃糖果的人，剩余糖果的数量是多少？

代码：

# declaring variables
numberOfCandies = 13
numberOfEaters = 4

# using modulo to calculate the leftover candies
leftoverCandies = numberOfCandies % numberOfEaters

# printing values
print("Number of Candies:", numberOfCandies)
print("Number of Eaters:", numberOfEaters)
print("Total number of Leftover Candies:", leftoverCandies)

输出：

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 = divmod(var_1, var_2)

其中：

res 是一个元组，包含了地板除法结果和取模结果。
var_1 是被除数。
var_2 是除数。

现在我们来看一个使用 divmod() 函数的示例。

示例8：

给定13个糖果和4个人，每个人能分到多少整个糖果，还剩下多少糖果？

代码：

# declaring variables
numberOfCandies = 13
numberOfEaters = 4

# using the divmod() function
nCandies, nLeftovers = divmod(numberOfCandies, numberOfEaters)

# printing values
print("Number of Candies:", numberOfCandies)
print("Number of Eaters:", numberOfEaters)
print("Number of Candies per eater:", nCandies)
print("Total number of Leftover Candies:", nLeftovers)

输出：

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

说明：

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

理解整数除法的优先级

在Python中，整数除法运算符 // 的优先级与乘法（ ***** ）、除法（ / ）和取余（ % ）的优先级相同。

这意味着如果我们进行乘法运算，然后进行整数除法运算，乘法会先完成，然后是整数除法；反之亦然。

但是，如果我们例如减去两个数，然后进行整数除法运算，整数除法操作会先进行。

让我们看一个演示相同情况的示例。

示例9.1：

# declaring some variables
a = 3
b = 5
c = 6
d = 7

# performing an operation
e = a * b // c - d

# printing the result
print(a, "*", b, "//", c, "-", d, "=", e)

输出：

3 * 5 // 6 - 7 = -5

解释：

在上述代码片段中，我们声明了一些变量： a = 3，b = 5，c = 6， 以及 d = 7 。然后我们执行了一个操作，并将结果值存储在一个新的变量 e 中。最后，我们将这个值打印给用户。

为了理解这个结果是如何计算的，我们可以根据正确的优先顺序在术语周围插入括号。

下面的示例展示了同样的情况：

示例9.2：

# declaring some variables
a = 3
b = 5
c = 6
d = 7

# performing an operation
e = ((a * b) // c) - d

# printing the result
print("((", a, "*", b, ") //", c, ") -", d, "=", e)

输出：

(( 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：

# declaring some variables
a = 31
b = 7

# performing floor division using the // operator
c = a // b
# performing floor division using the __floordiv__() method
d = (a).__floordiv__(b)

# printing the results of both operations
print("Using the // operator:\n", a, "//", b, "=", c)
print("Using the __floordiv__() method:\n (", a, ").__floordiv__(", b, ") =", c)

输出：

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

解释：

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

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

现在，事情将变得有趣。让我们考虑下面的示例。

示例11.1：

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

代码：

# creating a class representing integer values as string
class IntStr:
    def __init__(self, val):
        self.val = val

# instantiating the class with two objects
intOne = IntStr("17")
intTwo = IntStr("4")

# printing the result of the floor division operation
print(intOne // intTwo)

输出：

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：

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

代码：

# creating a class representing integer values as string
class IntStr:
    def __init__(self, val):
        self.val = val
    def __floordiv__(self, other):
        intOne = int(self.val)
        intTwo = int(other.val)
        res = intOne // intTwo

        return IntStr(str(res))

# instantiating the class with two objects
intOne = IntStr("17")
intTwo = IntStr("4")

# performing floor division operation
res = intOne // intTwo

# printing the result of the floor division operation
print(intOne.val, "//", intTwo.val, "=", res.val)

输出:

17 // 4 = 4

说明：

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

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

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

让我们考虑以下示例来说明这一点。

示例11.3：

# creating a class representing integer values as string
class IntStr:
    def __init__(self, val):
        self.val = val
    def __floordiv__(self, other):
        intOne = int(self.val)
        intTwo = int(other.val)
        res = intOne // intTwo

        return IntStr(str(res))
    def __str__(self):
        return self.val

# instantiating the class with two objects
intOne = IntStr("17")
intTwo = IntStr("4")

# performing floor division operation
res = intOne // intTwo

# printing the result of the floor division operation
print(intOne, "//", intTwo, "=", res)

输出：

17 // 4 = 4

解释：

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