Python魔法之旅-魔法方法(03)

avatar
作者
猴君
阅读量:0

目录

 一、概述

1、定义

2、作用

二、主要应用场景

1、构造和析构

2、操作符重载

3、字符串和表示

4、容器管理

5、可调用对象

6、上下文管理

7、属性访问和描述符

8、迭代器和生成器

9、数值类型

10、复制和序列化

11、自定义元类行为

12、自定义类行为

13、类型检查和转换

14、自定义异常

三、学习方法

1、理解基础

2、查阅文档

3、编写示例

4、实践应用

5、阅读他人代码

6、参加社区讨论

7、持续学习

8、练习与总结

9、注意兼容性

10、避免过度使用

四、魔法方法

11、__delitem__方法

11-1、语法

11-2、参数

11-3、功能

11-4、返回值

11-5、说明

11-6、用法

12、__dir__方法

12-1、语法

12-2、参数

12-3、功能

12-4、返回值

12-5、说明

12-6、用法

13、__divmod__方法

13-1、语法

13-2、参数

13-3、功能

13-4、返回值

13-5、说明

13-6、用法

五、推荐阅读

1、Python筑基之旅

2、Python函数之旅

3、Python算法之旅

4、博客个人主页

 一、概述

1、定义

        魔法方法(Magic Methods/Special Methods,也称特殊方法或双下划线方法)是Python中一类具有特殊命名规则的方法,它们的名称通常以双下划线(`__`)开头和结尾

        魔法方法用于在特定情况下自动被Python解释器调用,而不需要显式地调用它们,它们提供了一种机制让你可以定义自定义类时具有与内置类型相似的行为。

2、作用

        魔法方法允许开发者重载Python中的一些内置操作或函数的行为,从而为自定义的类添加特殊的功能

二、主要应用场景

1、构造和析构

1-1、__init__(self, [args...]):在创建对象时初始化属性。
1-2、__new__(cls, [args...]):在创建对象时控制实例的创建过程(通常与元类一起使用)。
1-3、__del__(self):在对象被销毁前执行清理操作,如关闭文件或释放资源。

2、操作符重载

2-1、__add__(self, other)、__sub__(self, other)、__mul__(self, other)等:自定义对象之间的算术运算。
2-2、__eq__(self, other)、__ne__(self, other)、__lt__(self, other)等:定义对象之间的比较操作。

3、字符串和表示

3-1、__str__(self):定义对象的字符串表示,常用于print()函数。
3-2、__repr__(self):定义对象的官方字符串表示,用于repr()函数和交互式解释器。

4、容器管理

4-1、__getitem__(self, key)、__setitem__(self, key, value)、__delitem__(self, key):用于实现类似列表或字典的索引访问、设置和删除操作。
4-2、__len__(self):返回对象的长度或元素个数。

5、可调用对象

5-1、__call__(self, [args...]):允许对象像函数一样被调用。

6、上下文管理

6-1、__enter__(self)、__exit__(self, exc_type, exc_val, exc_tb):用于实现上下文管理器,如with语句中的对象。

7、属性访问和描述符

7-1、__getattr__, __setattr__, __delattr__:这些方法允许对象在访问或修改不存在的属性时执行自定义操作。
7-2、描述符(Descriptors)是实现了__get__, __set__, 和__delete__方法的对象,它们可以控制对另一个对象属性的访问。

8、迭代器和生成器

8-1、__iter__和__next__:这些方法允许对象支持迭代操作,如使用for循环遍历对象。
8-2、__aiter__, __anext__:这些是异步迭代器的魔法方法,用于支持异步迭代。

9、数值类型

9-1、__int__(self)、__float__(self)、__complex__(self):定义对象到数值类型的转换。
9-2、__index__(self):定义对象用于切片时的整数转换。

10、复制和序列化

10-1、__copy__和__deepcopy__:允许对象支持浅复制和深复制操作。
10-2、__getstate__和__setstate__:用于自定义对象的序列化和反序列化过程。

11、自定义元类行为

