面向对象-魔术方法

魔术方法：一种特殊的方法而已。
特点：不需要人工调用，在特定的时刻自动执行。

1.__init__ 初始化魔术方法 

1.触发时机：实例化对象之后触发
2.作用:为对象添加对象的所属成员。
3.参数：一个self 接受当前对象 其他的参数根据实例化的传参决定
4.返回值：无
5.注意事项：无

 1 #__init__初始化魔术方法
 2 
 3 class Human:
 4     #属性
 5     sex = 'man'
 6     age = 1
 7     name = '张三'
 8     eye =2
 9     skin = 'yellow'
10 
11     #方法
12     #魔术方法__init__
13     def __init__(self,kidname):
14         print('init方法被执行')
15         #为对象加成员
16         self.sex = '男'
17         self.age = 1
18         self.name = kidname
19 
20     def eat(self):
21         print('吃饭的方法')
22 
23     def run(self):
24         print('跑步的方法')
25 
26     def sleep(self):
27         print('睡觉的方法')
28 
29 #实例化一个人的对象
30
31 one = Human('刘佳怡') #实例化对像【1.制作一个对象(new)，2.初始化对像(init)】
32 #输出结果：init方法被执行 33 34 print(one.__dict__)#打印对象成员 35 #输出结果：{'sex': '男', 'age': 1, 'name': '刘佳怡'} 36 37 print(one) 38 #输出结果：<__main__.Human object at 0x00000149782C0048>

 

2.__new__ 构造方法
1.触发时机：实例化对象的时候触发！
2.作用：管理控制对象的生成过程。
3.参数：一个cls接受当前类，其他的参数根据实例化的参数决定
4.返回值：可有可无 没有返回值，实例化结果为None
5.注意事项：new魔术方法跟init的魔术方法的参数一致（除了第一个）

#__init__初始化魔术方法

class Human:
    #属性
    sex = 'man'
    age = 1
    name = '张三'
    eye =2
    skin = 'yellow'

    #方法
    #魔术方法（重载object内部自带的 __new__）
    def __new__(cls,sex):
        print('new方法被触发')
        #return 'new的返回值'
        #自已控制对象的生成过程（女的生，男的不生）
        if sex == '女':
            #生成对象并返回
            return object.__new__(cls) #object上帝之手，重做了一个Human对象
        else:
            return None


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

    def run(self):
        print('跑步的方法')

    def sleep(self):
        print('睡觉的方法')

#实例化一个人的对象
#__new__方法在实例化对象的时候被执行
one = Human('女')#实例化对像【1.制作一个对象(new)，2.初始化对像(init)】
#输出结果：new方法被触发
print(one) #上面实例化是输入女，所以能做出对象：<__main__.Human object at 0x000001B2C1BE0048>
#输出结果：<__main__.Human object at 0x000001B2C1BE0048>

#实例化一个人的对象
#__new__方法在实例化对象的时候被执行
one2 = Human('男')#实例化对像【1.制作一个对象(new)，2.初始化对像(init)】
#输出结果：new方法被触发
print(one2) #上面实例化是输入男，所以不能做出对象：None
#输出结果：None

 __new__方法延伸实例

#__new__将猴子类重载到人类
#猴子类
class Monkey:
    pass

#人类
class Human:
    #重载new方法
    def __new__(cls):
        #返回，对象.重载入Monkey猴子类
        return object.__new__(Monkey)
    pass

#实例化人类对象
ren = Human()

#打印人类对象
print(ren) #返回猴子的对象
#输出结果：<__main__.Monkey object at 0x00000238556B8588>

 

3.__del__ 析构方法 （拆构方法）
1.触发时机：对象被系统回收的时候自动触发(del不一定触发)
2.作用：回收程序使用过程的信息和变量等
3.参数：一个self接收当前对象
4.返回值：无
5.注意事项：无

#__del__析构魔术方法
class Human:
    #属性
    sex = 'man'
    age = 1
    name = '张三'
    eye =2
    skin = 'yellow'
    #方法

    def eat(self):
        print('吃饭的方法')
    def run(self):
        print('跑步的方法')
    def sleep(self):
        print('睡觉的方法')
    # 魔术方法（析构方法一般写在类的最后）
    def __del__(self):
        print('del方法被触发')
