mixins机制

mixins机制是用来区分主类和副类
继承副类就有该副类中的功能，不影响子类使用
python对于mixin类的命名方式一般以Mixin，able，ible为后缀
且mixin类必须责任单一，如果需要多功能则写多个mixin类
通常副类写在主类的前面，这是规范，或建议

class transportation():  # 交通工具
    def run():
        pass
     
class fly():  # 能飞
    def fly():
        pass

class plain(fly,transportation):  # 飞机可以飞也是交通工具
    pass

class car(transportation):  # 车只是交通工具
    pass

内置函数

1. __init__ ->实例化对象
2. __str__ ->设置打印对象后的返回值，返回值必须是字符串
3. __del__ ->手动删除对象时或应用程序执行完毕后执行

# __init__
class Student():
    def __init__(self,name,age):
        self.name = name
        self.age = age
        
obj = Student('ly',18)
print(obj)  # 输出obj内存地址

# __str__
class Student():
    def __init__(self,name,age):
        self.name = name
        self.age = age
        
    # 只有在打印对象的时候触发
    def __str__(self):
        return self.name
        
obj = Student('ly',18)
print(obj)  # ly

# __del__
class Student():
    def __init__(self,name,age):
        self.name = name
        self.age = age
        
    def __del__(self):
        print('__del__')
        
obj = Student('ly',18)
del obj  # __del__

其他常用的内置函数

判断是否是其实例

isinstance
isinstance('abc',str)
判断'abc'是否是str的实例

判断是否是其子类

issubclass
issubclass(Foo,object)
判断Foo是否是object的子类

找的属性不存在

__getattr__
当访问的属性不存在时触发

class Student():
    def __init__(self,name,age):
        self.name = name
        self.age = age
     
    def __getattr__(self,item):
        print(f'你访问的 {item} 属性不存在')
        
obj = Student('ly',18)
obj.n  # 你访问的 n 属性不存在

修改属性

__setattr__
当添加、修改属性时触发运行

class Student():
    def __init__(self,name,age):
        self.name = name
        self.age = age
        
    def __setattr__(self,k,v):
        print('设置成功')
        
obj = Student('ly',18)
# 设置成功

class Student():
    def __init__(self,name,age):
        self.name = name
        self.age = age
        
    def __setattr__(self,k,v):
        self.k = v  # 错误设置方法，会无限递归
        self.__dict__[k] = v  # 正确设置方法

删除属性

__delattr__
当删除属性时触发运行

class Student():
    def __init__(self,name,age):
        self.name = name
        self.age = age
        
    def __delattr__(self,item):
        print(f'已删除 {item}')
        
stu = Student('ly',99)
del stu.name  # 已删除 ly

中括号触发

以上带有attr的都是通过 xxx.xxx 来触发执行 
将attr变成item就成了通过 xxx[] 来触发执行

对象加小括号

__call__
对象() 如此调用时触发运行

class Student():
    def __init__(self,name,age):
        self.name = name
        self.age = age
        
    def __call__(self,*args,**kwargs):
        print('call')

比较

大于 -> greater than -> gt
小于 -> less than -> lt
等于 -> be equal to -> e

大于等于 -> gte
小于等于 -> lte

class Student():
    def __init__(self,name,age):
        self.name = name
        self.age = age
        
    def __比较__(self,other):
        print(other)
        
obj1 = Student('ly',99)
obj2 = Student('egon',100)

print(obj1 > obj2)  # obj2的内存地址

反射

正常情况下 对象.'xxx' 点后不能跟字符串，会报错

反射：通过字符串来操作类属性或方法

getattr(类名或对象,'调用属性',默认值)  # 获取属性
# 如果调用时属性不存在则取默认值
setattr(类名或对象,'被修改的属性',修改后的值)  # 修改属性
# 需要修改的属性不存在则新建
delattr(类名或对象,'删除的属性')  # 删除属性
# 注意对象是否有对应的属性，而不是类的公用属性
hasattr(类名或对象,'需要查找的属性')  # 查找属性
# 返回布尔值

调用字符串形式的函数
getattr(obj,'func')()

在以后的项目源码中通常这么写
handler = getattr(obj,'func')
def test(*args,**kwargs):
    return handler(*args,**kwargs)

或者调用模块
import time
getattr(time,'sleep')(2)

导入模块时如果模块是字符串
time = __import__('time')

异常

什么是异常

异常就是错误发生的信号，当遇到该信号就会抛出异常，如果不对该异常做处理，那么此后的代码都不再执行
异常总体分为两种：逻辑错误，语法错误

为什么用异常

为了增强代码的可靠性，健壮性

如何使用异常

NameError: name 'x' is not defined
# 变量名x未被找到

IndexError: list index out of range
# 列表超出范围

KeyError: 'k1'
# k值未被取到

AttributeError: 'Foo' object has no attribute 'x'
# 属性错误，Foo类内没有对象x

TypeError: 'int' object is not iterable
# 类型错误，整形不是可被迭代的类型

ZeroDivisionError: division by zero
# 0不可作为被除数

SyntaxError: invalid syntax
# try和else不能单独用，但是和finally可以单独用

还有其他的异常不再一一赘述


try:
    print(111)
    print(222)
    l = []
    l[2]
    print(333)
except KeyError as e:
    print("KeyError", e)
except IndexError as e:
    print("IndexError", e)
except AttributeError as e:
    print("AttributeError", e)
except ZeroDivisionError as e:
    print("ZeroDivisionError", e)
except Exception as e:
    print("我是收底的")
else:
    print("当被监测的代码没有异常时候执行")
finally:
    print("不管有没有异常都会执行的")
    
try内放执行的代码
except后放异常类型，触发后执行，如果触发的不在你写的异常类型内，则触发except Exception下的代码
else内的代码在未报错时执行
finally内的代码不管报不报错都执行