Python基础语法入门(第十八天)——类方法与魔术方法

**类方法（Class Method）**是一种在类级别上定义的方法，而不是在实例级别上定义的方法。

类方法使用 @classmethod 装饰器来声明，其第一个参数通常被命名为 cls，表示当前类。和实例方法不同，类方法可以直接通过类本身调用，而不需要先创建对象。

魔术方法（Magic Methods），也称为双下划线方法（dunder methods），是在Python中具有特殊功能的特殊方法。这些方法使用双下划线（__）作为前缀和后缀，因此被称为魔术方法。

魔术方法可以用于自定义类的行为，例如操作符重载、对象创建和销毁、属性访问等。这些方法可以在类中被重写，通过在类中定义特定的魔术方法，可以改变类的默认行为。

在Python中常见的魔术方法有__init__、__new__、__call__。接下来我们就来对这些常见的魔术方法进行学习。其中，__init__方法在第十六天的文章中有过提及，因此本文中不再进行讲解。

一、类方法

类方法具有以下特点：

1. 类方法可以访问类的属性，但不能直接访问实例属性。
2. 类方法可以修改类的属性。
3. 类方法可以被类的实例和类本身调用，但是一般更推荐使用类进行调用。

请看下方示例，在该例子中展示了如何定义与使用类方法：

class MyClass:
    class_attribute = "Hello"

    @classmethod
    def class_method(cls):
        print("This is a class method")
        print("Accessing class attribute:", cls.class_attribute)

# 使用类进行调用类方法
MyClass.class_method()

# 创建对象并调用类方法
my_obj = MyClass()
my_obj.class_method()

在上述代码中，我们定义了一个名为 MyClass 的类，并在其中定义了一个类方法 class_method。通过 @classmethod 装饰器，将该方法声明为类方法。

在类方法 class_method 中，我们可以通过 cls 参数访问类的属性 class_attribute。在使用类进行调用时，直接通过 MyClass.class_method() 调用类方法；在创建对象后，也可以通过对象进行调用，如 my_obj.class_method()。

需要注意的是，类方法不与任何特定实例对象相关联，而是与整个类相关联。因此，在类方法中不能直接访问实例属性，只能访问类属性。如果需要访问实例属性，应该使用实例方法。

类方法常用于定义与整个类相关的工具方法、工厂方法或者对类属性的操作方法等。

类方法与实例方法的区别

类方法和实例方法在使用方式和行为上有一些区别：

1. 定义方式：类方法使用 `@classmethod` 装饰器进行声明，而实例方法没有特殊的装饰器，只需在方法定义中包含 `self` 参数。

2. 参数：类方法的第一个参数通常被命名为 `cls`，表示当前类本身，而实例方法的第一个参数通常被命名为 `self`，表示当前实例对象。

3. 访问属性：类方法可以访问类本身的属性，但不能直接访问实例对象的属性。而实例方法可以访问实例对象的属性和类的属性。

4. 调用方式：类方法可以直接通过类本身进行调用，而不需要先创建类的实例对象。实例方法则需要通过创建的实例对象进行调用。

5. 修改属性：类方法可以修改类的属性，而实例方法可以修改实例对象的属性。

6. 调用上下文：类方法对整个类而言是共享的，因此在内部无法直接访问实例特定的属性。而实例方法在调用时可以访问实例特定的属性，包括通过 `self.` 访问实例属性。

以下是一个示例，展示了类方法和实例方法的区别：

class MyClass:
    class_attribute = "Hello"

    @classmethod
    def class_method(cls):
        print("This is a class method")
        print("Accessing class attribute:", cls.class_attribute)

    def instance_method(self):
        print("This is an instance method")
        print("Accessing instance attribute:", self.instance_attribute)

# 创建对象
my_obj = MyClass()
my_obj.instance_attribute = "World"

# 调用类方法
MyClass.class_method()

# 调用实例方法
my_obj.instance_method()

在上述代码中，我们定义了一个名为 MyClass 的类，其中包含一个类方法 class_method 和一个实例方法 instance_method。

当我们调用类方法 MyClass.class_method() 时，可以通过 cls 参数访问类的属性 class_attribute。

当我们调用实例方法 my_obj.instance_method() 时，可以通过 self 参数访问实例属性 instance_attribute。

