Python 魔术方法

#常用魔术方法
#魔术方法不需要用户调用,会在特定的时刻自动执行的方法就是魔术方法

#__init__魔术方法  初始化魔术方法
'''
触发时机:做出对象,对象初始化的时候触发
功能:为对象添加成员[肯定不会添加到类中]
参数:至少一个self接受对象,其他根据情况添加
返回值:无
'''

import random
class Human:
    #属性
    age = 1
    color = 'yellow'

    #方法
    def __init__(self,diyname):
        #为对象添加成员
        #print(self)
        self.hair = '自然卷'
        self.name = 'diyname'
        #随机产生性别
        if random.randrange(0,2) == 1:
            self.sex = '男'
        else:
            self.sex = '女'

    def eat(self):
        print('吃饭')

    def drink(self):
        print('喝水')

#实例化对象
zw = Human('旺旺')
print(zw.__dict__)

print(Human.__dict__)


#__new__ 构造方法
'''
触发时机:创建对象的时候触发(在语法上和init的触发相同)
功能:控制对象的创建过程
参数:至少一个cls接受当前的类,其他根据情况决定
返回值:有返回值也可以没有(这里的返回值通常返回对象)
'''

class Human:
    #属性
    age = 18
    sex = 'man'

    #方法
    def __new__(cls,diyname):
        #print('new方法被触发')
        print(cls)
        return object.__new__(cls)

    def __init__(self,diyname):
        pass

    def sleep(self):
        print('睡觉')

    def eat(self):
        print('吃饭')

#实例化对象
sy = Human('阳') #1.创建对象(new)  2.对对象进行初始化操作(init)
print(sy)


#单例设计模式

class WangYingsong:
    #属性
    color = 'yellow'
    age = 27
    name = '应松'
    #声明了一个类成员属性用于保存创建的对象
    obj = None

    #方法
    def __new__(cls):

        #检测是否已经制作过对象
        if cls.obj == None:#没有做过对象
            #实例化对象(存入当前类中)
            cls.obj = object.__new__(cls)
            return cls.obj
        else:#做过对象,直接将类中保存的对象返回
            return cls.obj

    def study(self):
        print('好好学习天天向上')

    def eat(self):
        print('吃饭')

#实例化对象1
ys1 = WangYingsong()
print(ys1)

#实例化对象2
ys2 = WangYingsong()
print(ys2)

#实例化对象3
ys3 = WangYingsong()
print(ys3)


#del魔术方法
'''
触发时机:当对象被内存回收的时候自动触发[1.页面执行完毕回收所有变量 2.对象的所有变量被del的时候]
功能:处理对象使用完毕时候的成员或者资源的回收
参数:一个self接受对象
返回值:无
'''
class Human:
    #属性
    money = 1000
    sex = 'man'
    age = 18
    name = '小松松'

    #方法
    def eat(self):
        print('吃饭')

    def drink(self):
        print('喝水')

    #del魔术方法  析构方法
    def __del__(self):
        print('del方法被触发')

#实例化对象
ss = Human()
#将对象赋值给另外一个变量
yy = ss
print(ss)
print('----------')

del ss
del yy

print('----------')


#文件读取操作
'''
1.打开文件
2.读取文件
3.关闭文件
'''

'''
fp = open('11.txt','r')
fp.read()
fp.close()
'''
class ReadFile:

    #打开文件(构造)
    def __init__(self,filename):
        #打开文件将文件io对象保存在对象成员
        self.fp = open(filename,'r')

    #读取文件
    def fread(self):
        return self.fp.read()

    #关闭文件(析构)
    def __del__(self):
        print('关闭文件操作')
        self.fp.close()

#实例化对象
one = ReadFile('11.txt')
txt = one.fread()
print(txt)


#call魔术方法
'''
触发时机:把对象当做函数调用的时候自动触发
功能:简化操作
参数:至少一个self接受当前对象,其他参数根据程序决定
返回值:根据程序决定
'''
class Human:
    #属性
    sex = 'man'
    age = 18
    color = 'yellow'
    #方法
    def eat(self):
        print('吃饭')

    def sleep(self):
        print('睡觉')

    def __call__(self):
        print('call魔术方法被触发')

#实例化对象
bb = Human()
print(bb)
#把对象当做函数调用的时候
bb()


#做蛋糕的类