#实例化一个人的对象
#__del__方法系统在回收对象的时候被执行
one = Human()#实例化对像
print('==最后的代码==')
'''
在输出结果中可以看出，one对像实例化是在【==最后的代码==】之前，但del方法被触发却
在【==最后的代码==】之后，说明系统在回收对象时触发__del__
输出结果：
==最后的代码==
del方法被触发
'''

 

4.__call__
1.触发时机：将对象当作函数调用的时候自动触发
2.作用：常用于归结类/对象的操作步骤，方便后期掉用
3.参数:一个self接受当前对象，其余的参数根据需求添加
4.返回值：可以有，可以没有
5.注意事项：无

 

#__call__魔术方法
class Human:
    #属性
    sex = 'man'
    age = 1
    name = '张三'
    eye =2
    skin = 'yellow'
    #方法
    def __call__(self,var):
        print('call方法被触发'+ var)
    def eat(self):
        print('吃饭的方法')
    def cry(self):
        print('55555~~~~')

#实例化一个人的对象
#将对象当做函数调用的时候自动触发
one = Human()#实例化对像
one('--->传入的数据')#
#1.在类中没有加入__call__方法，如果对象以【调用函数one()】调用就会如下报错
#2.输出结果：TypeError:“Human”对象不可调用

#3.在类中加入__call__方法，对象就可以【调用函数one(传入的数据)】
#4.输出结果：call方法被触发--->传入的数据

__call__实例，制作一个账号验证过程

#__call__实例，制作一个账号验证过程
class ZuCe:
    ZanHao = '张三'
    Mima = '123456'
    SouJi = '13488888888'
    #__call__魔术方法
    def __call__(self,yanzen):#这里call方法可以传入多个参数
        print(self.ZanHao + yanzen)
        print(self.Mima + yanzen)
        print(self.SouJi + yanzen)

ZC = ZuCe()
ZC('--->验证中...')
'''
输出结果：
张三--->验证中...
123456--->验证中...
13488888888--->验证中...
'''

 

5.__len__

1.触发时机：使用len函数检测对象的时候自动触发
2.作用：使得len可以检测对象中某个数据的信息
3.参数：一个self接受当前对象
4.返回值：必须有,必须是整型
5.注意事项：len检测什么有程序员自己决定

#__len__魔术方法
class Car:
    #属性
    color = '黑色'
    weight = '2T'
    grand = '奥利奥'
    circle =['左前轮','右前轮','左后轮','右后轮','备胎']

    #方法
    def __len__(self):
        print('len方法被触发')
        num = len(self.circle)
        return num
    def playmusic(self):
        print('车正在播放音响中...')
    def move(self):
        print('请注意，倒车...')

#实例化一个人的对象

mycar = Car()
#len函数接收对象，对象的方法得到__len__魔术方法，还得有return 返回值
result = len(mycar)#对象的返回值得有个变量来接收来可以
#没有加入__len__方法的输出结果：类型'Car'的对象没有len()

#加入__len__方法的输出结果：TypeError: 'NoneType'对象不能解释为整数
#在__len__方法中加入 【return 整数】，输出结果：不会报错

print(result)#
#输出结果：5

 

6.__str__
1.触发时机：使用print打印对象的时候自动触发
2.作用：可以定义打印对象显示的信息内容
3.参数：一个self接受当前对象
4.返回值：必须有，且必须是字符串类型
5.注意事项：除了print之外，使用str() 转换数据的时候也会触发

 

#__str__魔术方法
class Human:
    #属性
    color = '黄色'
    sex = '女'
    age = 18
    name = '黄小丽'

    #方法
    def __str__(self):#重载魔术方法__str__（继承object类的）
        #__str__魔术方法必须返回值：'字符串'
        print('str被触发')
        return '加载了str方法'
    def eat(self):
        print('真香...')
    def smile(self):
        print('哈哈哈哈哈哈...')

#实例化一个人的对象

hxl = Human()
print(hxl)

#没有重载__str__方法时打印对象，其实对象本身就有__str__方法，输出对象本身
#输出结果：<__main__.Human object at 0x00000241992C0F28>
'''
加重载__str__方法时打印对象
输出结果：
str被触发
加载了str方法
'''

#str第二个被触发的时机，用str转换，只打印输出，没打印返回值
str(hxl)
#输出结果：str被触发

 

