Learn day7 继承（单、多、菱形）\多态\魔术方法\装饰器\异常

1.继承

1.1 单继承

# ### 继承
"""
(1) 单继承 (2) 多继承
至少2个类,子类和父类
一个类继承另外一个类,当前类是子类 (衍生类)
被继承的这个类是父类.(基类,超类)

python 所有类的父类都是object
"""
# 1.子父继承后,子类可以使用父类的公有方法
class Father():
    skin = "黑色的"
    __sex = "男性"

    def hobby(self):
        print("爱好喜欢大篮球")

    def __smoke(self):
        print("老爸喜欢抽大麻")

class Daughter(Father):
    pass

obj = Daughter()
print(obj.skin)
obj.hobby()

# 2.子父继承后,子类不能调用父类的私有方法
class Son(Father):
    def pub_func(self):
        print(self.__sex) #error
obj = Son()
# print(obj.__sex)
# obj.pub_func()

# 3.子父继承后,子类可以改写父类方法
"""self对象优先调用本类中的方法,如果本类当中没有再调用父类."""
class n_selfchild(Father):
    skin = "白色的"
    def hobby(self):
        print("白种人喜欢种大麻")
obj = n_selfchild()
obj.hobby()

1.2 多继承

# ### 多继承

# 1.基本语法
class Father():
    f_property = "英俊潇洒,才华横溢,道貌岸然,一表人才"
    def hobby1(self):
        print("抽烟,喝酒,烫头,吃喝嫖赌抽,坑蒙拐骗偷")

class Mother():
    m_property = "一枝红情出墙来"
    def hobby(self):
        print("打麻将,蹦野迪,买包包")

class Daughter(Father,Mother):
    pass

obj = Daughter()
print(obj.f_property)
obj.hobby()

# 2.self 和 super的区别
"""
(1)super本身是一个类 super()是一个对象 用于调用父类的绑定方法
(2)super() 只应用在绑定方法中,默认自动传递self对象 (前提:super所在作用域存在self)
(3)super用途: 解决复杂的多继承调用顺序
"""
class Father():
    f_property = "英俊潇洒,才华横溢,道貌岸然,一表人才"
    def hobby1():
        print("抽烟,喝酒,烫头,吃喝嫖赌抽,坑蒙拐骗偷")

class Mother():
    m_property = "一枝红情出墙来"
    def hobby2(self):
        print("打麻将,蹦野迪,买包包")

class Son(Father,Mother):
    m_property = "一枝梨花压海棠"

    def hobby2(self):
        print("出入奇怪的场所,比如卡丁车,蹦极")

    def skill1(self):
        print(Father.f_property)
        Father.hobby1()

    """
        # self
        self在调用成员的时候,如果自己本类有,优先调用自己的,
        self在调用成员的时候,如果自己本类没有,调用父类的,
    """
    def skill2(self):
        print(self.m_property)
        self.hobby2()

    """
        # super
        super在调用成员你的时候,一定会调用父类的方法或者属性
        这是它与self的本质区别.
    """
    def skill3(self):
        print(super().m_property)
        super().hobby2()

obj = Son()
obj.skill1()
obj.skill2()
obj.skill3()

1.3 菱形继承

# ### 菱形继承 (钻石继承)
"""
      Human
Man          Woman
    Children
"""

class Human():
    pty = 4
    def feelT(self):
        print("古代人类,天冷了,穿动物的毛1")
        print(self.pty) # 1
        print("古代人类,天热了,啃树皮2")

class Man(Human):
    pty = 3
    def feelT(self):
        print("现代人类,天热了,喝啤酒,吃西瓜,撸串3")
        super().feelT()
        print("现代人类,天冷了,把火罐,开空调,吃炸鸡4")

class Woman(Human):
    pty = 2
    def feelT(self):
        print("现代女性,天热了,光膀子,穿裙子,买包包5")
        super().feelT()
        print("现代女性,天冷了,穿动物的毛,貂皮大衣6")

class Children(Man,Woman):
    pty = 1
    def feelT(self):
        print("现代小孩,天热了,吃冰棍,游泳7")
        super().feelT()
        print("现代小孩,天冷了,喝热水,玩农药8")