class MakeCake:
    #和面
    def huomian(self):
        print('和面操作')
    #发酵
    def fajiao(self):
        print('发酵操作')
    #烘烤
    def hongkao(self):
        print('烘烤操作')
    #切形状
    def zaoxing(self):
        print('切形状')
    #抹奶油
    def monaiyou(self):
        print('抹奶油操作')

    #打包
    def dabao(self):
        print('打包操作')
        return '完整的盒装蛋糕'

    #获取蛋糕的方法
    def __call__(self,who):
        print('制作者:',who)
        self.huomian()
        self.fajiao()
        self.hongkao()
        self.zaoxing()
        self.monaiyou()
        result = self.dabao()

        return result

#实例化对象
mc = MakeCake()

#用户获取蛋糕
r = mc('大厨')
print(r)


#len魔术方法
'''
触发时机:使用len(对象)的时候自动触发
功能:用于检测对象中或者类中某个内容的个数
参数:只有一个参数self接受当前对象
返回值:必须返回整型
'''
class Human:
    #属性
    sex = 'man'
    age = 18
    color = 'yellow'

    #方法
    def eat(self):
        print('吃饭')

    def drink(self):
        print('喝水')

    #魔术方法__len__
    def __len__(self):
        print('len方法被触发')
        #去掉所有带下划线开头和结尾的成员
        #获取所有带下划线的成员
        result = {k:v for k,v in Human.__dict__.items() if k.startswith('__') and k.endswith('__')}
        print(result)
        #获取所有成员
        alls = Human.__dict__
        #获取用户定义的普通成员个数 相减
        return len(alls   ) - len(result)

#实例化对象
mmf = Human()
print(mmf)

result = len(mmf)
print(result)


#str魔术方法
'''
触发时机:使用print打印对象的时候或者str(对象)都可以触发
功能:定义对象转换为字符串的结果
参数:一个self接受对象
返回值:必须返回字符串类型
'''
class Human:
    #属性
    sex = 'man'
    age = 18
    name = 'wangcheng'

    #方法
    def la(self):
        print('lalala')

    def sa(self):
        print('谁先来')

    #魔术方法__str__
    def __str__(self):
        print('str被触发')
        return 'laxini'
        return self.name

#实例化对象
wc = Human()
#print(wc)

result = str(wc)
print(result)


#repr魔术方法
'''
触发时机:使用repr(对象)的时候触发
功能:定义repr函数的结果
参数:一个self接收当前对象
返回值:必须是字符串类型
'''
class Human:
    #属性
    sex = 'woman'
    age = 18
    height = '178cm'

    #方法
    def think(self):
        print('思想')

    def dream(self):
        print('I have a dream')

    #__repr__魔术方法
    def __repr__(self):
        print('repr方法被触发')
        return 'zw对象'
    #设定__str__和__repr__的魔术方法相同
    __str__ = __repr__
#实例化对象
zw = Human()
result = repr(zw)
print(result)

#测试repr函数
var = '123'
print(var)
result = repr(var)
print(result)


#__bool__魔术方法
'''
触发时机:使用bool(对象)的时候自动触发
功能:根据某个规则确定对象的布尔值转换结果
参数:一个self接受当前对象
返回值:必须是布尔类型
'''
class Human:
    #属性
    sex = 'woman'
    age = 20
    color = 'yellow'

    #方法
    def getMoney(self):
        print('赚钱')

    def spendMoney(self):
        print('花钱')

    #__bool__魔术方法
    def __bool__(self):
        #print('bool方法被触发')
        #设置当前对象 男 -> True 女 -> False
        if self.sex == 'man':
            return True
        return False
#实例化对象
bb = Human()
result = bool(bb)
print(result)


#format魔术方法

class Human:
    #属性
    name = 'feng'
    sex = 'man'
    age = 18
    #方法
    def lang(self):
        print('划船一身浪')

    def show(self):
        print('xiufeng')
    #__format__魔术方法
    def __format__(self,arg):
        print('format方法被触发')
        print(arg)

        #  >  <  ^
        #将arg(限定符号)进行拆分
        flag = arg[0] # @
        align = arg[1] # > < ^
        num = int(arg[2:]) # 6
        #判断对齐方式
        if align == '<':#左对齐
            result = self.name.ljust(num,flag)
        elif align == '>':#右对齐
            result = self.name.rjust(num,flag)
        elif align == '^':#居中对齐
            result = self.name.center(num,flag)
        return result

