魔术方法笔记0-1

#__init__ 魔术方法

'''
触发时机：实例化对象后自动触发
功能：对对象进行成员属性的设定(成员归对象所有)
参数：由一个self接收当前对象，其余根据需求决定
返回值：不需要

import random
class Human:
    #属性
    name = '张三'
    sex = '男'
    age = 18
    color = 'yellow'
    #方法
    def __init__(self,newname):
        #print('init执行')
        if random.choice(['男','女']) == '男':
            self.sex ='男'
        else:
            self.sex='女'
        self.name = newname
    def eat(self):
        print('我喜欢吃虾爬子')
    def drink(self):
        print('我喜欢喝山泉水')
#实例化对象
ld = Human('我') #1.制作对象   2.初始化对象（初步处理）
print(ld.__dict__)

#__new__  魔法方法
'''
触发时机：实例化对象的过程当中触发
功能：根据事情情况决定是否产生对象
参数：一个cls接收当前类，其余根据需求决定（new魔术方法的参数和init的参数一样）
返回值：可有可无
'''

class Human:
    #属性
    age = 0
    color = 'yellow'
    #方法
    def __new__(cls,familyName): #实际操作相当于重载object中的__new__方法
      #print(cls)  #cls表示当前类
    #判断是否姓王
        if familyName == '王':
            return object.__new__(cls)
        else:
            return None


#实例化对象
x = Human('王')  #制作对象  #初始化对象（初步处理
print(x)

#__del__ 魔术方法
'''
触发时机：当对象从内存中被移除的时候自动触发
1.系统回收所有资源，页面结束  2，所有该对象的变量，都被删除的时候
功能：回收系统资源
参数：一个self接收当前对象
返回值：无

