Python的魔术方法

一、什么是魔术方法

1、魔术方法是一组具有特殊命名和行为的特殊方法，它们允许您自定义类的行为。这些方法使用双下划线（__）作为前缀和后缀，因此也被称为双下划线方法或特殊方法。

2、需要掌握每个方法什么时候触发或者执行

二、常见的魔术方法

1、__init__方法

初始化方法，当一个类被调用产生实例对象，自动触发，它可以用来初始化对象的属性和执行其他必要的设置。

2、__str__和__repr__方法

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

class Student():     def __init__(self, name, age, gender):         self.name = name         self.age = age         self.gender = gender       def __str__(self):         print('str')         return '%s %s' % (self.name, self.age)       def __repr__(self):         print('repr')         return '%s' % self.name   stu = Student('kevin', 18, 'male') print(stu)   # str # kevin 18

注：

__str__和__repr__差不多，同时使用时，__str__会被优先执行，__repr__不执行

当打印或者输出对象的时候，会自动触发__str__(self)的执行

__str__(self): 只能返回字符串，它被print()函数和str()函数调用，可以用来自定义对象的打印输出。

__repr__(self): 返回对象的可打印表示。它被repr()函数调用，通常用于调试目的。

3、_len__(self): 返回对象的长度。它被len()函数调用，用于获取对象的元素个数。 

4、__del__方法


用于定义对象被销毁（垃圾回收）时的行为。它在对象的引用计数达到零时自动被调用。

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25

class Student():     def __init__(self, name, age, gender):         self.name = name         self.age = age         self.gender = gender         self.f = open("a.txt", "w", encoding="utf8")       # 我执行了：     # 1. 当删除对象的时候，会自动触发函数的执行     # 2. 当程序结束的时候，也会自动触发执行     def __del__(self):         print("我执行了")         """可以做一些清理垃圾的操作"""         self.f.close() stu = Student("kevin", 19, 'male')   # del stu # 有删除对象的操作，会立即触发__del__(self)   print("1") print("12") print("123") # 1 # 12 # 123 # 我执行了

注：

当对象被销毁会触发执行__del__(self)

没有对象被销毁操作时，程序代码执行完也会触发执行__del__(self)

5、 isinstance(obj,cls) 和 issubclass(sub,super)

isinstance(obj,cls)  函数判断对象是不是由某个类实例化的，返回布尔值

issubclass(sub,super)  函数也可以用于检查一个类是否是多个类中的任何一个类的子类

1	print(issubclass(Dog, (Animal, Mammal)))

6、__doc__

document:可以查看出类内部的详细信息，其实就是注释里面的内容
这个特性不能够继承到父类

1 2 3 4 5

class MyClass:     """This is a docstring for MyClass."""     pass   print(MyClass.__doc__)  # 输出 "This is a docstring for MyClass."

7、__enter__和__exit__

是用于实现上下文管理器的两个特殊方法

__enter__(self): __enter__() 方法在进入上下文管理器（遇到with）时被调用，并返回一个对象。通常，它被用来执行一些准备工作，例如初始化资源、设置环境等。返回的对象（如果有）会被赋值给与 with 语句关联的目标变量 as 后的 f 变量。

__exit__(self, exc_type, exc_value, traceback):

__exit__() 方法在离开上下文管理器时被调用。它接受三个参数，用于处理异常情况。如果代码块正常执行完毕，这些参数都为 None。如果发生异常，这些参数将包含异常的类型、值和回溯信息。__exit__() 方法负责清理资源、处理异常或执行其他必要的操作。

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

class open:     def __init__(self, name):         self.name = name       def __enter__(self):         # 执行进入上下文前的准备工作         print("Entering the context")         return self  # 可选，返回一个对象       def __exit__(self, exc_type, exc_value, traceback):         # 执行离开上下文时的清理工作         print("Exiting the context")         if exc_type is not None:             # 处理异常             print(f"Exception occurred: {exc_type}, {exc_value}")   # 使用上下文管理器 with open('a.txt') as f:     # 执行一些操作     print("Inside the context")   # Entering the context  # 遇到with先执行__enter__方法 # Inside the context   # 再执行with 下的代码 # Exiting the context # 最后执行__exit__方法

补充：对上下文管理器的with的理解

当使用 with 语句时，Python 会自动管理上下文管理器的获取和释放，以确保资源的正确获取和释放，即使在出现异常的情况下也能正常工作。这是通过遵循上下文管理协议来实现的。

上下文管理协议要求上下文管理器对象必须定义 __enter__() 和 __exit__() 两个方法。它们分别用于进入上下文和离开上下文时的操作。

具体来说，with 语句的工作流程如下：

1. with 语句获取上下文管理器对象：

   • 调用上下文管理器的 __enter__() 方法，该方法可能返回一个对象，并将其绑定到 as 子句中指定的变量上。如果没有指定 as 子句，则返回的对象被丢弃。

