在Python中，类特殊成员是指以双下划线开头和结尾的属性和方法，也被称为魔术方法（Magic methods）或特殊方法（Special methods）。这些特殊成员在类的定义中具有特殊的语法和功能，用于实现对象的特定行为和操作。

特殊方法一般由Python解释器调用，无需手动调用。通过在类中定义这些特殊方法，可以改变对象的默认行为，使其具备更多的功能和操作。特殊方法提供了一种更加Pythonic的面向对象编程的方式，可以让代码更加简洁和易读。

__init__

__init__ 是Python中的一个特殊方法，也被称为构造方法。它在创建对象时自动调用，用于初始化对象的属性。通过在类中定义 __init__ 方法，我们可以在对象创建时为其赋予初始状态，设置属性的默认值，或执行其他必要的初始化操作。

__init__ 方法的格式通常如下：

def __init__(self, arg1, arg2, ...):
    self.attribute1 = arg1
    self.attribute2 = arg2
    # ...

self 代表对象本身，arg1、arg2 等是用于接收传入的参数的形参，我们可以根据实际需要为 __init__ 方法传入不同的参数。

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

person1 = Person("Alittle", 30)

在 __init__ 方法中，我们可以执行其他的初始化操作，例如连接数据库、打开文件、设置默认值等。这使得我们能够在创建对象时，做一些必要的准备工作，确保对象在初始化后即可用。

需要注意的是，Python 中的 __init__ 方法是可选的，不是必须定义的。如果类中没有定义 __init__ 方法，Python 会使用默认的空的 __init__ 方法。但通常情况下，我们会定义 __init__ 方法来初始化对象的属性。

__del__

__del__ 是Python中的一个特殊方法，也被称为析构方法。它在对象被销毁前自动调用，用于进行清理工作。当对象的引用计数为零时（即没有任何变量引用该对象），Python解释器会自动触发 __del__ 方法的调用。

__del__ 方法的格式通常如下：

def __del__(self):
    # 清理代码

在 __del__ 方法中，self 代表对象本身。我们可以在 __del__ 方法中编写需要在对象销毁之前执行的清理代码，例如关闭文件、释放资源、记录日志等。

class FileHandler:
    def __init__(self, filename):
        self.file = open(filename, 'w')

    def write_data(self, data):
        self.file.write(data)

    def __del__(self):
        self.file.close()

handler = FileHandler("data.txt")
handler.write_data("Hello, World!")
# 在退出程序或手动执行 del handler 时，会自动调用 __del__ 方法关闭文件

我们定义了一个 FileHandler 类，其中的 __init__ 方法用于打开文件并创建一个 file 对象。write_data 方法用于向文件写入数据。在 __del__ 方法中，我们通过 self.file.close() 关闭了文件。当程序退出或手动执行 del handler 时，对象 handler 被销毁，会自动调用 __del__ 方法关闭文件，确保资源的正常释放。

另外需要注意的是，__del__ 方法的调用是由Python解释器自动控制的，并不是我们手动调用的。因此，我们不能依赖 __del__ 方法来进行关键性的清理工作，如释放内存。一般来说，Python有自己的垃圾回收机制，会自动管理对象的内存释放。我们只需确保在 __del__ 方法中执行一些简单的清理操作即可。此外，应尽量避免在 __del__ 方法中抛出异常，以免影响其他代码的执行。

__str__

__str__ 也是Python中的一个特殊方法，也被称为字符串表示方法。它定义了当我们对一个对象使用内置的 str() 函数或 print() 函数进行输出时，应该返回的字符串形式表示。简而言之，__str__ 方法用于定制对象的字符串输出。

__str__ 方法的格式通常如下：

def __str__(self):
    # 返回表示对象的字符串

在 __str__ 方法中，self 代表对象本身，没有其他的参数了，我们可以在该方法中编写需要返回的表示对象的字符串形式的代码，例如组织对象的属性信息、状态等。

以下是一个示例，展示了如何使用 __str__ 方法来定制对象的字符串输出：

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __str__(self):
        print("call __str__")
        return f"Point({self.x}, {self.y})"

p = Point(3, 4)
print(p)
print("-----------------")
str(p)

上面的示例中的输出

call __str__
Point(3, 4)
-----------------
call __str__

我们定义了一个 Point 类，其中的 __init__ 方法用于初始化点的坐标。在 __str__ 方法中，我们使用格式化字符串 f-string 将点的坐标表示为 ‘(x, y)’ 的形式。当我们对 p 对象使用 print(p) 和 str(p) 时，会自动调用 __str__ 方法，并返回该方法中定义的字符串 (3, 4)。

__repr__

__repr__ 与 __str__ 方法类似，下面直接用一个例子来说明这个和 __str__ 的区别。

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __str__(self):
        print("call __str__")
        return f"Point1({self.x}, {self.y})"

    def __repr__(self):
        print("call __repr__")
        return f"Point2({self.x}, {self.y})"

p = Point(3, 4)
print(p)
print("-----------------")
str(p)
repr(p)

上面的示例中的输出

call __str__
Point1(3, 4)
-----------------
call __str__
call __repr__

