zoukankan      html  css  js  c++  java
  • 7. 继承(单、多、菱形)多态魔术方法装饰器异常

    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)


    善战者,求之于势,不责于人,故能择人而任势
  • 相关阅读:
    iOS学习05C语言函数
    iOS学习04C语言数组
    iOS学习03C语言循环结构
    iOS学习02C语言分支结构
    iOS学习01C语言数据类型
    Objective-C学习——中文URL编码和解码
    Objective-c 字面量
    SDWebImage
    mac的svn之cornerstone简易教程
    javascript 和oc交互
  • 原文地址:https://www.cnblogs.com/NGU-PX/p/11332800.html
Copyright © 2011-2022 走看看