obj = Children()
obj.feelT()

"""
super 遵循mro列表中出现顺序,依次进行调用.
类.mro()

super在调用方法时,默认传递本对象.
"""
lst = Children.mro()
print(lst)
'''
super 在调用同名方法时,要依据该列表中出现的类的调用顺序,依次调用
[<class '__main__.Children'>, <class '__main__.Man'>, <class '__main__.Woman'>, <class '__main__.Human'>, <class 'object'>]
'''

"""
现代小孩,天热了,吃冰棍,游泳7
现代人类,天热了,喝啤酒,吃西瓜,撸串3
现代女性,天热了,光膀子,穿裙子,买包包5
古代人类,天冷了,穿动物的毛1
古代人类,天热了,啃树皮2
现代女性,天冷了,穿动物的毛,貂皮大衣6
现代人类,天冷了,把火罐,开空调,吃炸鸡4
现代小孩,天冷了,喝热水,玩农药8
"""

#issubclass 判断子父关系 isinstance 判断类型
res = issubclass(Man,Human)
print(res)
# 判断子父时,必须是类,不能是对象
# res = issubclass(obj,Human)
# print(res)
# 判断子父时,有继承血缘关系即可.
res= issubclass(Children,Human)
print(res)
# 判断Children,在小括号中,有一个满足是父类就返回真
res= issubclass(Children,(Woman,Man,Human))
print(res)

#obj的类型是Children , 只要有血缘关系即可 ,一脉相承.
res= isinstance(obj,Children)
print(res)
res= isinstance(obj,Woman)
print(res)
res= isinstance(obj,Human)
print(res)
res= isinstance(obj,(Human,Man))
print(res)

2.单态

# ### 单态模式
"""类无论实例化多少次,都有且只有一个对象. 为了节省空间"""

# 1.基本语法
class SingleTon():
    # 防止类外调用__obj,形成封装保护.
    __obj = None
    def __new__(cls):
        if cls.__obj is None:
            obj  =  object.__new__(cls)
            cls.__obj = obj
        return cls.__obj 

# 第一次实例化对象,因为cls.__obj is None 条件为真,创建对象并返回
obj1 = SingleTon()
# 第二次发现 cls.__obj is None: 条件为假,直接返回原有对象
obj2 = SingleTon()
# 第二次发现 cls.__obj is None: 条件为假,直接返回原有对象
obj3 = SingleTon()
print(obj1)
print(obj2)
print(obj3)

# 2. 有且只有一个对象
class SingleTon():
    # 防止类外调用__obj,形成封装保护.
    __obj = None
    def __new__(cls,*args,**kwargs):
        if cls.__obj is None:
            cls.__obj  =  object.__new__(cls)
        return cls.__obj 

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

obj1 = SingleTon("郭一萌")
print(obj1.name)
obj2 = SingleTon("舒则会")
print(obj1.name)
print(obj2.name)
obj3 = SingleTon("银燕")
print(obj1.name)
print(obj2.name)
print(obj3.name)
"""
obj1.name = 郭一萌
obj2.name = 舒则会
"""

3.多态

# ### 多态
"""

不同的子类对象,调用相同的父类方法,产生不同的执行结果
继承,重写
好处:多态针对的是对象来说的.在不改变原有代码的前提下,完成不同的功能;
不同的对象,调用相同的方法,达到了不同的功能.
"""
class Soldier():
    def attact(self):
        pass
    def back(self):
        pass

class Army(Soldier):
    def attact(self):
        print("[陆军]拿一把枪,突突突,然后倒下")
    def back(self):
        print("[陆军]撒腿就跑,躺下装死")

class Navy(Soldier):
    def attact(self):
        print("[海军]开炮,鱼雷,拿鱼叉子插死敌人")
    def back(self):
        print("[海军]立即跳海,下海喂鱼")

class AirForce(Soldier):
    def attact(self):
        print("[空军]空对地导弹,使用二营长的意大利跑射死别人")
    def back(self):
        print("[空军]立即跳伞,落地成盒")

# 实例化一个陆军士兵
obj_army = Army()
# 实例化一个海军士兵
obj_navy = Navy()
# 实例化一个空军士兵
obj_airforce=AirForce()

