Python 模数实践：如何使用 % 运算符

模运算符 int

大多数情况下，您将使用带整数的模运算符。模运算符与两个正整数一起使用时，将返回标准欧几里得除法的余数：

>>> 15 % 4
3

>>> 17 % 12
5

>>> 240 % 13
6

>>> 10 % 16
10

当心！就像除法运算符 ( /) 一样，ZeroDivisionError如果您尝试使用除数为 的模运算符，Python 将返回 a 0：

>>> 22 % 0
ZeroDivisionError: integer division or modulo by zero

接下来，您将了解如何将模运算符与float.

模运算符 float

与 类似int，与 a 一起使用的模运算符float将返回除法的余数，但作为一个float值：

>>> 12.5 % 5.5
1.5

>>> 17.0 % 12.0
5.0

将 afloat与模运算符一起使用的替代方法是使用math.fmod()对float值执行模运算：

>>> import math
>>> math.fmod(12.5, 5.5)
1.5

>>> math.fmod(8.5, 2.5)
1.0

由于计算模运算结果的方式，官方 Python 文档建议math.fmod()在处理float值时使用Python 模运算符math.fmod()。如果您使用负操作数，那么您可能会在math.fmod(x, y)和之间看到不同的结果x % y。您将在下一节中更详细地探索使用带负操作数的模运算符。

就像其他算术运算符一样，模运算符 andmath.fmod()在处理浮点算术时可能会遇到舍入和精度问题：

>>> 13.3 % 1.1
0.09999999999999964

>>> import math
>>> math.fmod(13.3, 1.1)
0.09999999999999964

如果保持浮点精度对您的应用程序很重要，那么您可以将模运算符与decimal.Decimal. 您将在本教程的稍后部分看到这一点。

带负操作数的模运算符

到目前为止，您所看到的所有模运算都使用了两个正操作数并返回了可预测的结果。当引入负操作数时，事情变得更加复杂。

事实证明，计算机确定具有负操作数的模运算结果的方式对于余数是否应采用被除数（被除数）或除数的符号（被除数的数）存在歧义。股息被分割）。不同的编程语言对此有不同的处理方式。

例如，在JavaScript 中，余数将采用被除数的符号：

8 % -3 = 2

此示例中的余数2为正，因为它采用被除数 的符号8。在 Python 和其他语言中，余数将采用除数的符号：

8 % -3 = -1

在这里，您可以看到余数-1，取除数 的符号-3。

您可能想知道为什么 JavaScript 中2的余数是，而 Python 中的余数是-1。这与不同语言如何确定模运算的结果有关。余数采用被除数符号的语言使用以下等式来确定余数：

r = a - (n * trunc(a/n))

这个方程有三个变量：

1. r 是余数。
2. a 是股息。
3. n 是除数。

trunc()在这个等式中意味着它使用截断除法，它总是将负数四舍五入到零。有关更多说明，请参阅下面使用8作为被除数和-3作为除数的模运算的步骤：

r = 8 - (-3 * trunc(8/-3))
r = 8 - (-3 * trunc(-2.666666666667))
r = 8 - (-3 * -2) # Rounded toward 0
r = 8 - 6
r = 2

在这里你可以看到像 JavaScript 这样的语言是如何得到余数的2。Python 和其他语言的余数采用除数的符号使用以下等式：

r = a - (n * floor(a/n))

floor()在这个等式中意味着它使用楼层划分。对于正数，楼层除法将返回与截断除法相同的结果。但是对于负数，地板除法会将结果向下舍入，远离零：

r = 8 - (-3 * floor(8/-3))
r = 8 - (-3 * floor(-2.666666666667))
r = 8 - (-3 * -3) # Rounded away from 0
r = 8 - 9
r = -1

在这里你可以看到结果是-1。

既然您了解了余数的差异从何而来，您可能想知道如果您只使用 Python，为什么这很重要。好吧，事实证明，并非 Python 中的所有模运算都是相同的。虽然与int和float类型一起使用的模将采用除数的符号，但其他类型不会。

当你比较的结果，你可以看到这样的例子8.0 % -3.0和math.fmod(8.0, -3.0)：

>>> 8.0 % -3
-1.0

>>> import math
>>> math.fmod(8.0, -3.0)
2.0

math.fmod()使用截断除法float取被除数的符号，而使用除数的符号。在本教程的后面，您将看到另一种使用被除数符号的 Python 类型，decimal.Decimal.