11-1、__metaclass__(Python 2)或元类本身(Python 3):允许自定义类的创建过程,如动态创建类、修改类的定义等。

12、自定义类行为

12-1、__init__和__new__:用于初始化对象或控制对象的创建过程。
12-2、__init_subclass__:在子类被创建时调用,允许在子类中执行一些额外的操作。

13、类型检查和转换

13-1、__instancecheck__和__subclasscheck__:用于自定义isinstance()和issubclass()函数的行为。

14、自定义异常

14-1、你可以通过继承内置的Exception类来创建自定义的异常类,并定义其特定的行为。

三、学习方法

        要学好Python的魔法方法,你可以遵循以下方法及步骤:

1、理解基础

        首先确保你对Python的基本语法、数据类型、类和对象等概念有深入的理解,这些是理解魔法方法的基础。

2、查阅文档

        仔细阅读Python官方文档中关于魔法方法的部分,文档会详细解释每个魔法方法的作用、参数和返回值。你可以通过访问Python的官方网站或使用help()函数在Python解释器中查看文档。

3、编写示例

        为每个魔法方法编写简单的示例代码,以便更好地理解其用法和效果,通过实际编写和运行代码,你可以更直观地感受到魔法方法如何改变对象的行为。

4、实践应用

        在实际项目中尝试使用魔法方法。如,你可以创建一个自定义的集合类,使用__getitem__、__setitem__和__delitem__方法来实现索引操作。只有通过实践应用,你才能更深入地理解魔法方法的用途和重要性。

5、阅读他人代码

        阅读开源项目或他人编写的代码,特别是那些使用了魔法方法的代码,这可以帮助你学习如何在实际项目中使用魔法方法。通过分析他人代码中的魔法方法使用方式,你可以学习到一些新的技巧和最佳实践。

6、参加社区讨论

        参与Python社区的讨论,与其他开发者交流关于魔法方法的使用经验和技巧,在社区中提问或回答关于魔法方法的问题,这可以帮助你更深入地理解魔法方法并发现新的应用场景。

7、持续学习

        Python语言和其生态系统不断发展,新的魔法方法和功能可能会不断被引入,保持对Python社区的关注,及时学习新的魔法方法和最佳实践。

8、练习与总结

        多做练习,通过编写各种使用魔法方法的代码来巩固你的理解,定期总结你学到的知识和经验,形成自己的知识体系。

9、注意兼容性

        在使用魔法方法时,要注意不同Python版本之间的兼容性差异,确保你的代码在不同版本的Python中都能正常工作。

10、避免过度使用

        虽然魔法方法非常强大,但过度使用可能会导致代码难以理解和维护,在编写代码时,要权衡使用魔法方法的利弊,避免滥用。

        总之,学好Python的魔法方法需要不断地学习、实践和总结,只有通过不断地练习和积累经验,你才能更好地掌握这些强大的工具,并在实际项目中灵活运用它们。

四、魔法方法

11、__delitem__方法

11-1、语法
__delitem__(self, key, /)     Delete self[key]
11-2、参数

11-2-1、self(必须)一个对实例对象本身的引用,在类的所有方法中都会自动传递。

11-2-2、key(必须)表示想要从对象中删除的元素的键或索引

11-2-3、/(可选)这是从Python 3.8开始引入的参数注解语法,它表示这个方法不接受任何位置参数(positional-only parameters)之后的关键字参数(keyword arguments)。

11-3、功能

        用于定义当从容器中删除一个元素时应该执行的操作。

11-4、返回值

        当这个方法被调用时,它应该执行删除操作,但不应该返回任何值(或者更具体地说,它应该返回None)。

11-5、说明

        对于列表,key通常是一个整数索引;对于字典,key通常是一个键。

