目录
一、概述
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、避免过度使用
四、魔法方法
32、__index__方法
32-1、语法
32-2、参数
32-3、功能
32-4、返回值
32-5、说明
32-6、用法
33、__init__方法
33-1、语法
33-2、参数
33-3、功能
33-4、返回值
33-5、说明
33-6、用法
34、__init_subclass__方法
34-1、语法
34-2、参数
34-3、功能
34-4、返回值
34-5、说明
34-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的魔法方法需要不断地学习、实践和总结，只有通过不断地练习和积累经验，你才能更好地掌握这些强大的工具，并在实际项目中灵活运用它们。
四、魔法方法
32、__index__方法
32-1、语法
__index__(self, /)
Return self converted to an integer, if self is suitable for use as an index into a list32-2、参数
32-2-1、self(必须)：一个对实例对象本身的引用，在类的所有方法中都会自动传递。
32-2-2、/(可选)：这是从Python 3.8开始引入的参数注解语法，它表示这个方法不接受任何位置参数(positional-only parameters)之后的关键字参数(keyword arguments)。
32-3、功能
用于那些希望表现得像整数，但实际上不是整数的对象。
32-4、返回值
返回一个整数，该整数代表该对象在整数上下文中的值。
32-5、说明
__index__方法与__int__方法不同：
32-5-1、__int__ 方法用于将对象转换为整数，但并不保证转换后的整数适合用作索引(例如，它可能返回一个负数或超出索引范围的数)；而__index__方法应该只返回那些可以用作索引的有效整数。
32-5-2、__index__ 方法通常只在需要整数索引的上下文中被调用，比如列表索引、切片操作等；在其他上下文中，可能需要使用__int__或其他转换方法。
32-6、用法
# 032、__index__方法：
# 1、自定义整数类型
class MyInt:
def __init__(self, value):
self.value = value
def __index__(self):
return self.value
def __repr__(self):
return f"MyInt({self.value})"
if __name__ == '__main__':
lst = [1, 2, 3, 4, 5]
idx = MyInt(2)
print(lst[idx]) # 输出 3
# 2、自定义时间索引
from datetime import datetime, timedelta
class TimeIndex:
def __init__(self, hours):
self.hours = hours
def __index__(self):
return self.hours * 60 * 60 # 转换为秒
if __name__ == '__main__':
now = datetime.now()
# 手动调用 TimeIndex 对象的 __index__ 方法来获取秒数
seconds = TimeIndex(2).__index__()
delta = timedelta(seconds=seconds)
future_time = now + delta
print(future_time) # 输出类似于 2024-06-02 09:49:54.742039
# 3、自定义进度条(简化示例)
class ProgressBar:
def __init__(self, total):
self.total = total
self.current = 0
def update(self, value):
self.current = value
def __index__(self):
return self.current
if __name__ == '__main__':
bar = ProgressBar(100)
for i in range(101):
bar.update(i)
print(f"Progress: {i} / {bar.__index__() + 1}")
# 4、自定义范围
class MyRange:
def __init__(self, start, end):
self.start = start
self.end = end
def __index__(self):
return self.end - self.start # 返回范围的大小
if __name__ == '__main__':
rng = MyRange(10, 20)
print(f"Range size: {rng.__index__()}") # 输出：Range size: 10
# 5、自定义列表索引
class WeightedList:
def __init__(self, elements, weights):
self.elements = elements
self.weights = weights
def __getitem__(self, index):
# 这里假设我们使用累积权重作为索引
cumulative_weights = [sum(self.weights[:i + 1]) for i in range(len(self.weights))]
if isinstance(index, int):
for i, cw in enumerate(cumulative_weights):
if index < cw:
return self.elements[i]
raise IndexError("Index out of range")
elif hasattr(index, "__index__"):
# 如果index有__index__方法，我们用它来获取整数值
index_val = index.__index__()
return self.__getitem__(index_val)
else:
raise TypeError("Unsupported index type")
class WeightedIndex:
def __init__(self, value):
self.value = value
def __index__(self):
# 假设我们根据某种规则将value转换为索引
# 这里只是一个示例，实际应用中规则可能更复杂
return self.value * 2 # 例如，我们想要索引是权重的两倍
if __name__ == '__main__':
wl = WeightedList(['a', 'b', 'c'], [1, 3, 2])
print(wl[WeightedList.WeightedIndex(1)]) # 假设我们想要索引为权重的两倍，所以这里会返回'b'
# 6、自定义时间步索引
class TimeStep:
def __init__(self, step_number):
self.step_number = step_number
def __index__(self):
return self.step_number
if __name__ == '__main__':
time_steps = [TimeStep(0), TimeStep(1), TimeStep(2)]
for ts in time_steps:
print(f"Time step: {ts.__index__()}")
# 7、图形元素索引
class GraphElement:
def __init__(self, id):
self.id = id
def __index__(self):
# 假设我们直接使用元素的id作为索引
return self.id
if __name__ == '__main__':
elements = [GraphElement(1), GraphElement(2), GraphElement(3)]
for elem in elements:
print(f"Element index: {elem.__index__()}")33、__init__方法
33-1、语法
__init__(self, /, *args, **kwargs)
Initialize self. See help(type(self)) for accurate signature33-2、参数
33-2-1、self(必须)：一个对实例对象本身的引用，在类的所有方法中都会自动传递。
33-2-2、/(可选)：这是从Python 3.8开始引入的参数注解语法，它表示这个方法不接受任何位置参数(positional-only parameters)之后的关键字参数(keyword arguments)。
33-2-3、*args(可选)：一个非关键字可变位置参数列表，它允许你在调用构造函数时传入任意数量的位置参数，这些参数会作为元组(tuple)传递给__init__方法。
33-2-4、**kwargs(可选)：一个非关键字可变关键字参数字典，它允许你在调用构造函数时传入任意数量的关键字参数，这些参数会作为字典(dictionary)传递给__init__方法。
33-3、功能
初始化新创建的对象的状态。
33-4、返回值
没有特定的返回值(或更准确地说是返回None)。
33-5、说明
无
33-6、用法
# 033、__init__方法：
# 1、基础示例
class Person:
def __init__(self, name, age):
self.name = name
self.age = age
# 2、设置默认值
class Car:
def __init__(self, color='red', brand='Toyota'):
self.color = color
self.brand = brand
# 3、列表初始化
class Playlist:
def __init__(self, songs):
self.songs = songs
# 4、字典初始化
class UserInfo:
def __init__(self, details):
self.details = details
# 5、使用*args(可变位置参数)
class VariableArguments:
def __init__(self, *args):
self.args = args
# 6、使用kwargs(可变关键字参数)
class KeywordArguments:
def __init__(self, **kwargs):
self.kwargs = kwargs
# 7、结合*args和kwargs**
class CombinedArguments:
def __init__(self, name, *args, **kwargs):
self.name = name
self.args = args
self.kwargs = kwargs
# 8、属性验证(例如，确保年龄为正数)
class ValidatedPerson:
def __init__(self, name, age):
if age < 0:
raise ValueError("Age cannot be negative")
self.name = name
self.age = age
# 9、文件处理(初始化时打开文件)
class LogFile:
def __init__(self, filename):
self.file = open(filename, 'a')
def __del__(self):
self.file.close()
# 10、数据库连接(初始化时连接到数据库)
import sqlite3
class Database:
def __init__(self, db_name):
self.connection = sqlite3.connect(db_name)
self.cursor = self.connection.cursor()
def __del__(self):
self.connection.close()
# 11、计算属性(在初始化时计算某些值)
class Circle:
def __init__(self, radius):
self.radius = radius
self.diameter = 2 * radius
self.area = 3.14159 * radius ** 2
# 12、使用私有属性和getter/setter
class SecretAgent:
def __init__(self, code_name):
self._code_name = code_name
@property
def code_name(self):
return self._code_name
@code_name.setter
def code_name(self, new_name):
if new_name.isalpha():
self._code_name = new_name
else:
raise ValueError("Code name must be alphabetic")
# 13、带有日志记录的初始化
import logging
class LoggedClass:
def __init__(self, name):
self.name = name
logging.info(f'Object of {self.__class__.__name__} with name {name} created.')
# 14、设置对象的状态
class Light:
OFF = 0
ON = 1
def __init__(self, status=OFF):
if status not in [self.OFF, self.ON]:
raise ValueError('Invalid status')
self.status = status
# 15、绑定回调函数
class Button:
def __init__(self, on_press=None):
self.on_press = on_press
def press(self):
if self.on_press:
self.on_press()
# 16、处理继承中的初始化
class Parent:
def __init__(self, parent_attr):
self.parent_attr = parent_attr
class Child(Parent):
def __init__(self, parent_attr, child_attr):
super().__init__(parent_attr) # Call parent's __init__
self.child_attr = child_attr
# 17、使用枚举类型
from enum import Enum
class Color(Enum):
RED = 1
GREEN = 2
BLUE = 3
class LightBulb:
def __init__(self, color: Color):
if not isinstance(color, Color):
raise ValueError('Color must be an instance of Color Enum')
self.color = color
# 18、配置文件的加载
import configparser
class ConfiguredClass:
def __init__(self, config_file):
config = configparser.ConfigParser()
config.read(config_file)
self.setting1 = config.get('section1', 'setting1')
self.setting2 = config.getint('section2', 'setting2')
# 19、使用@property装饰器进行初始化
class PropertyExample:
def __init__(self):
self._value = None
@property
def value(self):
return self._value
@value.setter
def value(self, new_value):
if new_value < 0:
raise ValueError('Value must be non-negative')
self._value = new_value
if __name__ == '__main__':
obj = PropertyExample()
obj.value = 10 # 这里实际上在setter中进行了初始化
# 20、依赖注入
class Service:
def __init__(self, dependency):
self.dependency = dependency
if __name__ == '__main__':
dependency = SomeDependency()
service = Service(dependency)34、__init_subclass__方法
34-1、语法
__init_subclass__(cls, **kwargs):
super().__init_subclass__(**kwargs) # 调用父类的__init_subclass__方法34-2、参数
34-2-1、cls(必须)：一个对子类本身的引用，它是一个类对象。
34-2、**kwargs(可选)：一个可变关键字参数字典，允许你在定义子类时传递任意数量的关键字参数给__init_subclass__方法。这些关键字参数在子类的类定义中通过元类(如果有的话)或直接在类定义中通过metaclass=SomeMetaClass(arg1=value1, arg2=value2, ...)的方式传递。
34-3、功能
在子类被创建时自动调用，用于在子类定义完成后执行一些初始化操作。
34-4、返回值
没有特定的返回值(或更准确地说是返回None)。
34-5、说明
__init_subclass__并不是在所有情况下都会自动被调用，它只在通过class语句显式地定义子类时才会被调用，而不是在通过继承或元类编程间接地创建子类时。
34-6、用法
# 034、__init_subclass__方法：
# 1、添加类属性
class Base:
def __init_subclass__(cls, **kwargs):
cls.subclass_attr = kwargs.get('subclass_attr', 'default')
class SubclassA(Base, subclass_attr='A-specific'):
pass
print(SubclassA.subclass_attr) # 输出 'A-specific'
# 2、注册子类
class Registry:
subclasses = []
def __init_subclass__(cls, **kwargs):
super().__init_subclass__(**kwargs)
cls.subclasses.append(cls)
class RegisteredA(Registry):
pass
class RegisteredB(Registry):
pass
print(Registry.subclasses) # 输出 [<class '__main__.RegisteredA'>, <class '__main__.RegisteredB'>]
# 3、动态设置元类
class MetaBase(type):
pass
class MetaA(MetaBase):
pass
# 注意这里我们使用了 metaclass 关键字来指定元类
class Base(metaclass=MetaBase):
def __init_subclass__(cls, **kwargs):
super().__init_subclass__(**kwargs)
# 这里我们不需要做任何额外的事情，因为元类已经在类定义时指定了
# 这里我们不再使用 meta=MetaA，而是直接在类定义时指定元类
class SubclassWithMeta(Base, metaclass=MetaA):
pass
print(type(SubclassWithMeta)) # 应该输出 <class '__main__.MetaA'>
# 4、设置类级别的变量
class Base:
def __init_subclass__(cls, **kwargs):
super().__init_subclass__(**kwargs)
# 注意：这里我们不会从 kwargs 获取 class_var，因为我们不能直接传递它
class SubclassB(Base):
# 我们不能直接在这里设置 class_var，因为它是类变量，不是 __init_subclass__ 的参数
pass
# 在类定义之后，我们直接设置 class_var
SubclassB.class_var = 42
print(SubclassB.class_var) # 输出 42
# 5、验证子类属性
class Base:
def __init_subclass__(cls, **kwargs):
super().__init_subclass__(**kwargs)
if not hasattr(cls, 'required_attr'):
raise TypeError(f"{cls.__name__} must have a 'required_attr' attribute")
class SubclassD(Base):
required_attr = True
# 下面的类会抛出TypeError，因为它没有'required_attr'
# class SubclassE(Base):
# pass
# TypeError: SubclassE must have a 'required_attr' attribute
# 6、设置默认属性值
class Base:
default_value = None
def __init_subclass__(cls, **kwargs):
super().__init_subclass__(**kwargs)
if not hasattr(cls, 'default_value'):
cls.default_value = 'default from Base'
class SubclassF(Base):
pass
print(SubclassF.default_value) # 输出 'default from Base'
# 7、实现接口检查
class Interface:
pass
class Base:
def __init_subclass__(cls, **kwargs):
super().__init_subclass__(**kwargs)
if not issubclass(cls, Interface):
raise TypeError(f"{cls.__name__} must implement {Interface.__name__} interface")
# 下面的类会抛出TypeError，因为它没有实现Interface
# class SubclassG(Base):
# pass
class SubclassH(Base, Interface):
pass
# 8、添加类方法
class Base:
def __init_subclass__(cls, **kwargs):
super().__init_subclass__(**kwargs)
def subclass_method(self):
return f"I'm a method from {cls.__name__}"
setattr(cls, 'subclass_method', classmethod(subclass_method))
class SubclassC(Base):
pass
print(SubclassC.subclass_method()) # 输出 "I'm a method from SubclassC"
# 9、设置继承顺序
class Base:
_order = []
def __init_subclass__(cls, order=None, **kwargs):
super().__init_subclass__(**kwargs)
if order is not None:
Base._order.append((order, cls))
# 按照指定的顺序排序
Base._order.sort(key=lambda x: x[0])
class SubclassI(Base, order=1):
pass
class SubclassJ(Base, order=2):
pass
class SubclassK(Base, order=0):
pass
# 打印按照顺序排列的子类
for _, cls in Base._order:
print(cls.__name__) # 输出 SubclassK, SubclassI, SubclassJ
# 10、添加装饰器到所有子类方法
def my_decorator(func):
def wrapper(*args, **kwargs):
print(f"Calling {func.__name__} with decorator")
return func(*args, **kwargs)
return wrapper
class Base:
def __init_subclass__(cls, **kwargs):
super().__init_subclass__(**kwargs)
for name, method in vars(cls).items():
if callable(method) and not name.startswith("__"):
setattr(cls, name, my_decorator(method))
class SubclassL(Base):
def method(self):
print("SubclassL method called")
SubclassL().method() # 输出 "Calling method with decorator" 和 "SubclassL method called"
# 11、根据子类名称动态添加方法
class Base:
def __init_subclass__(cls, **kwargs):
super().__init_subclass__(**kwargs)
def dynamic_method(self):
return f"This is a dynamic method for {cls.__name__}"
setattr(cls, f"dynamic_{cls.__name__.lower()}", dynamic_method)
class SubclassN(Base):
pass
print(SubclassN().dynamic_subclassn()) # 输出 "This is a dynamic method for SubclassN"
