组合 mixins机制 内置函数 反射 异常

组合 mixins机制 内置函数 反射 异常

组合

# 解决类与类之间代码冗余问题：
	1. 继承 
    2. 组合 属性的值指向另一个类实例化的对象
    
组合：一个对象拥有一个属性， 属性的值必须是另外一个对象
继承满足的是：什么是什么的关系  # is-a  人是动物，猪是动物 狗是动物
组合满足的是：什么有什么的关系  # has-a 人会说话 思考，自己独有的
练习
class People():

    def __init__(self,name,blood,armor,atk,weapon = None):
        if weapon is None:
            weapon=[]
        self.name=name    #name 名字
        self.blood=blood  #blood 血量
        self.armor=armor  #armor护甲
        self.atk=atk      #atk攻击力
        self.weapons=weapon #weapon武器



class Weapon():  #武器类
    def __init__(self,weapon_name,attack,suck):
        self.weapon_name=weapon_name  #武器名字
        self.attack=attack #攻击力
        self.suck=suck    #吸血

    def show_weapon(self):
        print('武器名字：%s ，武器攻击力：%s，武器吸血：%s'%(self.weapon_name,self.attack,self.suck))

class Dmxy(People):
    def __init__(self,name,blood,armor,atk,race,belief,weapon = None):
        if weapon is None:
            weapon=[]
        self.name=name    #name 名字
        self.blood=blood  #blood 血量
        self.armor=armor  #armor护甲
        self.atk=atk      #atk攻击力
        self.race=race  #种族
        self.belief=belief #信仰
        self.weapons = weapon  # weapon武器




class Nkss(People):
    def __init__(self,name,blood,armor,atk, race, belief,weapon = None):
        if weapon is None:
            weapon=[]
        self.name=name    #name 名字
        self.blood=blood  #blood 血量
        self.armor=armor  #armor护甲
        self.atk=atk      #atk攻击力
        self.race = race  # 种族
        self.belief = belief  # 信仰
        self.weapons = weapon  # weapon武器



knife=Weapon('无尽之刃',500,0)
sword=Weapon('饮血剑',300,50)


Riven=Nkss('瑞文',1800,100,200,'诺克萨斯','诺克萨斯，无可匹敌')
Galen=Dmxy('盖伦',2500,200,80,'德玛西亚','德玛西亚，永世长存')

print(Riven.__dict__)
print(Galen.__dict__)

Riven.weapons=knife
Galen.weapons=sword

Riven.weapons.show_weapon()
Galen.weapons.show_weapon()
#输出结果
{'name': '瑞文', 'blood': 1800, 'armor': 100, 'atk': 200, 'race': '诺克萨斯', 'belief': '诺克萨斯，无可匹敌', 'weapons': []}
{'name': '盖伦', 'blood': 2500, 'armor': 200, 'atk': 80, 'race': '德玛西亚', 'belief': '德玛西亚，永世长存', 'weapons': []}
武器名字：无尽之刃 ，武器攻击力：500，武器吸血：0
武器名字：饮血剑 ，武器攻击力：300，武器吸血：50

mixins机制 了解知识

1. 分主类和辅类
主类就是主要功能
辅类就是辅要功能
2. 命名方式一般以 Mixin, able, ible 为后缀
比如FlyMixIn   或者Flyable 或者Flyible
3. 辅类位置一般在主类的左边

内置函数 *******************************

# 1__init__()实例化自动调用

# 2__str__()  ********  打印对象自动调用的方法函数
--打印对象自动触发的函数 ，方法，只能返回字符串
--返回值必须是字符串类型
class Student:
    school='SH'
    def __str__(self):        #打印对象自动触发的函数 ，方法，只能返回字符串
        return self.school    #返回值必须是字符串类型

    # def index(self):                这个也可以 但是需要调.index方法
    #     return self.school
stu=Student()
print(stu)   #打印对象自动触发__str__函数，方法
#3__del__ 删除
删除对象属性时候，自动触发
代码执行完毕，还会自动触发
class Student:
    school='SH'

    def __del__(self): 
        print('__del_____')