11-6、用法
# 011、__delitem__方法: # 1、简单的自定义字典 # 定义一个名为CustomDict的类,该类继承自内置的dict类 class CustomDict(dict):     # 重写父类dict中的__delitem__方法,该方法在删除字典中的键值对时被调用     def __delitem__(self, key):         # 打印出将要被删除的键         print(f"Deleting key: {key}")          # 调用父类dict的__delitem__方法来实际删除指定的键值对         # 使用super()函数可以调用当前类继承的父类(或多个父类)中的方法         super().__delitem__(key) # 判断当前模块是否作为主程序运行(而不是被导入为模块) if __name__ == '__main__':     # 创建一个CustomDict对象d,并初始化时传入一个字典{'a': 1, 'b': 2}     d = CustomDict({'a': 1, 'b': 2})      # 删除d中键为'a'的键值对     # 这会触发CustomDict类中定义的__delitem__方法,打印出"Deleting key: a"     del d['a']  # 输出: Deleting key: a  # 2、带有额外检查的字典 # 定义一个名为CheckedDict的类,该类继承自内置的dict类 class CheckedDict(dict):     # 重写父类dict中的__delitem__方法,用于在删除字典项之前进行检查     def __delitem__(self, key):         # 检查键key是否存在于当前字典中         if key not in self:             # 如果键不存在,则抛出一个KeyError异常,并说明键不存在             raise KeyError(f"Key {key} does not exist.")         # 如果键存在,则打印出正在删除的键         print(f"Deleting key: {key}")          # 调用父类dict的__delitem__方法来实际删除指定的键值对         super().__delitem__(key) # 判断当前模块是否作为主程序运行(而不是被导入为模块) if __name__ == '__main__':     # 创建一个CheckedDict对象cd,并初始化时传入一个字典{'a': 1, 'b': 2}     cd = CheckedDict({'a': 1, 'b': 2})      # 删除cd中键为'a'的键值对     # 这会触发CheckedDict类中定义的__delitem__方法,打印出"Deleting key: a"     del cd['a']  # 输出: Deleting key: a      # 尝试删除cd中键为'c'的键值对     # 因为'c'不在cd中,所以会触发CheckedDict类中定义的__delitem__方法中的KeyError异常     del cd['c']  # 引发 KeyError: Key c does not exist.  # 3、自定义列表,删除元素时更新索引 class IndexedList:     # 初始化方法,创建一个空的列表用于存储元素,和一个空的字典用于存储元素和它们的索引     def __init__(self):         self.items = []  # 列表,用于存储元素         self.indices = {}  # 字典,用于存储元素和它们的索引     # 添加元素到列表的末尾,并在indices字典中记录其索引     def append(self, item):         index = len(self.items)  # 获取当前列表的长度,即新元素的索引         self.items.append(item)  # 将元素添加到列表的末尾         self.indices[item] = index  # 在indices字典中记录元素和它的索引     # 删除指定索引或元素的方法     def __delitem__(self, key):         # 如果key是整数,则认为它是索引         if isinstance(key, int):             index = key  # 索引就是key             item = self.items[index]  # 从列表中根据索引获取元素         # 如果key在indices字典中,则认为它是元素的值         elif key in self.indices:             index = self.indices[key]  # 从indices字典中获取元素的索引             # 注意:这里item应该设置为列表中的元素,而不是key本身             # 但由于代码逻辑,我们保持item = key,这在key是元素值时是正确的             item = key         # 如果key既不是整数也不在indices字典中,则抛出KeyError         else:             raise KeyError(f"Key {key} does not exist.")         # 打印正在删除的元素和它的索引         print(f"Deleting item at index {index}: {item}")         # 从列表中删除元素         del self.items[index]         # 从indices字典中删除对应的条目         # 注意:这里应该使用item对应的值,而不是item本身(如果key是索引的话)         # 但由于之前的代码逻辑,这里直接使用item是可行的(如果key是元素值)         del self.indices[item] if __name__ == '__main__':     il = IndexedList()  # 创建一个IndexedList对象     il.append('apple')  # 添加'apple'元素,其索引为0     il.append('banana')  # 添加'banana'元素,其索引为1     del il[1]  # 删除索引为1的元素(即'banana'),并输出:Deleting item at index 1: banana  # 4、带有删除日志的列表 class LoggedList(list):     # 重写list类的__delitem__方法,以便在删除元素时记录日志     def __delitem__(self, index):         # 使用pop方法删除指定索引的元素,并返回该元素         # 注意:pop方法会直接修改列表,删除指定索引的元素并返回它         item = self.pop(index)  # 使用pop删除并返回元素         # 打印正在删除的元素         print(f"Deleting item: {item}") if __name__ == '__main__':     # 创建一个LoggedList对象,并初始化列表为[1, 2, 3]     ll = LoggedList([1, 2, 3])     # 删除索引为1的元素(即值为2的元素)     # 由于LoggedList类重写了__delitem__方法,所以在删除时会调用该方法并记录日志     del ll[1]  # 输出: Deleting item: 2  # 5、限制删除操作的列表 class RestrictedList(list):     # 重写父类list的__delitem__方法,增加索引检查     def __delitem__(self, index):         # 检查索引是否在有效范围内(包括0到len(self)-1)         if not 0 <= index < len(self):             # 如果索引超出范围,则抛出IndexError异常             raise IndexError(f"Index {index} out of range.")             # 如果索引有效,则调用父类list的__delitem__方法来删除元素         super().__delitem__(index) if __name__ == '__main__':     # 创建一个RestrictedList对象,并初始化列表为[1, 2, 3]     rl = RestrictedList([1, 2, 3])     # 删除索引为1的元素(即值为2的元素),这是正常删除     del rl[1]  # 正常删除     # 打印列表rl,此时应该输出:[1, 3]     print(rl)  # 输出:[1, 3]      # 尝试删除索引为3的元素,由于索引超出范围,将引发IndexError异常     del rl[3]  # 引发 IndexError: Index 3 out of range.     # 注意:由于IndexError异常,接下来的代码(如果有的话)将不会被执行  # 6、删除元素时触发回调的列表 class CallbackList(list):     # 初始化方法,除了继承自list的初始化外,还接受一个回调函数作为参数     def __init__(self, callback):         # 存储传入的回调函数         self.callback = callback         # 调用父类list的初始化方法         super().__init__()     # 重写list类的__delitem__方法,以便在删除元素时执行回调函数并打印信息     def __delitem__(self, index):         # 使用pop方法删除指定索引的元素,并返回该元素         item = self.pop(index)         # 调用存储的回调函数,传入被删除的元素         self.callback(item)         # 打印被删除的元素         print(f"Deleted item: {item}") # 使用示例中的回调函数 def print_deleted(item):     # 打印回调函数接收到的元素,表示该元素已被删除     print(f"Callback: Item {item} was deleted") if __name__ == '__main__':     # 创建一个CallbackList对象,并传入回调函数print_deleted     cl = CallbackList(print_deleted)     # 向CallbackList对象中添加元素     cl.append(1)     cl.append(2)     # 删除索引为0的元素(即值为1的元素)     # 由于CallbackList类重写了__delitem__方法,所以在删除时会调用该方法并执行回调函数和打印信息     del cl[0]  # 输出: Callback: Item 1 was deleted 和 Deleted item: 1