# 各就位准备
lst = [obj_army,obj_navy,obj_airforce]

# 将军请下令
strvar = '''
1.全体出击
2.全体撤退
3.空军上,其他人撤退
'''

while True:
    print(strvar)
    num = input("请将军下令>>>")
    if num.isdecimal():
        if int(num) == 1:
            for i in lst:
                i.attact()
        elif int(num) == 2:
            for i in lst:
                i.back()
        elif int(num) == 3:
            for i in lst:
                # 通过判断对象的类型,执行对应的方法
                if isinstance(i,AirForce):
                    i.attact()
                else:
                    i.back()
        else:
            print("风太大,我听不见!")
    else:
        if num.upper() == "Q":
            print("欢迎下次在指挥")
            break

4.魔术方法

4.1  __new__ 魔术方法
'''
    触发时机：实例化类生成对象的时候触发(触发时机在__init__之前)
    功能：控制对象的创建过程
    参数:至少一个cls接受当前的类,其他根据情况决定
    返回值：通常返回对象或None
'''

"""
对象.属性
对象.方法()

类.属性
类.方法()

object是所有类的父类
"""

# (1)基本语法
class MyClass(object):
    a = 5

obj2 = MyClass()

# 可以通过__new__ 来控制对象创建的过程
class MyClass2():
    def __new__(cls):
        print(cls)
        # 通过父类object 中的 __new__ 魔术方法 ,返回该类的对象,参数是类.
        # obj = object.__new__(cls)

        # 返回本类对象,只能通过父类创建.
        # return obj
        # 可以返回None
        # return None
        # 也可以返回别人的对象
        return obj2

obj = MyClass2()
print(obj)
print(obj.a)

# 2 .对比__new__ 和 __init__ 之间的区别
"""
__new__  负责创建对象
__init__ 负责初始化对象
__new__ 在 __init__ 触发时机之前.
"""
class MyClass3():
    def __new__(cls):
        print(1)
        return object.__new__(cls)

    def __init__(self):
        print(2)
        self.name = "王刚蛋"

obj = MyClass3()

# __new__ 和 __init__ 形参实参要匹配
class MyClass3():
    def __new__(cls,name):
        print(1)
        return object.__new__(cls)

    def __init__(self,name):
        print(2)
        self.name = name

obj = MyClass3("廖平平")
print(obj.name)

# 升级版
class MyClass3():
    # 用收集参数,一劳永逸
    def __new__(cls,*args,**kwargs):
        print(1)
        return object.__new__(cls)

    def __init__(self,name,age,sex):
        print(2)
        self.name = name
        self.age = age
        self.sex = sex

obj = MyClass3("廖平平",98,"未知")
print(obj.name)
print(obj.age)
print(obj.sex)

# (3) 注意点.__init__ 只能初始化自己本类的对象

class MyClass4():
    def __new__(cls):
        print(1)
        return obj2

    # 不会调用init方法,因为返回的对象不是MyClass4本身的,不调用;
    def __init__(self):
        print(2)

obj = MyClass4()
print(obj)

4.2  __del__ 魔术方法 (析构方法)

'''
   触发时机:当对象被内存回收的时候自动触发[1.页面执行完毕回收所有变量 2.所有对象被del的时候]
    功能：对象使用完毕后资源回收
   参数：一个self接受对象
   返回值：无
'''
import os
class LangDog():
   def __init__(self,name):
      self.name = name
      
   def eatmeat(self):
      print("可爱滴小狼狗喜欢吃肉")
   
   def __del__(self):
      print("析构方法被触发")

obj = LangDog("詹姆斯•蛋蛋")

# (1) 页面执行完毕,触发析构方法
print("<====程序执行完毕start===>")

# (2)所有对象被del的时候
obj2 = obj # 两个不同的变量 指向同一个对象
print(obj2)
print(obj)

del obj
del obj2

print("<====程序执行完毕end===>")