'''

class Human:
    #属性
    color = 'yellow'
    age = 12
    #方法
    def eat(self):
        print('咖啡')

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

#实例化对象
jr = Human()  #不是这里触发的
#将多个变量指向对象
xj = jr #两者都是使用同一个对象
#从内存中删掉对象
del jr #删除变量  内存会回收资源
del xj
print('-----')

#__call__ 魔术方法

#触发时机：将对象当做函数调用自动触发时机
#功能：代替一个方法的名称，为操作提供快捷方式
#参数：一个self

class ReadFile:
    #打开文件
    def __init__(self,path):
        #设定读取的文件路径
        self.filepath = path
        #打开文件（将文件指针存入当前对象）
        self.fp = open(self.filepath,'r')

    #读取文件  （只读取操作）
    def __call__(self, askNums):
        result = self.fp.read()
        #检测是否需要打印字数
        if askNums == True:
            print(result,len(result))
        else:
            print(result)


        #关闭文件
    def __del__(self):
        self.fp.close()


#实例化对象
rf = ReadFile('C:\\Users\\cz\\Desktop\\ip.txt')
#将对象当做函数调用
jg =rf(True)

#__len__ 魔术方法
'''
触发时机：使用len检测对象的时候自动触发
功能:计算某个事物的长度
参数：一个self 接收当前对象
返回值;必须是一个整数
'''

class Human:
    #属性
    age = 10
    color = '黄色'
    eye = 2
    #方法
    def eat(self):
        print('hhah')
    def __len__(self):
        print('len魔术被调用')
        print(Human.__dict__) #获取类的所有成员  字典
        #过滤出来所有自定义成员
        allmember = {k : v for k,v in Human.__dict__.items() if not(k.startswith('__')and(k.endswith('__')))}
        return len(allmember)


#实例化对象
juzi = Human()
#len()   检测对象
result = len(juzi)  #出发魔术方法len
print(result)

#__str__ 魔术方法
'''
触发时机：使用print()   打印对象的时候或者使用str() 转换对象的时候自动触发
功能;设置对象打印时候的值
参数;一个self接收当前对象
返回值;必须是字符串类型
'''

class Jia:
    #属性
    sex = '女'
    #定义打印对象的结果
    def __str__(self):
        return 'hello'

#实例化对象
j = Jia()
#直接打印对象
print(j)

result = '我'+str(j)+'实习'
print(result)

#__repr__ 魔术方法
'''
触发时机;使用repr()  操作对象时自动触发
功能：设置repr()   操作对象的返回结果
参数：一个self接收当前对象
返回值：必须是字符串
'''

class Zhang:
    #成员属性
    sex = '男'

#定义repr魔术方法
    def __repr__(self):
        return '$$hello%%'
#类中默认都有一句话
#__str__ = __repr__

#定义str的魔术方法
    def __str__(self):
        return '3.4cm'

#实例化对象
zl =Zhang()
print(zl)

#repr()
result =repr(zl)
print(result)

#___bool__ 魔术方法
'''
触发时机： 使用bool转换对象的时候自动触发
功能：检测成员的状态
参数：一个self接收当前对象
返回值;必须是布尔值
'''

class Pei:
    #属性
    married = '单身'
    #方法
    def __bool__(self):
        #判断此人是否已婚
        if self.married == '已婚':
            return True
        else:
            return False

#实例化对象
p =Pei()
result = bool(p)
print(result)

#__format__ 魔术方法
'''
触发时机： 使用format操作对象的时候时候自动触发
功能;定义format操作对象的方式
参数：一个self接收当前对象，一个形参接收format的限定符号
'''

class SunYuWei:
    #属性
    name = 'hello'
    #方法
    def __format__(self, sign):
        print(sign)
        #获取标志内容
        fillchar = sign[0]
        align = sign[1]
        total = int(sign[2:])#将字符串转换为整数
        print(total,type(total))
        #判断对齐方式
        if align =="^": #居中对齐
            result = self.name.center(total,fillchar)
        elif align == ">": #右对齐
            result = self.name.rjust(total,fillchar)
        elif align == "<": #左对齐
            result = self.name.ljust(total,fillchar)
        else:
             'mmp'
        return result
#实例化对象
lw = SunYuWei()
#使用format函数
str1 = '一起he{:^10}去吃饭'
result =str1.format(lw)
print(result)

描述符相关的魔术方法

1.__get__()

触发时机：在获取指定描述符操作的成员属性的值的时候触发

参数：1描述符对象本身，2描述符描述的属性所在的对象，描述符描述的对象的类

返回值：必须有，不然无法获取相应属性值

注意：仅在描述符中使用

2.__set__()

触发时机：在设置或者添加指定描述符操作的成员属性的时候触发

参数：1描述符对象本身，2描述符描述的属性所在的对象,3要设置的值

返回值：无

注意：仅在描述符中使用

3.__delete__()

触发时机：在删除指定描述符操作的成员属性的时候触发

参数：1描述符对象本身，2描述符描述的属性所在的对象

返回值：无

注意：仅在描述符中使用

#描述符
#掌管成员属性操作的类
class MSF:
    #建立一个代替成员属性的临时属性（稻草人）
    def __init__(self):
        #就是在描述符类中代替username进行操作
        self.var = '张勒'
    #获取成员属性
    def __get__(self,obj,cls):#self 当前描述赋的对象  obj邮箱对象   cls邮箱类
        #用户名获取的相关处理（隐藏中间文字，只显示开头和结尾）
        result = self.var[0]+'*'+self.var[-1]
        return  result

    #设置成员属性
    def __set__(self,obj,value):
        #设置值，可以添加条件，内容的修饰操作
        self.var= value

    #删除成员属性
    def __delete__(self, obj):
        #通过邮箱对象判断用户名是否允许删除
        if obj.isallowdel == True:
            #将self.var删除  相当于删除了username
            del self.var
        else: #不允许删除
            pass
class Email:
    #成员属性
    username = MSF()  #操作的内容   #将用户名交给描述符的一个【对象】掌管
    password = '123445'
    #是否允许删除用户名
    isallowdel = False

    #成员方法
    #登录
    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 Eamil:
    # 成a员属性
    #username = '匿名用户'
    password = '12346789'
    # 是否允许删除用户名
    isallowdel = False

    # 成员方法
    # 登录
    def login(self):
        print('登录邮箱!')

    # 推出
    def logout(self):
        print('推出登录')


    def __init__(self):

        #设置一个用于在描述符中管理用户的映射变量
        self.var = '张科'
    #获取
    def fget(self):
        return self.var
    #设置
    def fset(self,value):
        self.var = value
    #删除
    def fdelete(self):
        del self.var
    #将username交接给描述符（必须在三个方法之后
    username =property(fget,fset,fdelete)

#
#实例化邮箱对象
e = Eamil()
#获取操作
print(e.username)
#设置操作
e.username='胡宏毅'
print(e.username)
#删除操作
del e.username
print(e.username)

#单例设计模式：一个类智能实例化一个对象
class Zhongju:
    #属性
    sex = "女"
    age = 19
    size = '33'
    obj = None #未来存储对象的成员属性
    #方法
    #需要new魔术方法
    def __new__(cls):
        #第一次制作对象
        if cls.obj == None:
            obj = object.__new__(cls)
            #将当前对象存入类中
            cls.obj = obj
            #返回对象
            return cls.obj
        else:
            #直接返回类中制作好的对象
            return cls.obj

#实例化对象
z1 = Zhongju()
print(z1)
z2 =Zhongju()
print(z2)

与属性操作相关的魔术方法

1.__getattr__（）
触发时机：获取不存在的对象成员时触发
参数：1个接收当前对象的self，一个是获取成员名称的字符串
返回值：必须有值
作用:为访问不存在的属性设置值
注意：getattribute无论何时都会在getattr之前触发，触发了getattribute就不会在触发getattr了
例子：

#属性操作的魔术方法
class Human:
    #属性
    def __init__(self):
        self.xingbie = '男'
        self.age = 18
        self.color = 'red'

    '''
    触发时机：访问不存在的成员属性的时候自动触发
    功能：设置不存在的属性的访问结果，可以防止程序报错
    参数:可有可无
    '''
    def __getattr__(self, attrname):
        #为不存在属性设置不同的值
        if attrname == 'name':
            return '匿名用户'
        elif attrname == 'size':
            return '33'
        elif  attrname =='sex':
            return 'xingbie'
        else:
            return False

#实例化对象
juzi = Human()
#访问成员属性
print(juzi.name)
print(juzi.age)

2.__setattr__（）
触发时机:设置对象成员值的时候触发
参数:1个当前对象的self,一个是要设置的成员名称字符串,一个是要设置的值
返回值:无 过程操作
作用:接管设置操作,可以在设置前之前进行判断验证等行为
注意:在当前方法中无法使用成员=值的方式直接设置成员，否则会无限递归，必须借助object的设置方法来完成

object.__setattr__（参数1，参数2，参数3）

class Human:
    age =14
    #重载了object的操作
    def __setattr__(self,attrname,attrvalue):
        #print(attrvalue,attrname)
        #我们无法自行设置，否则会递归，需要object来实现
        if attrname == 'age':
            object.__setattr__(self,attrname,attrvalue)
        elif attrname == 'wing':
            pass

#实例化对象
juzi = Human()
#设置成员属性
juzi.age = 16
juzi.wing = '留意'
print(juzi.__dict__)

3.__delattr__（）
触发时机：删除对象成员时触发
参数：一个当前对象的self
返回值：无
作用:可以在删除成员时进行验证。
class Human:
    #属性
    def __init__(self):
        self.xingbie = '男'
        self.age = 18
        self.color ='red'
        #方法
        def __delattr__(self, attrname):
            print('delatter')
            #验证成员是否被删除
            if attrname == 'xingbie':
                pass
            elif attrname == 'color':
                #借助object来删除
                object.__delattr__(self,attrname)

#实例化对象
jiarui =Human()
print(jiarui.__dict__)
del jiarui.xingbie
print(jiarui.__dict__)

4.__getattribute__（）
触发时机：使用对象成员时触发，无论成员是否存在
参数：1个接收当前对象self，一个是获取的成员的名称字符串
返回值：必须有
作用：在具有封装操作（私有化时），为程序开部分访问权限使用

#人类
class Human:
    #属性
    sex = '男'
    age = 18
    #私有成员
    __heart = '心脏'
    __jj = '3.5CM'

    #方法
    def __getattribute__(self, item):
        #判断哪些成员可以返回
        def __getattribute__(self, attrname):
            # 判断哪些成员可以返回
            if attrname == '__heart':
                return self.__heart
            return object.__getattribute__(self, attrname)



#实例化对象
z =Human()
#访问成员属性
print(z.aaa) #成员属性不存在
print(z.sex)  #成员属性存在
print(z.age)
5.__dir__（）
触发时机：dir（对象）的时候触发
参数:1个接收当前对象self
返回值：必须为序列类型（列表，元组，集合等，）
作用：可以自定义成员列表的返回值
class Human:
    #属性
    color = 'yellow'
    #方法
    def __init__(self,name):
        self.name =name
    def __dir__(self):
        print('dir被触发')
        #获取所有的可以访问的列表
        result = object.__dir__(self)
        #过滤数据，保留非魔术方法内容
        newlist = [i for i in result if not(i.startswith('__')and i.endswith('__'))]
        return newlist


#实例化对象
jr = Human('宏毅')
result = dir(jr)
print(result)