python 组合 反射 异常 面对对象的内置函数

内容概要

• 组合
• 面向对象的内置函数(魔术方法，魔法，__开头__的方法)
• 反射(掌握4个方法)
• 异常

内容详细

组合

            # 组合：就是一个对象拥有一个属性，该属性的值是另外一个对象

            解决类与类之间的代码冗余问题
                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:
                           不管被监测的代码有没有出错，都执行