# (3)文件读取操作
"""
fp = open("文件名",mode="r",encoding="utf-8")
res = fp.read()
fp.close()
"""
class ReadFile():
   def __new__(cls,filename):
      if os.path.exists(filename):
         return object.__new__(cls)
      return print("改文件不存在")
         
   def __init__(self,filename):
      self.fp = open(filename,mode="r",encoding="utf-8")
      
   def readcontent(self):
      res = self.fp.read()
      return res
      
   def __del__(self):
      self.fp.close()

obj = ReadFile("ceshi111.txt")
res = obj.readcontent()
print(res)

4.3 __str__ 魔术方法
'''
   触发时机: 使用print(对象)或者str(对象)的时候触发
   功能:     查看对象
   参数:     一个self接受当前对象
   返回值:   必须返回字符串类型
'''
class Cat():
   gift = "抓耗子"
   def __init__(self,name):
      self.name = name
      
   def obj_info(self):
      return "该对象名字{},它天生属性是{}".format(self.name,self.gift)
   def __str__(self):
      return self.obj_info()
tom = Cat("汤姆")
# 方式一:打印对象时触发
# print(tom)
# 方式二:强转对象为字符串时触发
res = str(tom)
print(res)

#__repr__ 魔术方法
'''
   触发时机: 使用repr(对象)的时候触发
   功能:     查看对象,与魔术方法__str__相似
   参数:     一个self接受当前对象
   返回值:   必须返回字符串类型
'''
class Mouse():
   gift = "会打洞"
   def __init__(self,name):
      self.name = name
      
   def obj_info(self):    
      return "该对象名字{},该对象属性:龙生龙,凤生凤,老鼠的儿子{}".format(self.name,self.gift)
      
   def __repr__(self):
      return self.obj_info()
   # 系统底层,自动加了一句话,如果存在__repr__魔术方法,自动把这个方法赋值给__str__方法,所以即使在print打印或者强转对象为字符串,也仍然触发.
   __str__ = __repr__
      
jerry = Mouse("杰瑞")
# res = repr(jerry)
# print(res)

print(jerry)
res = str(jerry)
print(res)

4.3  __bool__ 魔术方法
'''
   触发时机：使用bool(对象)的时候自动触发
   功能：强转对象
   参数：一个self接受当前对象
   返回值：必须是布尔类型
'''
class MyClass():
   def __bool__(self):
      return False 
      
# 实例化对象
obj = MyClass()       
res = bool(obj)
print(res)
      
'''
类似的还有如下等等(了解):
   __complex__(self)      被complex强转对象时调用
   __int__(self)          被int强转对象时调用
   __float__(self)        被float强转对象时调用
   ...
   ...
'''
      
      
4.4 __add__ 魔术方法  (与之相关的__radd__ 反向加法)
'''
   触发时机：使用对象进行运算相加的时候自动触发
   功能：对象运算
   参数：二个对象参数
   返回值：运算后的值
'''
'''
类似的还有如下等等(了解):
   __sub__(self, other)           定义减法的行为：-
   __mul__(self, other)           定义乘法的行为：
   __truediv__(self, other)       定义真除法的行为：/
   ...
   ...
'''
class MyClass():
   def __init__(self,num):
      self.num = num
      
   # 当对象在+加号的左侧时,自动触发;
   def __add__(self,other):
      return self.num * 2 + other
      
   # 当对象在+加号的右侧时,自动触发
   def __radd__(self,other):
      return self.num * 3 + other

a = MyClass(3)
# self 接收到 a ,other 接收到 1 self.num * 2 + 1 = 3 * 2 +1 = 7
res = a+1
print(res)

b = MyClass(5)
# 第一次参数永远接受的是对象,self接收的 b ,other 接受的是 2 => 5 * 3 + 2 => 17
res = 2 + b
print(res)

# a+b
"""
先触发add魔术方法 self 接收到a  other 接收到b => 3 * 2 + b => 6 +b
6+b 有触发了radd魔术方法 self 接收到 b  other 接收到6  => 5 * 3 + 6 => 21
"""
res = a+b
print(res)

4.5 __len__ 魔术方法
'''
   触发时机：使用len(对象)的时候自动触发 
   功能：用于检测对象中或者类中某个内容的个数
   参数：一个self接受当前对象
   返回值：必须返回整型
'''
'''
类似的还有如下等等(了解):
   __iter__(self)                 定义迭代容器中的元素的行为
   __reversed__(self)             定义当被 reversed() 调用时的行为
   __contains__(self, item)       定义当使用成员测试运算符（in 或 not in）时的行为
   ...
   ...
''' 

