python常用魔法方法

__code__获取一个函数对象中的参数数量

def add_func(x, y):
    return x + y
print(add_func.__code__.co_argcount)

__call__使一个对象可以像函数一样被调用

"""__call__()是一个特殊的魔法方法，用于使一个对象可以像函数一样被调用。当我们在一个对象上使用调用运算符()时，Python会自动调用这个对象的__call__()方法。
__call__()方法可以接受任意数量的参数，并且可以返回任何类型的值。如果一个对象定义了__call__()方法，那么我们就可以像调用函数一样来调用这个对象"""
class Compose:
    def __init__(self, func1, func2):
        self.func1 = func1
        self.func2 = func2

    def __call__(self, x) -> Any:
        return self.func1(self.func2(x))

def test_func1(x):
    return x + x

def test_func2(y):
    return y * y

c_obj = Compose(test_func1, test_func2)
q = c_obj(2)
print(q)
# 运行结果是8（也就是2*2 + 2*2）

__init__对象初始化方法，创建对象时调用

"""__init__()是一个特殊的魔法方法，用于在创建一个对象时进行初始化操作。当我们创建一个类的实例时，Python会自动调用这个类的__init__()方法，以便对该实例进行初始化"""
class Person:
    def __init__(self, name, age, school):
        self.name = name
        self.age = age
        self.school = school

    @property
    def introduce(self):
        return f"学生【{self.name}】，年龄【{self.age}】，毕业于【{self.school}】"


if __name__ == "__main__":
    user = Person("黄大师", 18, "清华大学")
    print("user.name:", user.name)
    print("user.age:", user.age)
    print("user.school:", user.school)
    print("user.introduce:", user.introduce)
'''
运行结果：
user.name: 黄大师
user.age: 18
user.school: 清华大学
user.introduce: 学生【黄大师】，年龄【18】，毕业于【清华大学】
'''

__new__创建一个新的对象

'''__new__()是一个特殊的魔法方法，用于创建一个新的对象。当我们创建一个类的实例时，Python会自动调用这个类的__new__()方法，以便为该实例分配内存空间，并返回一个指向该空间的引用'''
class Singleton:
    _instance = None

    def __new__(cls):
        if cls._instance is None:
            cls._instance = super().__new__(cls)
        return cls._instance


if __name__ == "__main__":
    s1_obj = Singleton()
    s2_obj = Singleton()
"""
我在debug过程中，在debug得时候
super().__new__(cls) 这一行提示我：RuntimeError: super(): no arguments
这时，将super().__new__(cls)替换为super(Singleton, cls).__new__(cls)便不会有问题
"""

enter__和__exit 上下文管理器

'''
一个对象要成为上下文管理器，必须实现两个魔法方法__enter__()和__exit__()，它们被称为上下文管理器协议。当进入with语句块时，Python会调用对象的__enter__()方法，并返回一个值。当离开with语句块时，Python会调用对象的__exit__()方法，并在此方法中执行一些清理操作'''
class ContentManage:

    def __enter__(self):
        print("进入上下文管理器")
        return self

    def do_work(self):
        print("做点啥事")

    def __exit__(self, exc_type, exc_value, traceback):
        print("事情做完了，自动退出")
with ContentManage() as cm:
    cm.do_work()
print("结束")
"""
执行结果：
进入上下文管理器
做点啥事
事情做完了，自动退出
结束
"""

__str__对象的字符串表示

'''可以通过print(obj)或str(obj)调用'''
class MagicFunc():
    def __init__(self, name):
        self.name = name

    def __str__(self):
        return f"MagicFunc.__str__.name:{self.name}"


if __name__ == "__main__":
    magic_func_obj = MagicFunc("王老五")
    print("print(magic_func_obj):", magic_func_obj)
    print("str(magic_func_obj):", str(magic_func_obj))

repr 对象的字符串解释

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

    def __repr__(self) -> str:
        return f"MagicFunc.__repr__:{self.name}"
magic_func_obj = MagicFunc("王老五")
print(repr(magic_func_obj))
"""
定义__repr__：执行结果：
repr(magic_func_obj)
'MagicFunc.__repr__:王老五'
=======================
未定义__repr__：执行结果：
repr(magic_func_obj)
'<__main__.MagicFunc object at 0x10fbcb610>'
"""

__len__对象的长度

"""可以通过len(obj)调用"""
class MagicFunc():
    def __init__(self, name):
        self.name = name

    def __len__(self):
        print(f"MagicFunc.name的长度为：{str(len(self.name))}")
        return len(self.name)

if __name__ == "__main__":
    magic_func_obj = MagicFunc("王老五")
    print(len(magic_func_obj))
'''
执行结果为：
MagicFunc.name的长度为：3
'''

getitem, setitem__,delitem

"""
__getitem__(self, key): 获取对象中指定键的值，可以通过obj[key]调用。
__setitem__(self, key, value): 设置对象中指定键的值，可以通过obj[key] = value调用。
__delitem__(self, key): 删除对象中指定键的值，可以通过del obj[key]调用。
"""
class MagicFunc():
    def __init__(self, name):
        self.name = name

    def __getitem__(self, key):
        if key not in dir(self):
            return None
        else:
            return getattr(self, key)

    def __setitem__(self, key, value):
        setattr(self, key, value)
        return True

    def __delitem__(self, key):
        if key not in dir(self):
            return None
        else:
            print(f"删除key:{key},value:{getattr(self, key)}")
            return delattr(self, key)
if __name__ == "__main__":
    magic_func_obj = MagicFunc("王老五")
    print(magic_func_obj['name'])
    magic_func_obj['age'] = "18"
    del magic_func_obj['age']
    print(magic_func_obj['age'])
'''
执行结果：
王老五
删除key:age,value:18
None
'''

iter(self): 对象的迭代器，可以通过for item in obj:调用

next(self): 迭代器的下一个值，可以通过next(obj)调用

contains(self, item): 对象是否包含指定项，可以通过item in obj调用。

getattr(self, name): 获取对象中不存在的属性时调用。

setattr(self, name, value): 设置对象中不存在的属性时调用。

delattr(self, name): 删除对象中不存在的属性时调用。

call(self[, args…]): 对象的可调用方法，可以通过obj()调用。

add(self, other): 加法运算，可以通过obj1 + obj2调用。

sub(self, other): 减法运算，可以通过obj1 - obj2调用。

mul(self, other): 乘法运算，可以通过obj1 * obj2调用。

truediv(self, other): 真除法运算，可以通过obj1 / obj2调用。

floordiv(self, other): 地板除法运算，可以通过obj1 // obj2调用。

mod(self, other): 取模运算，可以通过obj1 % obj2调用。

pow(self, other[, modulo]): 幂运算，可以通过obj1 ** obj2调用。

lt(self, other): 小于运算，可以通过obj1 < obj2调用。

le(self, other): 小于等于运算，可以通过obj1 <= obj2调用。

eq(self, other): 等于运算，可以通过obj1 == obj2调用。

ne(self, other): 不等于运算，可以通过obj1 != obj2调用。

gt(self, other): 大于运算，可以通过obj1 > obj2调用。

ge(self, other): 大于等于运算，可以通过obj1 >= obj2调用。