#实例化对象
sf = Human()
str = '{:#^10}去洗澡'
result = str.format(sf)
print(result)

#描述符相关的魔术方法

#描述符类
class Decription:

    #成员属性  共享值的操作
    def __init__(self):
        self.var = 'zhengyang'
    #定义三个操作
    #获取成员属性
    def __get__(self,obj,cls):#self描述符对象  obj接受描述的成员属性username的对象e  cls描述成员属性username所在的类Email
        #print(obj,cls)
        #隐藏名字中间的一个字符
        result = self.var[0]+'*'+self.var[-1]
        return result

    #设置成员属性
    def __set__(self,obj,value):#self描述符对象  obj接受描述的成员属性username的对象e  value设置的值
        #设置时候,默认添加思密达
        self.var = value + '思密达'

    #删除成员属性
    def __delete__(self,obj):#self描述符对象  obj接受描述的成员属性username的对象e
        #删除self.var就可以删除username的访问操作
        #根据密码是否为空决定是否可以删除用户名
        if obj.password == '':
            del self.var
        else:
            pass

class Email:
    #属性
    #希望对用户名进行管控(不是权限管控,而是内容管控)
    username = Decription()#交接操作 将username的操作管控交给描述符类的一个对象
    password = '123456'
    #方法
    def login(self):
        print('登录')
    def logout(self):
        print('注销')

#实例化对象
e = Email()

#获取成员属性
print(e.username)

#设置成员属性
e.username = '张望'
print(e.username)

#删除成员属性
del e.username
print(e.username)


#描述符2
class Email:
    #属性
    #username = ''
    password = ''
    #方法
    def __init__(self):
        #设置var对象成员为描述符的三个方法工作
        self.var = 'yang'

    def login(self):
        print('登录')

    def logout(self):
        print('注销')

    #获取属性的操作
    def getusername(self):
        result = self.var[0] + '*' +self.var[-1]
        return result

    #设置属性的操作
    def setusername(self,value):
        self.var = value

    #删除属性的操作
    def delusername(self):
        #删除的时候对self.var进行操作
        del self.var

    #将username属性交给property指定的函数管理
    username = property(getusername,setusername,delusername)

#实例化对象
e = Email()

#获取成员属性
print(e.username)

#设置成员属性
e.username = 'yangjun'
print(e.username)

#删除成员属性
#del e.username
#print(e.username)


#描述符3
class Email:
    #属性
    #username = ''
    password = ''
    #方法
    def __init__(self):
        #为描述符添加的用于数据通讯的成员属性
        self.var = '匿名'

    def login(self):
        print('登录')
    def logout(self):
        print('注销')

    #获取操作
    @property
    def username(self):
        result = self.var[0] + '*' + self.var[-1]
        return result
    #设置操作
    @username.setter
    def username(self,value):
        self.var = value
    #删除操作
    @username.deleter
    def username(self):
        del self.var

#实例化对象
e = Email()

#获取用户名
print(e.username)

#修改用户名
e.username = 'sun'
print(e.username)

#删除用户名
#del e.username
#print(e.username)

#与属性相关的魔术方法