# 计算类中的成员个数
class MyClass():
   pty1 = 1
   __pty2 = 2
   pty3 = 3
   
   def func1(self):
      pass
   
   def func2(self):
      pass
      
   def __func3(self):
      pass
      
   def __len__(self):
      dic = MyClass.__dict__
      """
      lst = []      
      for i in dic:
         if not( i.startswith("__") and i.endswith("__") ):
            lst.append(i)
      """
      lst = [i for i in dic if not( i.startswith("__") and i.endswith("__") )]
      return len(lst)

obj =  MyClass()
print(len(obj))

4.6 __call__ 魔术方法
'''
   触发时机：把对象当作函数调用的时候自动触发
   功能: 模拟函数化操作
   参数: 参数不固定,至少一个self参数
   返回值: 看需求
'''
import math
# (1) 基本语法
class MyClass():
   def __call__(self):
      print("__call__方法被调用")

obj = MyClass()
obj()

# (2) __call__ 魔术方法可以做一个统一的调用
class MakeCake():

   def __call__(self,something):
      print("我做的东西是{}".format(something))
      self.step1()
      self.step2()
      self.step3()
   
   def step1(self):
      print("和面,发酵,放点糖,放点牛奶,等一天")
   def step2(self):
      print("扔进烤箱,考7749天,炼丹")
   def step3(self):
      print("拿出来,切一切吃")
      
obj = MakeCake()
obj("蛋糕")

# (3) 默认系统int这个方法的实现
# int  浮点型 纯数字字符串 布尔类型 它自己
class MyInt():

   def func(self,strvar,sign=1):
      res = strvar.lstrip("0")
      if res == '':
         return 0
      # print(res)
      # 左边计算的是数值, 右边是正负号,用来控制这个数字的正负;
      return eval(res) * sign
      
   def __call__(self,num):
      if isinstance(num,bool):
         if num == True:
            return 1
         else :
            return 0
      elif isinstance(num,int):
         return num
         
      elif isinstance(num,float):    
         if num < 0 :
            return math.ceil(num)
         else:
            return math.floor(num)
      # +000000000012345 -000000000012345
      elif (num[0] == "+" or num[0] == "-") and num[1:].isdecimal():

         if num[0] == "+":
            sign = 1
         else:
            sign = -1
         
         return self.func(num[1:],sign)
      # 000000000012345
      elif num.isdecimal():
         return self.func(num)

         
      else:
         print("该类型不能判断")
      
myint = MyInt()
print(myint(444))
print(myint(9.9))
print(myint(-9.9))
# int(True) => 1
# int(False) => 0

# import math
# print(math.ceil(-4.9))
# print(math.floor(-3))
# print(math.ceil(4.9))
# print(math.floor(-9.9)) # -10
# print(math.ceil(-9.9)) # -9

# print(int("000000123"))
# print(eval("123"))
# print(eval("000000000123"))

print(11)
print(myint("+0000000000123456"))
print(myint("000000000123457"))
print(int(+-+-+-+-90))
print(myint(int(+-+-+-+-90)))

5. 装饰器

5.1 装饰器
"""
替换旧函数,返回新函数,在不改变原有代码的前提下,为原函数拓展新功能
语法:@ (语法糖)
"""
# 1.装饰器的原型
def kuozhan(func):
    def newfunc():
        print("厕所前,蓬头垢面")
        func()
        print("厕所后,精神抖擞")
    return newfunc

def func():
    print("我是高富帅")

"""
把旧函数当成参数传递给kuozhan,扩展返回一个新函数newfun赋值给func
func由以前的旧函数变成了现在的新函数.就间接完成了功能上的拓展,
而没有改变原代码;
"""
func = kuozhan(func)# func = newfunc => func()  <==>  newfunc()
func()

print("<=============>")
# 2.装饰器的基本写法
def kuozhan(func):
    def newfunc():
        print("厕所前,蓬头垢面")
        func()
        print("厕所后,精神抖擞")
    return newfunc