12、__dir__方法

12-1、语法
__dir__(self, /)     Default dir() implementation
12-2、参数

12-2-1、self(必须)一个对实例对象本身的引用,在类的所有方法中都会自动传递。

12-2-2、/(可选)这是从Python 3.8开始引入的参数注解语法,它表示这个方法不接受任何位置参数(positional-only parameters)之后的关键字参数(keyword arguments)。

12-3、功能

        用于定制对象的属性列表,即在执行如dir(obj)这样的操作时返回的属性名列表。

12-4、返回值

        返回一个字符串列表,包含了你想让dir()函数返回的对象的属性名。

12-5、说明

        如果你没有为类定义 __dir__ 方法,那么Python会使用默认的dir()实现,它会列出对象的所有属性,包括从父类继承的属性,以及实例属性、方法、类等。

12-6、用法
# 012、__dir__方法: # 1、基本实现,返回所有属性 # 定义一个名为 MyClass 的类 class MyClass:     # 类的初始化方法,当创建 MyClass 的实例时会被调用     def __init__(self):         # 为实例设置属性 a,并赋值为 1         self.a = 1         # 为实例设置属性 b,并赋值为 2         self.b = 2     # 定义一个名为 method 的方法,它不执行任何操作(pass 是空操作)     def method(self):         pass     # 自定义 __dir__ 方法,用于返回对象的属性列表     def __dir__(self):         # 返回实例的 __dict__ 属性(即实例的属性字典)的键的列表         # 并手动添加方法名 'method' 到列表中(注意:在 Python 3.3+ 中,方法名通常会自动包含在 __dir__ 中)         return list(self.__dict__.keys()) + ['method']  # 加上方法名(通常不需要手动添加) # 判断当前脚本是否作为主程序运行(而不是被导入为模块) if __name__ == '__main__':     # 创建一个 MyClass 的实例,并将其赋值给变量 obj     obj = MyClass()     # 调用 dir 函数并传入 obj 作为参数,打印 obj 的属性列表     # 由于 MyClass 定义了 __dir__ 方法,输出将包括 MyClass 实例的属性 'a'、'b' 以及手动添加的 'method'     # 注意:实际输出可能还包括其他内置方法和属性,如 '__class__', '__dict__', '__doc__' 等     print(         dir(obj))  # 输出可能包括:['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', ..., 'a', 'b', 'method']  # 2、隐藏某些属性 # 定义一个名为 MyClass 的类 class MyClass:     # 类的初始化方法,当创建 MyClass 的实例时会被调用     def __init__(self):         # 为实例设置一个公共属性 public_attr,并赋值为 1         self.public_attr = 1          # 为实例设置一个通常以单下划线开头的“受保护的”属性 _private_attr,并赋值为 2         # 注意:单下划线开头的属性并不是真正的私有属性,但在约定上被视为“受保护的”或“内部使用的”         self._private_attr = 2  # 通常以单下划线开头的属性被视为“受保护的”     # 自定义 __dir__ 方法,用于返回对象的属性列表     # 但这个方法有一个问题,因为它试图从自身调用 dir(self),这会导致无限递归     # 因为它会再次调用这个自定义的 __dir__ 方法,而不是内置的 dir 函数     def __dir__(self):         # 使用内置的 vars() 函数来获取实例的 __dict__,从而避免无限递归         return [attr for attr in vars(self) if not attr.startswith('_')] if __name__ == '__main__':     # 创建一个 MyClass 的实例,并将其赋值给变量 obj     obj = MyClass()      # 调用 dir 函数并传入 obj 作为参数,打印 obj 的属性列表     # 由于 MyClass 定义了 __dir__ 方法,输出将不包括以单下划线开头的属性     print(dir(obj))  # 输出将不包括以单下划线开头的属性,如:['public_attr']  # 3、添加动态属性 # 定义一个名为MyClass的类 class MyClass:     # 初始化方法,当创建MyClass的实例时会被调用     def __init__(self):         # 初始化一个实例变量dynamic_attr,并设置其值为None         self.dynamic_attr = None     # 定义一个方法add_dynamic_attr,用于动态地为实例添加属性     def add_dynamic_attr(self, name, value):         # 使用setattr函数动态地为实例添加属性,name为属性名,value为属性值         setattr(self, name, value)     # 自定义__dir__方法,用于返回对象的属性列表     def __dir__(self):         # 获取当前实例的所有属性名(不包括继承的属性),并将其转换为列表         # 然后添加方法名'add_dynamic_attr'到列表中         # 注意:在实际使用中,Python的dir()函数通常会自动包含方法名,这里添加可能是为了特殊需要或示例         return list(self.__dict__.keys()) + ['add_dynamic_attr']  # 添加方法名 # 当此脚本作为主程序运行时执行以下代码 if __name__ == '__main__':     # 创建一个MyClass的实例,并将其赋值给变量obj     obj = MyClass()      # 调用obj的add_dynamic_attr方法,动态地为其添加名为'new_attr'的属性,并设置其值为'some value'     obj.add_dynamic_attr('new_attr', 'some value')      # 调用dir函数并传入obj作为参数,打印obj的属性列表     # 由于MyClass定义了__dir__方法,输出将包括'add_dynamic_attr'、'dynamic_attr'以及动态添加的'new_attr'     print(dir(obj))  # 输出:['add_dynamic_attr', 'dynamic_attr', 'new_attr']  # 4、合并父类属性 # 定义一个名为Parent的基类 class Parent:     # 初始化方法,当创建Parent的实例时会被调用     def __init__(self):         # 初始化一个实例变量parent_attr,并设置其值为'parent'         self.parent_attr = 'parent' # 定义一个名为Child的子类,继承自Parent类 class Child(Parent):     # 子类的初始化方法     def __init__(self):         # 调用父类的初始化方法,确保父类的属性被正确初始化         super().__init__()         # 初始化一个子类特有的实例变量child_attr,并设置其值为'child'         self.child_attr = 'child'     # 自定义__dir__方法,用于返回对象的属性列表     def __dir__(self):         # 使用vars函数获取当前实例的字典表示(即属性和其值),并转换为集合         child_attrs = set(vars(self))         # 使用vars函数和super函数获取父类实例的字典表示,并转换为集合         parent_attrs = set(vars(super(Child, self)))         # 使用集合的并集操作符|,将子类和父类的属性合并为一个集合         all_attrs = child_attrs | parent_attrs         # 将合并后的属性集合转换为列表并返回         return list(all_attrs) # 当此脚本作为主程序运行时执行以下代码 if __name__ == '__main__':     # 创建一个Child类的实例,并将其赋值给变量obj     obj = Child()     # 调用dir函数并传入obj作为参数,打印obj的属性列表     # 由于Child类定义了__dir__方法,输出将包括父类Parent和子类Child的属性     print(dir(obj))  # 输出将包括父类和子类的属性  # 5、按条件显示属性 # 定义一个名为MyClass的类 class MyClass:     # 初始化方法,当创建MyClass的实例时会被调用     def __init__(self):         # 初始化一个实例变量show_this,并设置其值为True         self.show_this = True         # 初始化另一个实例变量hide_this,并设置其值为False         self.hide_this = False     # 自定义__dir__方法,用于返回对象的属性列表     def __dir__(self):         # 使用列表推导式遍历self.__dict__中的所有属性名(即键)         # 如果属性名不以'_this'结尾,或者该属性的值不为False(即值存在),则将其包含在内         # 注意:这里的逻辑实际上不会排除'hide_this',因为即使其值为False,它仍然存在于__dict__中         # 但为了注释说明,我们假设这是意图(尽管实际行为并非如此)         return [attr for attr in self.__dict__ if not attr.endswith('_this') or getattr(self, attr)] # 当此脚本作为主程序运行时执行以下代码 if __name__ == '__main__':     # 创建一个MyClass的实例,并将其赋值给变量obj     obj = MyClass()     # 调用dir函数并传入obj作为参数,打印obj的属性列表     # 注释说明中提到输出将包括'show_this',但不包括'hide_this'(因为其值为False)     print(dir(obj))  # 输出仅包括 ['show_this']  # 6、自定义排序 # 定义一个名为MyClass的类 class MyClass:     # 初始化方法,当创建MyClass的实例时会被调用     def __init__(self):         # 定义并初始化一个实例变量z,赋值为3         self.z = 3         # 定义并初始化一个实例变量b,赋值为2         self.b = 2         # 定义并初始化一个实例变量a,赋值为1         self.a = 1     # 自定义__dir__方法,用于返回对象的属性列表     def __dir__(self):         # 使用self.__dict__.keys()获取当前对象的所有属性名(作为字典的键)         # 然后使用sorted()函数对属性名进行排序(默认按字母顺序排序)         # 最后返回排序后的属性名列表         return sorted(self.__dict__.keys())  # 按字母顺序排序 # 当此脚本作为主程序运行时执行以下代码 if __name__ == '__main__':     # 创建一个MyClass的实例,并将其赋值给变量obj     obj = MyClass()     # 调用dir函数并传入obj作为参数,打印obj的属性列表     # 由于MyClass类中重写了__dir__方法,因此输出将按字母顺序排列属性名     print(dir(obj))  # 输出:['a', 'b', 'z']

