1.类的特殊成员与作用

1.1__init__ __del__

class Test:
    def __init__(self):
        print("我是__init__：构造函数,我的作用是在创建对象时进行初始化操作。可以在这个方法中初始化对象的属性、设置默认值等。")

    def __del__(self):
        print("我是__del__：析构函数,我的作用是在对象销毁时进行清理操作。可以在这个方法中释放资源、关闭文件等。")


t = Test()

运行效果图 自动调用

1.2__init__：构造函数，在创建对象时进行初始化操作。可以在这个方法中初始化对象的属性、设置默认值等。

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

person = Person("Alice", 25)
print(person.name)
print(person.age)

1.3__del__：析构函数，在对象销毁时进行清理操作。可以在这个方法中释放资源、关闭文件等。

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

    def __del__(self):
        print(f"Person {self.name} is being destroyed")

person1 = Person("Alice")
person2 = person1  # person2也引用了同一个对象

del person1  # 删除person1的引用
del person2  # 删除person2的引用

# 输出：Person Alice is being destroyed

2.__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("Alice", 25)
print(person)  # 输出：Person(name=Alice, age=25)

3.__repr__：将对象转换为可打印的字符串，通过repr()函数调用。通常用于调试和开发阶段，返回一个能够表示对象的字符串。

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

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

person = Person("Alice", 25)
print(person)  # 输出：Person(name=Alice, age=25)
print(repr(person))  # 输出：Person(name=Alice, age=25)

4.__len__：返回对象的长度，通过len()函数调用。可以在这个方法中定义自定义对象的长度计算方式。

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

    def append(self, item):
        self.data.append(item)

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

my_list = MyList()
my_list.append(1)
my_list.append(2)
print(len(my_list))  # 输出：2

5.__getitem__和__setitem__：用于实现对象的索引访问。通过下标访问对象的元素时会调用__getitem__方法，通过下标赋值时会调用__setitem__方法。

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

    def append(self, item):
        self.data.append(item)

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

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

my_list = MyList()
my_list.append(1)
my_list.append(2)
print(my_list[0])  # 输出：1
my_list[1] = 3
print(my_list[1])  # 输出：3

6.__delitem__ 是用于实现删除容器对象中指定位置元素或指定键值对的特殊方法。

class MyContainer:
    def __init__(self):
        self.elements = [1, 2, 3, 4, 5]

    def __delitem__(self, index):
        del self.elements[index]

container = MyContainer()
del container[2]  # 删除索引为2的元素
print(container.elements)  # 输出：[1, 2, 4, 5]

7.__getattr__和__setattr__：用于实现对象的属性访问。当访问对象的属性时，如果属性不存在，会调用__getattr__方法进行处理；当对对象的属性进行赋值时，会调用__setattr__方法进行处理。

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

    def __getattr__(self, attr):
        return f"Attribute {attr} does not exist"

    def __setattr__(self, attr, value):
        print(f"Setting {attr} to {value}")
        self.__dict__[attr] = value

person = Person("Alice", 25)
print(person.name)  # 输出：Alice
print(person.gender)  # 输出：Attribute gender does not exist
person.age = 30  # 输出：Setting age to 30

8.__call__：使对象可以像函数一样被调用。在对象后面加上括号时，会调用__call__方法。

class Adder:
    def __init__(self, num):
        self.num = num

    def __call__(self, x):
        return self.num + x

add_5 = Adder(5)
result = add_5(10)
print(result)  # 输出：15

9.__iter__和__next__：用于实现对象的迭代。通过迭代器协议，使对象能够被for循环遍历。

class MyRange:
    def __init__(self, start, end):
        self.start = start
        self.end = end

    def __iter__(self):
        return self

    def __next__(self):
        if self.start >= self.end:
            raise StopIteration
        current = self.start
        self.start += 1
        return current

my_range = MyRange(1, 5)
for num in my_range:
    print(num)  # 输出：1 2 3 4

10.__enter__和__exit__：用于实现上下文管理器。在使用with语句时，会调用__enter__方法获取资源，并在退出with块时调用__exit__方法释放资源。

class FileManager:
    def __init__(self, filename):
        self.filename = filename

    def __enter__(self):
        self.file = open(self.filename, 'w')
        return self.file

    def __exit__(self, exc_type, exc_val, exc_tb):
        self.file.close()

with FileManager('test.txt') as file:
    file.write('Hello, world!')

class File:
    def __enter__(self):
        print("开始")

    def __exit__(self, exc_type, exc_val, exc_tb):
        print("结束")

f = File()

with f:
    print("读取")

11. __new__是一个特殊方法，用于创建一个新的对象。它在实例化一个类时调用，并返回一个新的实例。在Python中，__new__方法通常用于创建不可变的对象，如元组和字符串。

__new__方法的作用是在对象创建之前进行一些预处理操作，比如验证参数、修改实例化行为等。它可以接受任意数量的参数，并返回一个新的实例。

当我们调用一个类来创建对象时，实际上是调用了该类的__new__方法来创建对象，然后再调用__init__方法对对象进行初始化。__new__方法通常会返回一个新的实例，然后__init__方法会对这个实例进行初始化。

需要注意的是，__new__方法是一个静态方法，因此在定义时需要使用@staticmethod装饰器。在实现自定义的__new__方法时，需要调用父类的__new__方法来创建实例，并将参数传递给父类的__new__方法。

class MyClass:
    def __new__(cls, *args, **kwargs):
        # 在创建实例之前进行预处理操作
        print("Preprocessing...")

        # 调用父类的__new__方法创建实例
        instance = super().__new__(cls)

        return instance

    def __init__(self, *args, **kwargs):
        # 对实例进行初始化操作
        print("Initializing...")

        # 其他初始化代码...

# 创建对象
obj = MyClass()

输出结果：
Preprocessing...

Initializing...