@kuozhan
def func():
    print("我是白富美")

"""
@ 有两个功能:
    1.可以把下面的func当成参数传递给装饰器kuozhan
    2.把kuozhan函数返回的新函数,用来替换旧函数func.
    相当于 func = kuozhan(func) 一模一样.
"""

func()

# 3.装饰器的嵌套
def kuozhan1(func):
    def newfunc():
        print("厕所前,蓬头垢面1")
        func()
        print("厕所后,精神抖擞2")
    return newfunc

def kuozhan2(func):
    def newfunc():
        print("厕所前,饥肠辘辘3")
        func()
        print("厕所后,酒足饭饱4")
    return newfunc

@kuozhan2
@kuozhan1
def func():
    print("我是个屌丝")

func()

"""
首先把func当成参数传递给kuozhan1这个装饰器,
返回:
    def newfunc():
        print("厕所前,蓬头垢面1")
        func()
        print("厕所后,精神抖擞2")

    变成下面的样子:
    @kuozhan2
    def newfunc():
        print("厕所前,蓬头垢面1")
        func()
        print("厕所后,精神抖擞2")

    def newfunc():
        print("厕所前,饥肠辘辘3")
        func() # 把上一次装饰的函数拿到这里

        print("厕所前,蓬头垢面1")
        func()
        print("厕所后,精神抖擞2")

        print("厕所后,酒足饭饱4")
# 3124
"""

print("<====>")
# 4.带有参数的装饰器
"""
原函数是几个参数,拓展之后就是几个参数.
"""
def kuozhan(func):
    def newfunc(who,where):
        print("厕所前,衣衫褴褛")
        func(who,where)
        print("厕所后,衣冠禽兽")
    return newfunc

@kuozhan
def func(who,where):
    print( "{}在{}解手 ... ".format(who,where) )

func("李祖清","鸟窝")

print("<============>")
# 5.带有参数返回值的装饰器
def kuozhan(func):
    def newfunc(*args,**kwargs):
        print("厕所前,饥肠辘辘")
        res = func(*args,**kwargs) # * 和 ** 的魔术用法
        print("厕所后,满嘴雌黄")
        return res
    return newfunc

@kuozhan
def func(*args,**kwargs):
    print(args)
    print("我来了,老弟")
    # lst = []
    dic = {"lzq":"李祖庆","wb":"吴波",'sl':"帅乐"}
    """
    print(args)
    print(kwargs)
    for k,v in kwargs.items():
        if k in dic:
            res = dic[k]+"留下了"+v
            lst.append(res)
    """
    # 用推导式转化
    lst = [dic[k]+"留下了"+v for k,v in  kwargs.items() if k in dic]
    return lst

res = func("电影院","游泳池","鸟窝",lzq="15克",wb="15斤",sl="15吨",lt="15两")
print(res)

5.2 property 装饰器
@property定义只读属性，@setter定义可读可写属性，@deleter定义可读可写可删除属性
"""
可以把成员方法变成属性
控制成员的获取,设置,删除.

@自定义名.setter  设置
@自定义名.deleter 删除

"""

# 写法一
class MyClass():
   def __init__(self,name):
      self.name = name
   @property
   def username(self):
      # pass
      return self.name 
      
   @username.setter
   def username(self,val):    
      # val这个形参会自动接收"廖萍萍"实参;
      self.name = val
   
   @username.deleter
   def username(self):
      # del self.name
      pass
# 把方法username 变成属性 username
obj = MyClass("郭一萌")
# 1.获取 username
print(obj.username)

# 2.设置 username
obj.username = "廖萍萍"
print(obj.username)

# 3.删除 username
# del obj.username
# print(obj.username)

# 写法二
class MyClass():

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

   def get_username(self):
      # pass
      return self.name 
      

   def set_username(self,val):    
      # val这个形参会自动接收"廖萍萍"实参;
      self.name = val
   

   def del_username(self):
      del self.name
      # pass
   # 按照顺序 先获取 -> 设置 -> 删除 依次传参
   username = property(get_username,set_username,del_username)

obj = MyClass("郭艳妹")
# 获取
print(obj.username)
# 设置
obj.username = "尹艳姐"
print(obj.username)
# 删除
del obj.username
print(obj.username)