13、__divmod__方法

13-1、语法
__divmod__(self, value, /)     Return divmod(self, value)
13-2、参数

13-2-1、self(必须)一个对实例对象本身的引用,在类的所有方法中都会自动传递。

13-2-2、value(必须)表示要与self进行除法和取模运算的第二个值。

13-2-3、/(可选)这是从Python 3.8开始引入的参数注解语法,它表示这个方法不接受任何位置参数(positional-only parameters)之后的关键字参数(keyword arguments)。

13-3、功能

        用于定义对象在使用divmod()内置函数时的行为。

13-4、返回值

        返回一个元组,其中包含两个值:除法的商和余数

13-5、说明

        当你对一个对象调用divmod()函数时,Python会自动尝试调用该对象的 __divmod__ 方法。这个方法应该接受两个参数:self(即对象本身)和value(即要与对象进行除法和取模运算的值)。

13-6、用法
# 013、__divmod__方法: # 1、整数类 # 定义一个名为Integer的类,用于表示整数 class Integer:     # 初始化方法,接收一个value参数,并将其赋值给实例变量self.value     def __init__(self, value):         self.value = value     # 定义__divmod__方法,用于自定义当对象使用divmod()函数时的行为     def __divmod__(self, other):         # 检查other是否为整数或浮点数,并且不等于0         # 如果不是,则抛出一个TypeError异常,提示不支持的操作数类型         if not isinstance(other, (int, float)) and other != 0:             raise TypeError("Unsupported operand type(s) for divmod()")         # 调用内置的divmod函数,对self.value和other进行除法和取模运算         # 并返回结果(一个包含商和余数的元组)         return divmod(self.value, other) # 如果当前模块是作为主程序运行的(而不是被导入到其他模块中),则执行以下代码 if __name__ == '__main__':     # 创建一个Integer对象a,并初始化其值为10     a = Integer(10)     # 使用divmod函数对a和3进行除法和取模运算     # 因为a是Integer的实例,所以这里会调用Integer类的__divmod__方法     # 输出结果应该是(3, 1),因为10除以3的商是3,余数是1     print(divmod(a, 3))  # 输出: (3, 1)  # 2、分数类 # 导入Fraction类,这是Python内置的一个分数类 from fractions import Fraction # 定义一个名为MyFraction的类,用于表示自定义的分数 class MyFraction:     # 初始化方法,用于创建MyFraction对象时设置分子和分母     def __init__(self, numerator, denominator=1):         # 分子         self.numerator = numerator         # 分母,默认为1(但通常不会为0,因为0作为分母在数学上是没有定义的)         self.denominator = denominator     # 定义divmod方法的特殊版本,用于实现自定义分数与其他数字类型的除法取余操作     def __divmod__(self, other):         # 检查传入的other是否是整数、浮点数或Fraction类型         if not isinstance(other, (int, float, Fraction)):             # 如果不是,则抛出TypeError异常             raise TypeError("Unsupported operand type(s) for divmod()")         # 将other转换为Fraction类型,以确保可以与Fraction对象进行运算         other_fraction = Fraction(other)          # 使用内置的divmod函数和Fraction对象进行除法取余操作         # 注意:这里将MyFraction对象也转换为Fraction对象进行计算         result = divmod(Fraction(self.numerator, self.denominator), other_fraction)          # divmod函数返回的是一个包含两个元素的元组:(商, 余数)         # 商和余数都是Fraction对象,我们需要将其转换为(分子, 分母)的形式并返回         # 第一个元素是商,转换为(分子, 分母)的元组形式         # 第二个元素是余数,直接返回其分子(因为余数的分母始终为1)         return (result[0].numerator, result[0].denominator), result[1].numerator # 如果当前脚本作为主程序运行(而不是被导入),则执行以下代码 if __name__ == '__main__':     # 创建一个MyFraction对象,分子为7,分母为3     frac = MyFraction(7, 3)      # 使用内置的divmod函数和自定义的MyFraction对象进行除法取余操作     # 注意:这里并没有直接调用MyFraction的__divmod__方法,而是使用了内置的divmod函数     # 但由于MyFraction类定义了__divmod__方法,所以内置的divmod函数能够识别并使用它     print(divmod(frac, 2))  # 输出: ((1, 1), 1),表示商为1(分子为1,分母为1),余数为1  # 3、复数类(注意:复数通常不支持取模运算) # 定义一个名为ComplexNumber的类,用于表示复数 class ComplexNumber:     # 初始化方法,设置复数的实部和虚部     def __init__(self, real, imag):         self.real = real  # 复数的实部         self.imag = imag  # 复数的虚部     # 定义__divmod__方法,用于实现复数与其他数字类型的除法取余操作     # 注意:复数通常不支持取模运算,这里仅作为示例展示除法     def __divmod__(self, other):         # 检查传入的other是否是整数、浮点数或复数类型         if not isinstance(other, (int, float, complex)):             # 如果不是,则抛出TypeError异常             raise TypeError("Unsupported operand type(s) for divmod()")         # 计算除法,使用内置的complex函数和/操作符进行复数除法         quotient = complex(self.real, self.imag) / other          # 这里不返回余数,因为复数除法没有明确的余数概念         # 返回商和0j(即虚部为0的复数,表示没有余数)         # 注意:这里返回的第二个元素虽然是0j,但在复数除法中并没有实际意义         return quotient, 0 + 0j # 如果当前脚本作为主程序运行(而不是被导入),则执行以下代码 if __name__ == '__main__':     # 创建一个ComplexNumber对象,实部为2,虚部为3     c = ComplexNumber(2, 3)      # 使用内置的divmod函数和自定义的ComplexNumber对象进行除法取余操作     # 注意:虽然名为divmod,但这里只实现了除法,并返回了商和0j作为余数(无实际意义)     print(divmod(c, 1 + 1j))  # 输出:((2.5+0.5j), 0j),表示商为2.5+0.5j,余数为0j(无实际意义)  # 4、自定义单位类(如长度,使用米和厘米) class Length:     def __init__(self, meters, cm=0):         # 将厘米转换为米,并加到总的米数上         self.meters = meters + cm / 100         # 获取剩余的厘米数(0-99)         self.cm = cm % 100     def __divmod__(self, other):         if not isinstance(other, (int, float)):             raise TypeError("不支持的操作数类型进行 divmod() 操作")             # 确保除数不为零         if other == 0:             raise ZeroDivisionError("除数不能为零")         # 转换为厘米以便进行计算         total_cm = int(self.meters * 100) + self.cm         # 使用 divmod 函数计算商和余数(均为厘米数)         quotient_cm, remainder = divmod(total_cm, other)         # 将商转换为米和厘米         quotient_meters = quotient_cm // 100         quotient_cm %= 100         # 返回一个包含商(Length 对象)和余数(厘米数)的元组         return Length(quotient_meters, quotient_cm), remainder if __name__ == '__main__':     l = Length(2, 30)     # 使用 divmod 函数进行除法操作,并打印结果     # 结果应该是一个包含 Length 对象和余数的元组     result = divmod(l, 5)     print(result)  # 输出可能类似于:(<__main__.Length object at 0x...>, 4)     # (< __main__.Length object at 0x0000023C5CACCE50 >, 4)

五、推荐阅读

1、Python筑基之旅

2、Python函数之旅

3、Python算法之旅

4、博客个人主页

广告一刻

为您即时展示最新活动产品广告消息,让您随时掌握产品活动新动态!