实践中的 Python 模运算符

现在您已经了解了 Python 模运算符的基础知识，您将查看一些使用它来解决实际编程问题的示例。有时，很难确定何时在代码中使用模运算符。下面的示例将使您了解它的多种使用方式。

def is_even(num):
    return num % 2 == 0

def is_odd(num):
    return num % 2 != 0

def is_odd(num):
    return num % 2 == 1

>>> -3 % 2
1

>>> 3 % -2
-1

>>> -2 % 2
0

>>> 2 % -2
0

如何在循环中以特定间隔运行代码

使用 Python 模运算符，您可以在循环内以特定时间间隔运行代码。这是通过使用循环的当前索引和模数执行模运算来完成的。模数确定特定于区间的代码在循环中运行的频率。

下面是一个例子：

def split_names_into_rows(name_list, modulus=3):
    for index, name in enumerate(name_list, start=1):
        print(f"{name:-^15} ", end="")
        if index % modulus == 0:
            print()
    print()

这段代码定义了split_names_into_rows()，它接受两个参数。name_list是应拆分为行的名称列表。modulus为操作设置一个模数，有效地确定每行中应该有多少个名字。split_names_into_rows()将循环name_list并在达到该modulus值后开始新的一行。

在更详细地分解函数之前，先看看它的实际效果：

>>> names = ["Picard", "Riker", "Troi", "Crusher", "Worf", "Data", "La Forge"]
>>> split_names_into_rows(names)
----Picard----- -----Riker----- -----Troi------
----Crusher---- -----Worf------ -----Data------
---La Forge----

如您所见，姓名列表已分为三行，每行最多三个姓名。modulus默认为3，但您可以指定任何数字：

>>> split_names_into_rows(names, modulus=4)
----Picard----- -----Riker----- -----Troi------ ----Crusher----
-----Worf------ -----Data------ ---La Forge----

>>> split_names_into_rows(names, modulus=2)
----Picard----- -----Riker-----
-----Troi------ ----Crusher----
-----Worf------ -----Data------
---La Forge----

>>> split_names_into_rows(names, modulus=1)
----Picard-----
-----Riker-----
-----Troi------
----Crusher----
-----Worf------
-----Data------
---La Forge----

现在您已经看到了运行中的代码，您可以分解它的作用。首先，它用于enumerate()迭代name_list，将列表中的当前项分配给 ，并将name计数值分配给index。您可以看到startfor的可选参数enumerate()设置为1。这意味着index计数将从而1不是开始0：

for index, name in enumerate(name_list, start=1):

接下来，在循环内部，函数调用print()输出name到当前行。endfor的参数print()是一个空字符串( "")，因此它不会在字符串末尾输出换行符。一个f 字符串被传递给print()，它使用Python 提供的字符串输出格式语法：

print(f"{name:-^15} ", end="")

在不涉及太多细节的情况下，:-^15语法告诉print()执行以下操作：

• 输出至少15字符，即使字符串短于 15 个字符。
• 将字符串居中对齐。
• 用连字符 ( -)填充字符串右侧或左侧的任何空格。

现在名称已打印到行，看看主要部分split_names_into_rows()：

if index % modulus == 0:
    print()

此代码采用当前迭代，index并使用模运算符将其与 进行比较modulus。如果结果等于0，则它可以运行特定于区间的代码。在这种情况下，该函数调用print()添加一个换行符，它开始一个新行。

上面的代码只是一个例子。使用该模式index % modulus == 0可以让您在循环中以特定间隔运行不同的代码。在下一节中，您将更深入地了解这个概念并查看循环迭代。

如何创建循环迭代

循环迭代描述了一种迭代，一旦到达某个点就会重置。通常，这种迭代方式用于将迭代的索引限制在一定范围内。

您可以使用模运算符来创建循环迭代。看一个使用turtle库绘制形状的示例：

import turtle
import random

def draw_with_cyclic_iteration():
    colors = ["green", "cyan", "orange", "purple", "red", "yellow", "white"]

    turtle.bgcolor("gray8") # Hex: #333333
    turtle.pendown()
    turtle.pencolor(random.choice(colors)) # First color is random

    i = 0 # Initial index

    while True:
        i = (i + 1) % 6 # Update the index
        turtle.pensize(i) # Set pensize to i
        turtle.forward(225)
        turtle.right(170)

        # Pick a random color
        if i == 0:
            turtle.pencolor(random.choice(colors))