6. 类中方法

# ### 类中方法
"""
普通方法:
    没有任何参数,只能类来调用
绑定方法:
    (1) 绑定到对象
    (2) 绑定到类
静态方法:
    无论对象还是类都能调用
"""

class Dog():
    # 普通方法
    def jiao():
        print("小狗喜欢叫")

    # 绑定方法(绑定对象)
    def run(self):
        print("小狗跑的快")

    # 绑定方法(绑定到类)
    @classmethod
    def tail(cls):
        print(cls)
        print("小狗看见主人会摇尾巴")

    # 静态方法
    @staticmethod
    def tian(a):
        print("小狗看见骨头喜欢舔一舔")

# 实例化对象
obj = Dog()
# 1.普通方法
Dog.jiao()

# 2.绑定方法(绑定对象)
obj.run()
Dog.run(1) # 手动传参

# 3.绑定方法(绑定到类)
"""无论是类还是对象都可以调用,只不过默认传递的参数是类."""
Dog.tail()# 推荐
obj.tail()

# 4.静态方法
obj.tian(2)
Dog.tian(3)

# 默认在类外,动态添加的方法时静态方法;
obj.func = lambda  : print(1233)
obj.func()

# import types
# types.MethodType(func,obj)

7.异常

7.1 了解异常

# IndexError                索引超出序列的范围
# lst = [1,2,3]
# lst[99]

# KeyError                  字典中查找一个不存在的关键字
# dic = {'a':1,'b':2}
# print(dic["aaaa"])

# NameError                 尝试访问一个不存在的变量
# wangwen = "宇宙最闪亮的星星"
# print(wangwen)

# IndentationError          缩进错误
# if 5==5:
    # print(11)
    # print(333)

# AttributeError            尝试访问未知的对象属性
# class MyClass():
    # a = 54
# obj = MyClass()
# obj.bbb

# StopIteration             迭代器没有更多的值
# it = iter(range(10))
# for i in it:
    # print(i)
# res = next(it)

# 给测试人员用的
# AssertionError             断言语句（assert）失败
assert 5<4

7.2 异常处理

# ### 异常处理
"""
try 
   code1
   code2
except:
   code3
   code4
   
把有可能出现的异常放到try代码块中
如果没有报错,正常执行
如果有报错,直接走except这个分支    

可以抑制错误,防止代码程序终止.
"""
# 1.基本异常语法

"""
try:
   lst = [34,5,6]
   print(lst[3434])
except:
   pass
   print("有错误")
"""
# 2.多分支的异常处理语法
"""把异常处理类写在except的后面,用来做哪种异常的判断,如果都没有最后走except"""
"""
try:
   # lst = [34,5,6]
   # print(lst[3434])
   
   # print(name)
   
   dic =  {}
   print(dic["a"])
except IndexError:
   print("IndexError 错误")
except NameError:
   print("NameError 错误")
except KeyError:
   print("KeyError 错误")
except:
   print("有错误")
"""
# 3.迭代器/生成器异常错误
"""
def mygen():
   for i in range(5):
      yield i

# 初始化生成器函数,返回生成器对象,简称生成器;
try:
   gen  = mygen()
   for i in gen:
      print(i)

   res = next(gen)
   print(res)
except StopIteration :
   print("下标越界")
"""
# 4.raise 主动抛出异常
"""
raise + 异常错误类 或者 异常错误类的对象
BaseException 是所有异常类的父类
"""
"""
try:
   raise  # 默认后面接的就是BaseException
except:
   print("报错了")
"""

# 异常处理其他写法 (了解)
# try .. except .. else 如果出现异常就不执行else
"""
try:
   lst = [34,5,6]
   # print(lst[3434])
except:
   print("错了")
else:
   print("执行了")
"""
# try .. finally ..     无论是否出现异常都执行finally
"""
无论是否出现异常,都必须执行的代码放到finally当中.
因为正常情况下报错了之后,下面的代码是不走了,所以一旦报错就执行finally;
"""
try:
   lst = [34,5,6]
   # print(lst[3434])
finally:
   print(1)
   print(2)