面向对象高级——魔术方法、反射、异常

面向对象的内置方法

​ 面向对象中的内置方法又称魔术方法，简单来说就是以双下划线开头和结尾的方法。下面我们来介绍几个比较常用的内置方法：

• __init__

  在对象实例化的时候自动调用该方法。

class Student():
    def __init__(self, name, age):
        self.name = name
        self.age = age
        print('我执行了')
        
stu = Student('mary',18)

• __str__

  打印或者输出对象的时候，自动调用该方法。

class Student():
    def __init__(self, name, age):
        self.name = name
        self.age = age

    # 打印或者输出对象的时候，自动调用的方法
    def __str__(self):
        return 'name:%s' % self.name
        # return 123  # 返回结果是字符串，不能是整型


stu = Student('mary', 19)
print(stu)  

# 结果输出：如果我们不写__str__方法，那么打印结果就是内存地址，现在我们写了，就会触发这个方法
name：mary

• __del__

  第一种情况是通过del 删除对象的时候会自动触发；第二种情况是当整个程序执行完毕后会调用该方法。

class Student():
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def __del__(self):
        print('触发了')

stu = Student('mary', 18)
del stu
print(123)

# 结果输出：（第一种情况）
触发了
123
# 如果注释掉del stu ，再执行，则结果为：（第二种情况）
123
触发了

• __enter__与__exit__

  使用with上下文管理的时候，只要出现with语句，就会触发__enter__方法，如果有返回值则赋值给as后面声明的变量；当with中的代码块执行完毕后，会自动触发__exit__方法。

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

    def __enter__(self):
        print('出现with语句,对象的__enter__被触发,有返回值则赋值给as声明的变量')
        # return self
    
    def __exit__(self, exc_type, exc_val, exc_tb):
        print('with中代码块执行完毕时执行我')



with Open('a.txt') as f:
    print('=====>执行代码块')

# 输出结果：
出现with语句,对象的__enter__被触发,有返回值则赋值给as声明的变量
=====>执行代码块
with中代码块执行完毕时执行我

• __getattr__、__setattr__与__delattr__

  只有在使用点调用属性并且属性不存在的时候才会触发__getattr__方法的执行；在添加/修改属性会触发__setattr__方法的执行；在删除属性的时候会触发__delattr__方法的执行。

class Foo:
    x=1
    def __init__(self,y):
        self.y=y

    def __getattr__(self, item):
        print('----> from getattr:你找的属性不存在')


    def __setattr__(self, key, value):
        print('----> from setattr')
        # self.key=value # 如果这样写，就会再次调用__setattr__方法，就会出现无限递归了
        self.__dict__[key]=value # 应该使用这种方式，不会出现递归的问题

    def __delattr__(self, item):
        print('----> from delattr')
        # del self.item  # 无限递归了
        self.__dict__.pop(item)

#__setattr__添加/修改属性会触发它的执行
f1=Foo(10)
print(f1.__dict__) # 因为你重写了__setattr__,凡是赋值操作都会触发它的运行,你啥都没写,就是根本没赋值,除非你直接操作属性字典,否则永远无法赋值
f1.z=3
print(f1.__dict__)

#__delattr__删除属性的时候会触发
f1.__dict__['a']=3 # 我们可以直接修改属性字典,来完成添加/修改属性的操作
del f1.a
print(f1.__dict__)

#__getattr__只有在使用点调用属性且属性不存在的时候才会触发
f1.xxxxxx

• __call__

  在对象后面加括号，会触发__call__方法的执行。构造方法的执行是由创建对象触发的，即：对象 = 类名() ；而对于 __call__方法的执行是由对象后加括号触发的，即：对象() 或者 类()()

class Foo:

    def __init__(self):
        pass
    
    # 对象加括号
    def __call__(self, *args, **kwargs):
        print('__call__')


obj = Foo()  # 执行 __init__
obj()  # # 执行 __call__

反射

在python的面向对象中，反射的意思就是通过字符串的形式操作对象相关的属性。在python中，一切事物都是对象，因此都可以使用反射。其中主要有四个方法：

注意：一切皆对象，类本身也是一个对象。

• getattr(object,name,default=None)通过字符串获取属性

class Student():
    school = 'SH'
    def func(self):
        print('from func')

stu = Student()

print(getattr(stu, 'school', 123))  # 如果有该属性，则获取属性值，如果没有，则设置为默认值
print(getattr(stu, 'func'))  # 方法func的内存地址
getattr(stu, 'func')()  # 加括号调用func方法

• setattr(x,y,v)：通过字符串添加、修改属性

class Student():
    school = 'SH'
    def func(self):
        print('from func')

stu = Student()

setattr(stu, 'x', 100)
print(stu.__dict__)

• hasattr(object,name)：判断object中是否含有name属性

class Student():
    school = 'SH'
    def func(self):
        print('from func')

stu = Student()

print(hasattr(stu, 'school'))

• delattr(object,name)：从object中删除name属性

class Student():
    school = 'SH'
    def func(self):
        print('from func')

stu = Student()
stu.x = 1
delattr(stu, 'x')
delattr(Student, 'school')
print(Student.__dict__)

异常

什么是异常

​ 在编程中，异常就是错误发生的信号，如果不对该信号做处理，程序就会终止运行。

为什么要用异常

​ 使用异常的目的是为了增加代码的健壮性。

如何使用异常

• 语法结构

try:
    pass
except 异常的类型:
    pass
except 异常的类型:
    pass
except 异常的类型:
    pass
else：
	print('当没有发生异常的时候执行')
finally:
    print('不管有没有异常都会执行')

注意：try和else不能单独组合使用，其他组合可以搭配使用。

• 主动抛出异常

class Animal():
    def speak(self):
        raise Exception('必须实现speak方法')


class Student(Animal):
    def speak(self):
        pass


stu = Student()
stu.speak()

• 自定义异常

class MyException(BaseException):
    def __init__(self, msg):
        self.msg = msg

    def __str__(self):
        return self.msg

raise MyException('出问题啦')