上面的代码使用一个无限循环来绘制一个重复的星形。每六次迭代后，它会改变笔的颜色。笔的大小随着每次迭代而增加，直到i重新设置回0。如果你运行代码，那么你应该得到类似的东西：

如何转换单位

在本节中，您将了解如何使用模运算符来转换单位。以下示例采用较小的单位并将它们转换为较大的单位，而不使用小数。模运算符用于确定当较小的单位不能被较大的单位整除时可能存在的任何余数。

在第一个示例中，您将英寸转换为英尺。模运算符用于获取未均匀划分为英尺的剩余英寸。楼层除法运算符 ( //) 用于将总英尺数向下取整：

def convert_inches_to_feet(total_inches):
    inches = total_inches % 12
    feet = total_inches // 12

    print(f"{total_inches} inches = {feet} feet and {inches} inches")

这是正在使用的函数的示例：

>>> convert_inches_to_feet(450)
450 inches = 37 feet and 6 inches

正如您从输出中看到的那样，450 % 12返回值6是未均匀划分为英尺的剩余英寸。的结果450 // 12是37，这是英寸被平均划分的总英尺数。

在下一个示例中，您可以更进一步。convert_minutes_to_days()取一个整数 ，total_mins代表分钟数，并以天、小时和分钟为单位输出时间段：

def convert_minutes_to_days(total_mins):
    days = total_mins // 1440
    extra_minutes = total_mins % 1440

    hours = extra_minutes // 60
    minutes = extra_minutes % 60

    print(f"{total_mins} = {days} days, {hours} hours, and {minutes} minutes")

分解一下，您可以看到该函数执行以下操作：

1. 用 确定可整除的总天数total_mins // 1440，其中1440是一天中的分钟数
2. 计算任何extra_minutes剩余的total_mins % 1440
3. 使用extra_minutes来获得可整除的hours和任何额外的minutes

你可以在下面看到它是如何工作的：

>>> convert_minutes_to_days(1503)
1503 = 1 days, 1 hours, and 3 minutes

>>> convert_minutes_to_days(3456)
3456 = 2 days, 9 hours, and 36 minutes

>>> convert_minutes_to_days(35000)
35000 = 24 days, 7 hours, and 20 minutes

虽然上面的例子只涉及将英寸转换为英尺和分钟转换为天，但您可以使用任何类型的单位和模运算符将较小的单位转换为较大的单位。

def convert_inches_to_feet_updated(total_inches):
    feet, inches = divmod(total_inches, 12)
    print(f"{total_inches} inches = {feet} feet and {inches} inches")

>>> convert_inches_to_feet(450)
450 inches = 37 feet and 6 inches

>>> convert_inches_to_feet_updated(450)
450 inches = 37 feet and 6 inches

def convert_minutes_to_days_updated(total_mins):
    days, extra_minutes = divmod(total_mins, 1440)
    hours, minutes = divmod(extra_minutes, 60)

    print(f"{total_mins} = {days} days, {hours} hours, and {minutes} minutes")

>>> convert_minutes_to_days(1503)
1503 = 1 days, 1 hours, and 3 minutes

>>> convert_minutes_to_days_updated(1503)
1503 = 1 days, 1 hours, and 3 minutes

现在您已经了解了如何使用模运算符来转换单位，在下一节中，您将了解如何使用模运算符来检查素数。

如何确定一个数是否为质数

在下一个示例中，您将了解如何使用 Python 模运算符来检查数字是否为质数。质数是任何只包含两个因数1和它本身的数。素数的一些例子是2，3，5，7，23，29，59，83，和97。

下面的代码是使用模运算符确定数字素数的实现：

def check_prime_number(num):
    if num < 2:
        print(f"{num} must be greater than or equal to 2 to be prime.")
        return

    factors = [(1, num)]
    i = 2

    while i * i <= num:
        if num % i == 0:
            factors.append((i, num//i))
        i += 1

    if len(factors) > 1:
        print(f"{num} is not prime. It has the following factors: {factors}")
    else:
        print(f"{num} is a prime number")

这段代码定义了check_prime_number()，它接受参数num并检查它是否是素数。如果是，则会显示一条消息，说明这num是一个质数。如果它不是质数，则会显示一条消息，其中包含该数字的所有因数。

在您更仔细地查看函数之前，以下是使用一些不同数字的结果：

>>> check_prime_number(44)
44 is not prime. It has the following factors: [(1, 44), (2, 22), (4, 11)]

>>> check_prime_number(53)
53 is a prime number

>>> check_prime_number(115)
115 is not prime. It has the following factors: [(1, 115), (5, 23)]

>>> check_prime_number(997)
997 is a prime number

深入研究代码，您可以看到它从检查 ifnum小于开始2。质数只能大于或等于2。如果num小于2，则函数不需要继续。它将print()一条消息和return：

if num < 2:
    print(f"{num} must be greater than or equal to 2 to be prime.")
    return

如果num大于2，则函数检查是否num为素数。为了检查这一点，该函数迭代2和 的平方根之间的所有数字，num以查看是否有任何数字均分为num。如果其中一个数被整除，则已找到一个因数，并且num不能是质数。

这是函数的主要部分：

factors = [(1, num)]
i = 2

while i * i <= num:
    if num % i == 0:
        factors.append((i, num//i))
    i += 1

这里有很多东西要解压，所以让我们一步一步来。

首先，factors使用初始因子创建一个列表，(1, num)。此列表将用于存储找到的任何其他因素：

factors = [(1, num)]

接下来，从 开始2，代码递增，i直到达到 的平方根num。在每次迭代中，它都会num与i进行比较，看看它是否可以被均匀整除。代码只需要检查并包括平方根，num因为它不包含任何高于此的因素：

i = 2

while i * i <= num:
    if num % i == 0:
        factors.append((i, num//i))
    i += 1

num该函数没有尝试确定 的平方根，而是使用while循环来查看i * i <= num。只要i * i <= num，循环还没有达到 的平方根num。

在while循环内部，模运算符检查是否可以num被 整除i：

factors = [(1, num)]
i = 2 # Start the initial index at 2

while i * i <= num:
    if num % i == 0:
        factors.append((i, num//i))
    i += 1

如果 可num被 整除i，则i是 的因子num，并将因子的元组添加到factors列表中。

一旦while循环完成，看到代码检查，如果发现任何其他因素：

if len(factors) > 1:
    print(f"{num} is not prime. It has the following factors: {factors}")
else:
    print(f"{num} is a prime number")

如果factors列表中存在多个元组，则num不能是质数。对于非质数，因子被打印出来。对于素数，该函数会打印一条消息，说明它num是一个素数。

凯撒密码

您将看到的第一个密码是Caesar 密码，它以 Julius Caesar 的名字命名，他用它来秘密地传递信息。它是一种使用字母替换来加密文本字符串的替换密码。

凯撒密码的工作原理是将一个要加密的字母在字母表中向左或向右移动一定数量的位置。位于该位置的任何字母都用作加密字符。这个相同的移位值适用于字符串中的所有字符。

例如，如果移位为5，则将A向上移位五个字母以变为F、B将变为G，依此类推。您可以在下面看到REALPYTHON移位为 的文本的加密过程5：

得到的密码是WJFQUDYMTS。

解密密码是通过反转移位来完成的。加密和解密过程都可以用以下表达式来描述，其中char_index是字母表中字符的索引：

encrypted_char_index = (char_index + shift) % 26
decrypted_char_index = (char_index - shift) % 26

此密码使用模运算符来确保在移动字母时，如果到达字母表的末尾，索引将环绕。既然您知道此密码的工作原理，请看一下实现：

import string

def caesar_cipher(text, shift, decrypt=False):
    if not text.isascii() or not text.isalpha():
        raise ValueError("Text must be ASCII and contain no numbers.")

    lowercase = string.ascii_lowercase
    uppercase = string.ascii_uppercase
    result = ""

    if decrypt:
        shift = shift * -1

    for char in text:
        if char.islower():
            index = lowercase.index(char)
            result += lowercase[(index + shift) % 26]
        else:
            index = uppercase.index(char)
            result += uppercase[(index + shift) % 26]

    return result

这段代码定义了一个名为 的函数caesar_cipher()，它有两个必需参数和一个可选参数：

• text 是要加密或解密的文本。
• shift 是移动每个字母的位置数。
• decrypt是一个布尔值，用于设置是否text应该解密。

decrypt包括在内，以便可以使用单个函数来处理加密和解密。此实现只能处理字母字符，因此该函数首先检查textASCII 编码中的字母字符：

def caesar_cipher(text, shift, decrypt=False):
    if not text.isascii() or not text.isalpha():
        raise ValueError("Text must be ASCII and contain no numbers.")

然后该函数定义了三个变量来存储lowercaseASCII 字符、uppercaseASCII 字符以及加密或解密的结果：

lowercase = string.ascii_lowercase # "abcdefghijklmnopqrstuvwxyz"
uppercase = string.ascii_uppercase # "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
result = ""

接下来，如果该函数被用来解密text，然后将其乘以shift通过-1使其移位向后：

if decrypt:
    shift = shift * -1

最后，caesar_cipher()循环遍历 in 中的各个字符text并对每个 执行以下操作char：

1. 检查char是小写还是大写。
2. 获取index的char无论是在lowercase或uppercaseASCII名单。
3. 添加 ashift以index确定要使用的密码字符的索引。
4. 用于% 26确保班次将回绕到字母表的开头。
5. 将密码字符附加到result字符串。

循环完成对text值的迭代后，result返回：

for char in text:
    if char.islower():
        index = lowercase.index(char)
        result += lowercase[(index + shift) % 26]
    else:
        index = uppercase.index(char)
        result += uppercase[(index + shift) % 26]

return result

这是完整的代码：

import string

def caesar_cipher(text, shift, decrypt=False):
    if not text.isascii() or not text.isalpha():
        raise ValueError("Text must be ASCII and contain no numbers.")

    lowercase = string.ascii_lowercase
    uppercase = string.ascii_uppercase
    result = ""

    if decrypt:
        shift = shift * -1

    for char in text:
        if char.islower():
            index = lowercase.index(char)
            result += lowercase[(index + shift) % 26]
        else:
            index = uppercase.index(char)
            result += uppercase[(index + shift) % 26]

    return result

现在使用meetMeAtOurHideOutAtTwo移位为的文本在 Python REPL 中运行代码10：

>>> caesar_cipher("meetMeAtOurHideOutAtTwo", 10)
woodWoKdYebRsnoYedKdDgy

加密结果为woodWoKdYebRsnoYedKdDgy。使用此加密文本，您可以运行解密以获取原始文本：

>>> caesar_cipher("woodWoKdYebRsnoYedKdDgy", 10, decrypt=True)
meetMeAtOurHideOutAtTwo

在介绍密码学时，使用凯撒密码很有趣。虽然凯撒密码很少单独使用，但它是更复杂的替换密码的基础。在下一节中，您将了解 Caesar 密码的一个后代，即 Vigenère 密码。

维吉尼亚密码

的V @ genere加密是一个多码替代密码。为了执行加密，它对输入文本的每个字母使用不同的凯撒密码。Vigenère 密码使用关键字来确定应该使用哪种凯撒密码来查找密码字母。

您可以在下图中看到加密过程的示例。在此示例中，输入文本REALPYTHON使用关键字加密MODULO：

使用 Python 模运算符 decimal.Decimal

在本教程的前面部分，您看到了如何将模运算符用于数字类型，例如int和float以及math.fmod()。您还可以使用Decimal来自decimal模块的模运算符。decimal.Decimal当您希望对浮点算术运算的精度进行离散控制时使用。

以下是使用整数decimal.Decimal和模运算符的一些示例：

>>> import decimal
>>> decimal.Decimal(15) % decimal.Decimal(4)
Decimal('3')

>>> decimal.Decimal(240) % decimal.Decimal(13)
Decimal('6')

下面是一些与decimal.Decimal模运算符一起使用的浮点数：

>>> decimal.Decimal("12.5") % decimal.Decimal("5.5")
Decimal('1.5')

>>> decimal.Decimal("13.3") % decimal.Decimal("1.1")
Decimal('0.1')

decimal.Decimal除非操作数之一为负数，否则所有模运算都返回与其他数值类型相同的结果。与int和不同float，但与 一样math.fmod()，结果decimal.Decimal使用被除数的符号。

看看下面的示例，比较使用模运算符与标准int和float值以及与 的结果decimal.Decimal：

>>> -17 % 3
1 # Sign of the divisor

>>> decimal.Decimal(-17) % decimal.Decimal(3)
Decimal(-2) # Sign of the dividend

>>> 17 % -3
-1 # Sign of the divisor

>>> decimal.Decimal(17) % decimal.Decimal(-3)
Decimal("2") # Sign of dividend

>>> -13.3 % 1.1
1.0000000000000004 # Sign of the divisor

>>> decimal.Decimal("-13.3") % decimal.Decimal("1.1")
Decimal("-0.1") # Sign of the dividend

与 相比math.fmod()，decimal.Decimal符号相同，但精度不同：

>>> decimal.Decimal("-13.3") % decimal.Decimal("1.1")
Decimal("-0.1")

>>> math.fmod(-13.3, 1.1)
-0.09999999999999964

从上面的示例中可以看出，使用decimal.Decimal和 模运算符类似于使用其他数字类型。您只需要记住在使用负操作数时它如何确定结果的符号。

在下一节中，您将了解如何覆盖类中的模运算符以自定义其行为。

在自定义类中使用 Python 模运算符

Python数据模型允许您覆盖 Python 对象中的内置方法以自定义其行为。在本节中，您将了解如何进行覆盖，.__mod__()以便您可以在自己的类中使用模运算符。

对于此示例，您将使用一个Student类。本课程将跟踪学生学习的时间。这是初始Student类：

class Student:
    def __init__(self, name):
        self.name = name
        self.study_sessions = []

    def add_study_sessions(self, sessions):
        self.study_sessions += sessions

在Student类初始化为name参数，并开始与一个空表，study_sessions，将举行代表每节研究分钟整数列表。还有.add_study_sessions()，它需要一个sessions参数，该参数应该是要添加到study_sessions.

现在，如果您还记得上面的转换单位部分，convert_minutes_to_day()使用 Python 模运算符转换total_mins为天、小时和分钟。您现在将实现该方法的修改版本，以了解如何将自定义类与模运算符一起使用：

def total_study_time_in_hours(student, total_mins):
    hours = total_mins // 60
    minutes = total_mins % 60

    print(f"{student.name} studied {hours} hours and {minutes} minutes")

您可以在Student课堂上使用此功能来显示 aStudent学习的总小时数。结合Student上面的类，代码将如下所示：

class Student:
    def __init__(self, name):
        self.name = name
        self.study_sessions = []

    def add_study_sessions(self, sessions):
        self.study_sessions += sessions

def total_study_time_in_hours(student, total_mins):
    hours = total_mins // 60
    minutes = total_mins % 60

    print(f"{student.name} studied {hours} hours and {minutes} minutes")

如果你在 Python REPL 中加载这个模块，那么你可以像这样使用它：

>>> jane = Student("Jane")
>>> jane.add_study_sessions([120, 30, 56, 260, 130, 25, 75])
>>> total_mins = sum(jane.study_sessions)
>>> total_study_time_in_hours(jane, total_mins)
Jane studied 11 hours and 36 minutes

上面的代码打印出jane学习的总小时数。此版本的代码有效，但它需要额外的求和步骤study_sessions才能total_mins在调用total_study_time_in_hours().

以下是修改Student类以简化代码的方法：

class Student:
    def __init__(self, name):
        self.name = name
        self.study_sessions = []

    def add_study_sessions(self, sessions):
        self.study_sessions += sessions

    def __mod__(self, other):
        return sum(self.study_sessions) % other

    def __floordiv__(self, other):
        return sum(self.study_sessions) // other

通过覆盖.__mod__()and .__floordiv__()，您可以使用Student带有模运算符的实例。计算sum()ofstudy_sessions也包含在Student类中。

通过这些修改，您可以Student直接在total_study_time_in_hours(). 由于total_mins不再需要，您可以将其删除：

def total_study_time_in_hours(student):
    hours = student // 60
    minutes = student % 60

    print(f"{student.name} studied {hours} hours and {minutes} minutes")

修改后的完整代码如下：

class Student:
    def __init__(self, name):
        self.name = name
        self.study_sessions = []

    def add_study_sessions(self, sessions):
        self.study_sessions += sessions

    def __mod__(self, other):
        return sum(self.study_sessions) % other

    def __floordiv__(self, other):
        return sum(self.study_sessions) // other

def total_study_time_in_hours(student):
    hours = student // 60
    minutes = student % 60

    print(f"{student.name} studied {hours} hours and {minutes} minutes")

现在，调用 Python REPL 中的代码，您可以看到它更加简洁：

>>> jane = Student("Jane")
>>> jane.add_study_sessions([120, 30, 56, 260, 130, 25, 75])
>>> total_study_time_in_hours(jane)
Jane studied 11 hours and 36 minutes

通过覆盖.__mod__()，您可以让自定义类的行为更像 Python 的内置数字类型。