class Man:
    #属性
    sex = 'man'
    age = 18
    color ='yellow'
    name = 'shizhipeng'

    #方法
    def __init__(self):
        self.gf = 'cortana'
        self.hobby = 'watchTV'

    def chou(self):
        print('piapia')
    def keng(self):
        print('坑娃的')
    '''
    #__getattr__()
   
    触发时机:访问一个不存在的成员属性的时候触发
    功能:1.防止访问不存在成员报错 2.可以为不存在的成员设置默认值
    参数:一个self接受对象  一个参数接受要访问的不存在的成员名
    返回值:可以有可以没有,如果有则是设置了访问的成员的值
    
    def __getattr__(self,attrname):
        #print(attrname)
        if attrname == 'height':
            return '175cm'
        elif attrname =='weight':
            return '75kg'
        else:
            return '对不起,不存在该属性'
    '''
    '''
    #__getattribute__()
    
    触发时机:访问对象成员时触发(无论是否存在)
    功能:可以限制过滤指定成员的值的访问
    参数:一个self接受当前对象  一个接受要访问的成员名
    返回值:可以有,可以没有  推荐根据程序设定(一般有!)
    
    def __getattribute__(self,attrname):

        if attrname == 'name':
            #不能通过当前对象访问成员(访问时绝对不允许使用[对象,成员名]的格式获取)触发递归!
            return object.__getattribute__(self,attrname)
        elif attrname == 'sex':
            return object.__getattribute__(self,attrname)
        else:
            return'对不起,成员不存在或者不允许访问'
    '''

    #__setattr__
    '''
    触发时机:对成员属性进行设置的时候触发
    功能:限制或者过滤对象成员的修改
    参数:一个self接受当前对象  一个接受修改的成员名  一个要修改的成员值
    返回值:没有返回值!
    '''
    def __setattr__(self,attrname,value):
        #可以在设置成员属性时候进行判断
        if attrname == 'sex' or attrname == 'name':
            pass
        else:
            object.__setattr__(self,attrname,value)

    #__delattr__ 魔术方法
    def __delattr__(self,attrname):
        #根据删除的内容决定是否允许删除
        if attrname == 'hobby':
            pass
        else:
            object.__delattr__(self,attrname)

#实例化对象
szp = Man()

'''
#获取对象的成员属性(getattr魔术方法)
print(szp.height)
print(szp.weight)
print(szp.length)
'''

#获取对象的成员属性(getattribute)
#print(szp.color)

#设置成员属性
#szp.sex = 'no man no woman'
#print(szp.sex)

#szp.name = '失了志'
#print(szp.name)

#szp.color = 'black'
#print(szp.color)

#删除成员属性
print(szp.__dict__)
del szp.gf
print(szp.__dict__)


#dir魔术方法
class Human:

    #属性
    sex = 'man'
    age = 18
    name = 'dog'

    #方法
    def eat(self):
        print('吃饭')
    def drink(self):
        print('喝水')

    #__dir__
    def __dir__(self):
        #获取所有可以访问的成员
        lists = object.__dir__(self)
        #过滤魔术方法  只留下自定义成员
        newlists = []
        for i in lists:
            if i.startswith('__') and i.endswith('__'):
                pass
            else:
                newlists.append(i)

        return newlists
#实例化对象
qw = Human()

#获取当前对象中所有存在的成员
result = dir(qw)
print(result)


#其他魔术方法

#自定义我们自己的整型类
class Myint(int):
    '''
    #__add__加法的魔术方法(int类中本来就有)
    def __add__(self,other):
        #print('add方法被触发')
        #print(self,other)
        return int(self) - int(other)
    '''
    #__radd__反向加法的魔术方法(int类中本来就有)
    def __radd__(self, other):
        #print('radd方法被触发')
        return int(self) * int(other)

#实例化对象
no1 = Myint(50)
#result = no1 + 15
#print(result)

'''
#练习:自定义一个整型,相加时进行的运算为10位数相乘+个位数相减
class Myint(int):
    def __add__(self,other):
        return int((self // 10) * (other // 10)) + int(self % 10 - other % 10)

no1 = Myint(18)

result = no1 + 25
print(result)
'''
#反向加法运算__radd__
result = no1 + 40
print(result)
'''
#练习:自定义一个整型,反向相加运算时获取2个数值的个位数的乘积作为结果
class Myint(int):
    def __radd__(self, other):
        return int(self % 10) * int(other % 10)

no1 = Myint(18)
result = 25 + no1
print(result)
'''


#比较运算
class Myint(int):

    #__eq__ 相等魔术方法
    def __eq__(self,other):
        #print('eq方法被触发')
        #print(self,other)
        #自定义规则:如果2个数都能被6整除 相等 其余都不相等
        if self % 6 == 0 and other % 6 == 0:
            return True
        else:
            return False

    #__gt__ 大于比较魔术方法
    def __gt__(self,other):
        if self % 5 > other % 5:
            return True
        else:
            return False
#实例化对象
no1 = Myint(34)
no2 = Myint(63)

#相等运算
result = no1 == no2
print(result)
'''
#练习:只要个位数相等 就相等 其余都不相等
class Myint(int):
    def __eq__(self,other):
        if (self % 10) == (other % 10):
            return True
        else:
            return False
no1 = Myint(12)
no2 = Myint(22)

result = no1 == no2
print(result)
'''
#大于比较运算
result = no1 > no2
print(result)