面向对象3

组合

        解决类与类之间的代码冗余问题
            1. 继承：满足什么是什么的关系，is-a的关系
            2. 组合：就是一个对象拥有一个属性，该属性的值是另外一个对象

        继承是一把双刃剑，并不是继承的越多，就越好

        class People():
            school = 'SH'

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


        class Admin(People):
           pass


        class Course():
            def __init__(self, name, period, price, ):
                self.name = name
                self.period = period
                self.price = price


        python = Course('python', '6mon', 10000)
        linux = Course('linux', '5mon', 20000)


        class Student(People, Course):
            def __init__(self, name, age, gender, course=None):
                if course is None:
                    course = []
                self.courses = course
                super().__init__(name, age, gender, )

            def choose_course(self, stu_obj, course):
                stu_obj.courses.append(course)

面向对象的内置函数

        1. __init__()
        2. __str__()
        3. __del__()
        4. __enter__()
        5. __exit__()
        6. __call__()

        class Student():
            school = 'SH'

            # 调用类的时候触发
            def __init__(self, name, age):
                self.name = name
                self.age = age

            def tell(self):
                print('name: %s, age: %s' % (self.name, self.age))

            # 打印对象的时候，自动触发的函数
            # 返回值只能是字符串
            def __str__(self):
                return 'name：%s' % self.name
                # return 123

               # 1. 手动执行del
            # 2. 程序执行完毕触发
            def __del__(self):
                print('__del__')
                self.f.close()


            # 对象加括号自动触发
            def __call__(self, *args, **kwargs):
                print('__call__')


        stu = Student('ly', 20)

反射(掌握4个方法)

        # 对象通过字符串来操作属性

        1. getattr
        print(getattr(stu, 'name1', None))  # stu.name
        stu.func()
        print(getattr(stu, 'func'))
        getattr(stu, 'func')()  # 必须掌握

        2. setattr
        setattr(stu, 'x', 123)
        print(stu.__dict__)

        3. hasattr
        print(hasattr(stu, 'name'))

        4. delattr
        delattr(stu, 'name')
        print(stu.__dict__)

异常

        1. 什么是异常？
            异常就是错误发生的信号，如果不对该信号做处理，那么异常之后的代码都不会执行

            异常的种类：
                1. 语法错误
                    print(123
                2. 逻辑错误
                     # 逻辑错误尽量写到完美
                    a = [1, 2, 3]
                     a[5]
        2. 为什么要用异常
            增强代码的健壮性

        3. 怎么用异常？
                try:
                      被监测代码
                except 异常的类型:
                          pass
                  except 异常的类型:
                          pass
                  except 异常的类型:
                          pass
                except Exception as e:
                          pass
                else:
                      # 当被监测代码没有发生异常的时候，触发的
                          pass
                finally:
                       不管被监测的代码有没有出错，都执行