stu=Student()
stu.x=1
print(stu.__dict__)  #1.先这个{'x': 1}
del stu.x           #2.执行，删除掉了  
print(stu.__dict__) #3.在输出一遍{}
#④.执行del里面的方法，对垃圾回收  __del_____
#4.isinstance(obj,cls)和issubclass(sub,super)
a='123'   #其实是a=str('123')

print(type(a) is str)
print(isinstance(a,str)) #True  判断a是不是后面的str实例化对象

class Doo:
    pass

class Foo(Doo):
    pass

class Xoo(Foo):
    pass

print(issubclass(Xoo,Doo))  #True     判断类是不是后面的子类，如果继承，也是子类
print(issubclass(Xoo,object)) #True    所有类都是object的子类
#5. __setattr__,__delattr__,__getattr__
当调用一个不存在的属性时，就会触发__getattr__()
只有在使用点调用属性且属性不存在的时候才会触发

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 #这就无限递归了,你好好想想      init里面的y不存在 调用一次 ，self.key又调用，调用还是self递归自己掉自己
         self.__dict__[key]=value #应该使用它

     def __delattr__(self, item):     #删除属性会触发
         print('----> from delattr')
         # del self.item #无限递归了
         self.__dict__.pop(item)

stu=Foo(10)
stu.z=10

#6.__call__  必须掌握
class Foo():

    def __call__(self, *args, **kwargs):
        print('我是__call__')



stu=Foo()
stu()       #给对象加()时候自动调用__call__方法

反射

# 通过字符串操作属性
平时都是对象.方法或者参数来调用，直接用字符串会报错	
class Student():
    kill=100
obj=Student()
# getattr()
x=input('输入>>>').strip()
# print(obj.x)   报错

print(getattr(obj,x,None)) #前面输入对象名，后面输入字符串  最后面如过取不到这个属性会返回None也可以是别的值比如print(getattr(obj,x,'找不到'))
# hasattr()    判断是否有这个属性
print(hasattr(obj,'kill'))#True   有这个属性
print(hasattr(obj,'killsss'))#   False 没有这个属性
# setattr()
setattr(obj,'y',10)        #给一个对象添加一个新值
print(obj.__dict__)      
# delattr()
delattr(Student,'kill')    #删除类中的属性
print(Student.__dict__)



#超级重要超级重要超级重要超级重要超级重要超级重要超级重要超级重要
class Student():
    kill=100

    def func(self):
        print('我是func')

obj=Student()
getattr(obj,'func')()   #判断对象里面有没有func方法返回一个地址，后面加上()表示调用
#还可以调用类的方法  比如time.sleep
import time

getattr(time,'sleep')(3)

异常

# 什么是异常？
	异常就是错误发生的信号， 如果不对该信息进行处理， 那么， 之后的代码就不会运行
    	1. 语法错误
        	# SyntaxError:
            print(123
        2. 逻辑错误
            # 有些逻辑错误可以尽量写到完美
            NameError: name 'x' is not defined
            print(x)
    
# 为什么用异常？
      为了增强代码的健壮性
# 怎么用异常？
      try:
         	被监测的代码1
             被监测的代码2
             被监测的代码3
             被监测的代码4
             被监测的代码5
	except 异常错误1 as e:    #也可以不加 只要报错就执行这里面的
    	pass
	except 异常错误2 as e:
    	pass
	except 异常错误3 as e:
   		 pass
	else:
    	print("当被检测的代码没有异常的时候触发") 
	finally:
    	print("不管有咩 有异常，都会走")  
                  
                  
                  
if 1>5:
    print('正确')
else:
    # print('hhh')
    raise Exception('索引错误')          #写了这个直接报出来错，不会执行下面代码
print('最下面')                 


a=[1,2,3]

#断言
assert len(a)==5     #必须是5否则直接报错退出
报错信息
Traceback (most recent call last):
  File "G:\pycharmproject\day 25\02-练习.py", line 187, in <module>
    assert len(a)==5
AssertionError
                  
#方法里面可以用raise必须实现此方法可以用                  
class Animal:
    def speak(self):
        raise Exception('必须实现次方法')

class Dog(Animal):
    pass

obj=Animal()
obj.speak()
                  
                  
                  
#这是自定义异常类  要记得继承  BaseException                
class MyException(BaseException):
    def __init__(self,msg):
        self.msg=msg
    def __str__(self):
        return self.msg

raise Exception('这是自定义异常类')