python魔术方法

# 例如
class Mytest():
    def __init__(self):
        print("----这是魔术方法__init__")
	
Mytest()

# 类
class Demo:
    pass
# 判断对象是否可被调用，有个函数可以使用——callable
print(callable(Demo))   ======》 返回True，可被调用
# demo类创建出来的对象是否可被调用，是不能的被调用的
obj = Demo()
obj()

class Demo:
    def __call__(self, *args,**kwds):
        print("这是__call__方法执行了")
print(callable(Demo))
# demo类创建出来的对象是否可被调用（不能被调用）
obj = Demo()

obj()          # 等同于：obj.__call__() 方法
obj()
obj()

class MyTest(object):
    # 初始化对象
    def __init__(self):
        print('-------init------方法')
	# 创建对象
    def __new__(cls, *args, **kwargs):
        print('------new方法-------')
        obj = super().__new__(cls)        # 调用父类的new来创建对象
        return obj     # 并返回新的对象
obj = MyTest()

class Demo:
    def __bool__(self):
        """内置函数bool()，获取对象的布尔值是会执行这个方法"""
        return True
b = Demo()       
# 获取对象的布尔值，返回True 或 False
print(bool(b))    =====》 返回 True

class Demo:
    def __str__(self):
        """
        使用print去输出对象时，输出到控制台的内容是由__str__来决定的
        """
      return 'zifuc'
b = Demo() 
# str方法
s = str('123')
print(s)    =======》 返回 123

class Demo:
    def __repr__(self):
        """
        这个方法也是控制对象显示的，一般会显示对象的原始信息
        """
        return 'repr-number'
b = Demo()         
# repr方法
s = repr('123')
print(s)    =======》 返回 '123'

class Demo:
    def __len__(self):
        """
        这个方法是获取对象的长度
        :return:
        """
        return 3
 b = Demo()       
# 获取对象的长度
print(len(b))    =====》 返回 3

class Demo:
    def __hash__(self):
        """
        这个方法是获取hash值
        :return:
        """
        return 999
b = Demo()   
# 获取hash值
print(hash(b))    =====》 返回 999

class Mytest:
    def __setitem__(self, key, value):
        return setattr(self, key, value)
m = Mytest()
print(m.__dict__)     没有数据，为空字典
m.name = 'gddg'     ==== 》 设置name属性，值为gddg
m['age'] = 18      ==== 》 设置age属性，值为18

class Mytest:
    def __getitem__(self,item):
        return getattr(self,item)
m = Mytest()
print(m['name'])     ==== 》 name属性，值为gddg

class Mytest:
    def __delitem__(self,item):
        delattr(self,item)
m = Mytest()
del m['name']      ==== 》 删除name属性

class MyTest:
    def __contains__(self, item):
        """成员运算符触发的魔术方法"""
        return True
a = MyTest()
b = MyTest()
print(a in b)   =======》 返回 True

class IterClass:
    def __iter__(self):
        """
        __iter__方法的返回值必须是一个迭代器
        """
        return iter([11, 22, 33, 44])     ===== 》返回一个迭代器
li = IterClass()
for i in li :
	print(i )
for遍历对象：
    1、执行对象的__iter__方法(返回迭代器)
    2、在循环使用next对迭代器进行迭代

a = 1
b = 2
print(a + b)    ======》 实际执行的是：a.__add__(a,b)
print(a - b)    ======》 实际执行的是：a.__sub__(a,b)

a = '123'
b = '12'
print(a + b)    ======》 实际执行的是：a.__add__(a,b)
print(a - b)    ======》 实际执行的是：a.__sub__(a,b)

class MyStr(str):
    def __sub__(self, other):
        return self.replace(other, '')
a = MyStr('1234')
b = MyStr('123')
print(a + b)     ======= 》  返回 1234123
print(a - b)    ======= 》  返回 4