从上面的输出可以看出，repr(p) 函数可以自动调用 __repr__，默认情况下，__str__ 和 __repr__ 同时存在的话，str() 和 print()函数就会优先调用 __str__，而如果只有 __repr__ 的话，就会调用 __repr__，不信你们可以把上面例子中的 __str__ 注释掉，然后看看输出情况。

__len__

__len__ 用于定义对象的长度。它主要被用于内置函数 len() 的操作，用于返回一个对象的长度或元素的个数。

__len__ 方法的格式通常如下：

def __len__(self):
    # 返回对象的长度或元素的个数

在 __len__ 方法中，self 代表对象本身。我们可以在该方法中编写代码，返回一个整数，表示对象的长度或元素的个数。

以下是一个示例，展示了如何使用 __len__ 方法来定义一个自定义的容器类并使用 len() 函数获取其长度：

class MyContainer:
    def __init__(self):
        self.data = []

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

    def add(self, element):
        self.data.append(element)

container = MyContainer()
container.add(1)
container.add(2)
container.add(3)

print(len(container))  # 输出 3，调用了 __len__ 方法

在上面的示例中，我们定义了一个名为 MyContainer 的容器类，该类包含一个名为 data 的列表用于存储元素。在 __len__ 方法中，我们使用内置函数 len() 计算了 data 列表的长度，并返回该长度。当我们通过调用 len(container) 来获取 container 对象的长度时，实际上会自动调用 __len__ 方法，并返回该方法中定义的长度值。

__len__ 方法应该返回一个整数，表示对象的长度或元素的个数。如果一个类没有定义 __len__ 方法，或者 __len__ 方法返回的值不是整数类型，那么调用 len() 函数时会抛出 TypeError 异常。

__getitem__和__setitem__

__getitem__ 和 __setitem__ 几乎都是成对出现的，__getitem__ 用于定义对象的索引操作，即允许通过索引值访问对象的元素，__setitem__ 用于定义对象的赋值操作，即允许通过索引值设置对象的元素值，它主要用于支持下标操作和切片操作。

__getitem__ 和 __setitem__ 方法的格式通常如下：

def __getitem__(self, index):
    # 返回指定索引位置的元素

def __setitem__(self, index, value):
    # 设置指定索引位置的元素为指定的值

这两个方法一个就是取值，一个就是赋值，主要就是应用在对象上面，相对而言比较好理解。

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

    def __getitem__(self, index):
        return self.data[index]

    def __setitem__(self, index, value):
        self.data[index] = value

mylist = MyList()
mylist.data = [1, 2, 3, 4, 5]

print(mylist[2])  # 输出 3，调用了 __getitem__ 方法
mylist[2] = 10  # 调用了 __setitem__ 方法赋值
print(mylist[2])  # 输出 10，调用了 __getitem__ 方法

在上面的示例中，我们定义了一个名为 MyList 的列表类，该类包含一个名为 data 的列表用于存储元素。通过实现 __getitem__ 和 __setitem__方法，我们可以使用类似于列表的方式通过索引来访问和设置 data 列表中的元素。
__getitem__ 方法通常与 __setitem__ 方法一起使用，以支持对象的索引和切片操作。通过定义这些方法，我们可以使自定义的类对象能够像内置的容器类型一样进行元素的访问和修改。

如果一个类没有定义 __getitem__ 和 __setitem__方法，或者__getitem__ 和 __setitem__方法不能处理给定的索引值或切片对象，那么当我们尝试通过索引或切片来访问（设置）对象时，会抛出 TypeError 异常。

__call__

__call__ 用于使对象能够像函数一样被调用。通过定义 __call__ 方法，我们可以将一个对象变成一个可调用的实例，类似于函数的行为。

__call__ 方法的格式通常如下：

def __call__(self, *args, **kwargs):
    # 定义对象的调用逻辑

在 __call__ 方法中，self 代表对象本身，args 和 kwargs 是传递给对象调用时的参数。

当我们像调函数一样使用对象时，Python 解释会自动调用对象的 __call__ 方法，并将传入的参数作为参数递给该方法。我们可以在 __call__ 方法中定义对象的调用逻，然后执行相应的操作。

以下一个示例，展示了如何使用 __call__ 方法来定义一个可调用的对象：

class Adder:
    def __call__(self, x, y):
        return x + y

add = Adder()

# 将对象 add 当作函数进行调用
result = add(3, 5)
print(result)  # 输出：8

在上述示例中，我们定义了一个 Adder 类，并实现了 __call__ 方法。在该方法中，我们将传入的两个参数进行相加，Python 解释器会自动调用对象 add 的 __call__ 方法，并将传递给该方法。__call__ 方法中的逻辑会被执行，参数进行相加操作，然后返回结果。

通过使用 __call__ 方法，我们可以将一个对象实例化后，即可像函数一样进行调用，并执行预定义的逻辑。这样可以增加对象的灵活性，使其更加接近函数的行为。__call__ 方法只有在对象被调用时才会被调用，也就是对象被函数那样调用。

通常情况下，__call__ 方法常用于实现可调用的对象，如自定义的函数对象、装饰器、上下文管理器等。通过定义 __call__ 方法，我们可以使对象具有函数的特性，并能够直接调用执行相应的逻辑。

更多精彩内容，请关注同名公众：一点sir（alittle-sir）