需要注意的是，类方法和实例方法各有适用的场景。类方法常用于定义类的工具方法、工厂方法，或者对类属性的操作方法等。实例方法则通常用于操作和访问实例特定的数据。

二、魔术方法

2.1 __new__方法

__new__ 是一个特殊的魔术方法，用于在对象创建之前被调用，用于控制对象的创建过程。它是一个类级别的方法，因此在定义时不需要传入 self 参数，而是传入一个类作为第一个参数。

__new__ 方法的主要作用是创建并返回一个新的对象实例。它在对象创建之前被调用，因此可以在对象创建之前对其进行一些额外的操作，例如修改对象的状态、改变对象的创建方式或者返回其他对象等。

__new__ 方法通常被用于以下情况：

1. 在不可变类（如元组、字符串等）中，__new__ 方法被用于创建对象之前对其进行修改，因为不可变对象一旦创建就不能改变。

2. 在自定义的可变类中，可以通过重写 __new__ 方法来实现对象的创建方式的改变，例如从对象池中获取对象或者实现单例模式等。

3. 在派生类中，可以通过重写 __new__ 方法来扩展父类的创建行为，添加额外的属性或修改对象的初始化方式。

需要注意的是，__new__ 方法负责创建对象并返回实例，而 __init__ 方法负责初始化对象的属性。在大多数情况下，不需要重写 __new__ 方法，而是重写 __init__ 方法来进行对象的初始化操作。只有在特定的需求下，才需要重写 __new__ 方法。

以下是一个简单的示例，展示了如何使用 __new__ 方法：

class MyClass:
    def __new__(cls, *args, **kwargs):
        # 自定义创建对象的逻辑
        obj = super().__new__(cls)
        # 对对象进行修改或扩展
        obj.custom_attribute = "Custom Value"
        return obj

    def __init__(self, *args, **kwargs):
        # 在 __new__ 方法中已经对对象进行了创建和修改，因此在此处不需要再修改
        pass

# 创建对象
my_obj = MyClass()

# 访问对象属性
print(my_obj.custom_attribute)  # 输出："Custom Value"

在上述代码中，我们重写了类 MyClass 的 __new__ 方法，根据自定义的逻辑创建对象 obj，并对其进行了扩展，添加了一个自定义的属性 custom_attribute。然后，通过返回修改后的对象实例来创建对象。最后，我们创建 MyClass 类的实例 my_obj，并访问它的属性 custom_attribute。

需要注意的是，在重写 __new__ 方法时，一定要确保返回一个对象实例，否则会导致对象创建失败。通常情况下，可以使用 super().__new__(cls) 来获取父类的 __new__ 方法返回的实例，并进行进一步的修改或扩展。

2.2 _len_(self)方法

__len__ 是一个常见的魔术方法，用于返回对象的长度或大小。它会在使用内置函数 len() 对对象进行操作时被调用。

定义了 __len__ 方法后，我们可以通过调用内置函数 len() 来获取对象的长度。该方法应该返回一个非负整数，表示对象的大小或元素的个数。

以下是一个简单的示例，展示了如何使用 __len__ 方法：

class MyList:
    def __init__(self):
        self.items = []

    def __len__(self):
        return len(self.items)

    def add_item(self, item):
        self.items.append(item)

my_list = MyList()
my_list.add_item("apple")
my_list.add_item("banana")
my_list.add_item("cherry")

print(len(my_list))  # 输出：3

在上述代码中，我们定义了一个名为 MyList 的类，其中包含一个 __len__ 方法。在 __len__ 方法中，我们返回 self.items 列表的长度，即列表中元素的个数。

然后，我们创建了一个 MyList 类的对象 my_list，并向其添加了三个元素。最后，使用内置函数 len() 来获取 my_list 对象的长度，并打印结果。

需要注意的是，当我们在自定义类中使用 len() 函数时，实际上是在调用该类的 __len__ 方法。使得我们可以根据自己的需求和逻辑来定义和实现对象的长度的计算方式。

2.3 _str_(self)方法

__str__ 是一个常见的魔术方法，用于返回对象的描述字符串。它会在使用内置函数 str() 或 print() 对对象进行操作时被调用。