7.__repr__
1.触发时机：在使用repr转换对象的时候自动触发
2.作用：可以设置repr函数操作对象的结果
3.参数：一个self接受有当前对象本身
4.返回值：有必须是字符串
5.注意事项：正常情况下，类中的__str__和__repr__魔术方法是完全一样的（字符串中的str和repr魔术方法就不一样。）

#__repr__魔术方法
class Human:
    #属性
    color = '黄色'
    sex = '女'
    age = 18
    name = '黄小丽'

    #方法
    def __repr__(self):
        print('repr方法被触发')
        #所有类默认存在一个等式
        #__str__ = __repr__ 将repr的方法赋值给str方法，完全一样
        return 'repr返回值'

    def __str__(self):#正常情况下，类中的__str__和__repr__魔术方法是完全一样的
        print('str方法被触发')
        return 'str返回值'

    def eat(self):
        print('真香...')
    def smile(self):
        print('哈哈哈哈哈哈...')

#实例化一个人的对象

hxl = Human()

print(hxl)
'''
输出结果：
str方法被触发
str返回值
'''
print(repr(hxl))
'''
输出结果：
repr方法被触发
repr返回值
'''

 

8.__bool__
1.触发时机：使用bool() 转换对象的时候自动触发
2.作用：用于检测对象成员的信息
3.参数：一个self接受当前对象
4.返回值：必须有且必须是布尔值
5.注意事项：无

 

#__bool__魔术方法
class Man:
    #属性
    color = '黄色'
    sex = '男'
    age = 28
    name = '小刚'
    jf = '已婚'

    #方法
    #__bool__魔术方法
    def __bool__(self):#self后面不接受任何参数
        print('bool方法被触发')
        if self.jf == '已婚':
            return True
        else:
            return False


    def smokin(self):
        print('多数男人会抽烟')
    def say(self):
        print('男人就会甜言蜜语')
#实例化一个人的对象
mr = Man()
print(mr)
#输出结果：<__main__.Man object at 0x00000297701F0F60>

#转换对象
#一般情况下对象转换的结果就是True
var = bool(mr) #一但用bool转换对象bool的方法就会被触发
#输出结果：bool方法被触发

print(var)#任何对象的返回值都得赋给变量才能打印出结果
'''
在类的属性中 jf = '已婚' 或 jf = '未婚' 来判断对象返回是 True 或 False
输出结果：True
'''

 

9.__format__
1.触发时机：
2.作用：
3.参数：
4.返回值：
5.注意事项：

 

#__format__魔术方法
class Girl:
    #属性
    color = '黄色'
    sex = '女'
    age = 18
    name = '小丽'

    #方法
    #__format__魔术方法
    def __format__(self,arg):#aa接受的是限定的符号的字符串
        print('format方法被触发')
        print(arg)

        #实现format自带的对齐和填充功能
        #1.按受限定符号
        flag = arg
        #2.拆分限定符号
        fillchar = flag[0]#填充字符
        align = flag[1]#对齐方式
        length = int(flag[2:])#
        #print(fillchar,align,length)
        #3.根据不同的符号进行不同的填充操作
        #判断对齐方式
        if align =='>': #右对齐
            newname = self.name.rjust(length,fillchar)
            return newname
        elif align =='^': #居中对齐
            newname = self.name.center(length,fillchar)
            return newname
        elif align == '<': #左对齐
            newname = self.name.ljust(length,fillchar)
            return newname
        else:
            return ''

    def smokin(self):
        print('买买买~~~')
    def say(self):
        print('吃烧烤~~')
#实例化一个人的对象
xcm = Girl()
print(xcm)
#输出结果：<__main__.Girl object at 0x000002688ED0B128>
#使用format来操作我们的对象1
action = '我和我的朋友{:@<20}去逛街'
result = action.format(xcm)
print(result)
'''
输出结果：
format方法被触发
@<20
我和我的朋友小丽@@@@@@@@@@@@@@@@@@去逛街
'''

#使用format来操作我们的对象2
action = '我和我的朋友{:@>20}去逛街，买了'
result = action.format(xcm)
print(result)
'''
输出结果：
format方法被触发
@>20
我和我的朋友@@@@@@@@@@@@@@@@@@小丽去逛街，买了
'''

#使用format来操作我们的对象3
action = '我和我的朋友{:@^20}去逛街，买了'
result = action.format(xcm)
print(result)
'''
输出结果：
format方法被触发
@^20
我和我的朋友@@@@@@@@@小丽@@@@@@@@@去逛街，买了
'''