2. 执行 with 语句块：

   • 执行 with 语句块中的代码，执行相关的操作。

3. 离开上下文：

   • 无论 with 语句块是否发生异常，都会调用上下文管理器的 __exit__() 方法进行资源的释放和清理。
   • 如果 with 语句块正常执行完毕，或者没有发生异常，__exit__() 方法的参数都为 None。
   • 如果 with 语句块发生异常，异常的类型、值和回溯信息将传递给 __exit__() 方法的参数，可以在该方法内部处理异常。

上下文管理协议的优点是它提供了一种统一、可靠的方式来管理资源，无论是否发生异常，都能保证资源的释放。这样可以避免资源泄露和其他潜在的问题。通过使用 with 语句，可以提高代码的可读性，并使资源管理更加简洁和安全。

8、__call__

对象后面加括号，触发执行。

本质上就是类里面定义了一个函数，类实例化后的对象➕括号调用该函数

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

class CallableClass:     def __call__(self, *args, **kwargs):         print("Calling the object")   # 创建一个对象 obj = CallableClass()   # 调用对象 obj()  # 输出："Calling the object" ____________ class CallableClass: def __call__(self, *args, **kwargs): print("Calling the object with arguments:") print("Positional arguments:", args) print("Keyword arguments:", kwargs)   # 创建一个对象 obj = CallableClass()   # 调用对象并传递参数 obj(1, 2, foo='bar')

9、__setattr__,  __delattr__,  __getattr__  使用(.)句点法object.key = value进行赋值操作

     __setitem__, __delitem__, __getitem__  使用使用 object[key] = value进行赋值操作

用于在访问、设置和删除对象的属性时提供自定义行为

• __setattr__(self, name, value):

  • 当给对象的属性赋值时被调用。
  • 它可以被用来在属性赋值前执行一些额外的逻辑或进行验证。
  • 参数 name 是要设置的属性名，value 是要赋给属性的值。
  • 在 __setattr__ 方法内部，通常应该使用 self.__dict__[name] = value 来设置属性值，以避免无限递归调用。

• __delattr__(self, name):

  • 当删除对象的属性时被调用。
  • 它可以用来在属性删除前执行一些清理操作或进行验证。
  • 参数 name 是要删除的属性名。

• __getattr__(self, name):

  • 当访问对象的属性失败时被调用。
  • 它可以用来处理对不存在属性的访问，或者实现属性的延迟加载。
  • 参数 name 是要访问的属性名。
  • __getattr__ 方法应该返回属性的值或引发 AttributeError 异常。

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29

class MyClass:     def __setattr__(self, name, value):  # attribute 属性         print(f"Setting attribute: {name} = {value}")         self.__dict__[name] = value       def __delattr__(self, name):         print(f"Deleting attribute: {name}")         del self.__dict__[name]       def __getattr__(self, name):         print(f"Getting attribute: {name}")         raise AttributeError(f"Attribute '{name}' not found")   # 创建对象 obj = MyClass()   # 设置属性 obj.attr1 = "Value 1"  # 调用 __setattr__()   # 获取属性 print(obj.attr1)  # 直接访问，不会调用 __getattr__() # Setting attribute: attr1 = Value 1 # Value 1   # 访问不存在的属性 print(obj.attr2)  # 调用 __getattr__()   # 删除属性 del obj.attr1  # 调用 __delattr__()

10、__new__ 

Python 中的一个特殊方法（special method），用于在创建一个新的实例（对象）时被调用。

它是在对象实例化的过程中执行的第一个方法，负责创建并返回一个新的实例。__new__ 方法的主要作用是控制对象的创建过程，它在 __init__ 方法之前调用。

__new__ 方法接收的参数与普通方法一样，但与普通方法不同的是，第一个参数不是 self，而是类本身（通常被命名为 cls）。

__new__ 方法必须返回一个新的实例，通常是通过调用父类的 __new__ 方法来实现的。

一般情况下，我们很少直接重写 __new__ 方法，因为大部分情况下使用默认的 object.__new__ 就足够了。但在某些特殊情况下，比如定制不可变对象，或者在创建对象时需要做一些额外的处理，重写 __new__ 方法可能是有用的。

1 2 3 4 5 6 7 8 9 10 11 12 13 14

class MyClass:     def __new__(cls, *args, **kwargs):         # 调用父类的 __new__ 方法来创建新实例         instance = super().__new__(cls)         # 可以在这里对实例进行额外的初始化或处理         return instance       def __init__(self, arg1, arg2):         # 在 __new__ 方法之后，由 __init__ 方法完成实例的初始化         self.arg1 = arg1         self.arg2 = arg2   # 创建实例时会调用 __new__ 方法，并将实例传递给 __init__ 方法 obj = MyClass("Hello", "World")