定义了 __str__ 方法后，我们可以通过调用内置函数 str() 来获取对象的描述字符串，或者通过使用 print() 函数来直接打印对象。该方法应该返回一个字符串，描述对象的信息或状态。

以下是一个简单的示例，展示了如何使用 __str__ 方法：

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def __str__(self):
        return f"Person(name={self.name}, age={self.age})"

person = Person("John", 25)

print(str(person))  # 输出：Person(name=John, age=25)
print(person)       # 输出：Person(name=John, age=25)

在上述代码中，我们定义了一个名为 Person 的类，其中包含一个 __str__ 方法。在 __str__ 方法中，我们使用 f-string 格式化字符串，将对象的名称 name 和年龄 age 输出为描述字符串。

然后，我们创建了一个 Person 类的对象 person，并使用 str() 函数将其转换为描述字符串，并使用 print() 函数直接打印对象。最终，得到的输出结果都是对象的描述字符串。

需要注意的是，当我们在自定义类中使用 str() 函数或 print() 函数时，实际上是在调用该类的 __str__ 方法。使得我们可以根据自己的需求和逻辑来定义和实现对象的描述信息。

2.4 _call_(self, …)

__call__ 是一个特殊的魔术方法，用于将对象作为函数一样进行调用。当使用括号将对象后面加上参数列表时，__call__ 方法会被调用。

定义了 __call__ 方法后，我们可以像调用函数一样调用对象，通过将参数传递给对象进行调用。这在某些情况下可以为类对象赋予函数一样的行为。

以下是一个简单的示例，展示了如何使用 __call__ 方法：

class Counter:
    def __init__(self):
        self.count = 0

    def __call__(self):
        self.count += 1
        return self.count

counter = Counter()

print(counter())  # 输出：1
print(counter())  # 输出：2
print(counter())  # 输出：3

在上述代码中，我们定义了一个名为 Counter 的类，其中包含一个 __call__ 方法。在 __call__ 方法中，我们对 self.count 进行自增操作，并返回增加后的值。

然后，我们创建了一个 Counter 类的对象 counter。通过将括号后面跟上空参数列表来调用 counter 对象，实际上是在调用 counter.__call__()。每次调用时，__call__ 方法会自增 count 属性的值，并返回增加后的值。

需要注意的是，__call__ 方法使得对象可以被当作函数一样进行调用，但并不表示对象本身就是函数。__call__ 方法允许我们对对象进行函数一样的行为定义，但对象本身仍然是一个类的实例。

通过重写 __call__ 方法，我们可以实现自定义的可调用对象，使类的实例具有函数一样的行为和特性。

三、魔术方法表

以下是一些常见的魔术方法：

• __init__(self, ...): 对象初始化方法，用于在创建对象时进行初始化操作。
• __str__(self): 返回对象的描述字符串，通过 str() 函数或 print() 函数调用。
• __repr__(self): 返回对象的可打印字符串，通过 repr() 函数调用。
• __len__(self): 返回对象的长度或大小，通过 len() 函数调用。
• __getitem__(self, key): 获取对象的索引值或键值，通过 obj[key] 进行调用。
• __setitem__(self, key, value): 设置对象的索引值或键值，通过 obj[key] = value 进行调用。
• __delitem__(self, key): 删除对象的索引值或键值，通过 del obj[key] 进行调用。
• __iter__(self): 返回对象的迭代器，用于支持对象的迭代操作。
• __next__(self): 返回迭代器的下一个值，通过迭代器的 next() 方法调用。
• __contains__(self, item): 判断对象是否包含某个元素，通过 in 运算符调用。
• __call__(self, ...): 将对象作为函数一样进行调用，通过 obj() 进行调用。
• __add__(self, other): 实现对象的加法操作，通过 + 运算符调用。
• __sub__(self, other): 实现对象的减法操作，通过 - 运算符调用。
• __mul__(self, other): 实现对象的乘法操作，通过 * 运算符调用。
• __div__(self, other): 实现对象的除法操作，通过 / 运算符调用。
• __eq__(self, other): 判断两个对象是否相等，通过 == 运算符进行调用。

这些只是一些常见的魔术方法示例，你可以根据需求和情况在自己的类中重写这些方法，以实现特定的行为和功能。通过合理地使用这些魔术方法，可以使得自定义的类对象更具功能性和灵活性。