python之面向对象高级

组合

组合: 就是一个对象拥有一个属性， 该属性的值是另外一个对象
组合的作用:  另一种解决类与类之间的代码冗余问题
    
为什么要用组合？
	因为继承: 是满足什么是什么的关系, is—a的关系
    所以继承的使用是有一定的限制的，并且继承是一把双刃剑，并不是继承的越多就越好eg:

        
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

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

'''
学生和老师都需要课程，但是管理员不需要课程，管理员，老师，学生都是人，可以继承People类
因此People类就不能有关于课程的属性，只能重新定义一个新的类Course，显而易见，学生不是课程，
所以不能使用继承的方式去调用，为了减少代码冗余，组合就诞生了
'''

怎么使用组合

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):
    def __init__(self, name, age, gender, course=None):
        if course is None:
            course = []
        self.course = course
        super().__init__(name, age, gender, )

    def choose_course(self, course):
        self.courses.append(course)  # 把课程添加到course列表中

        
st1 = ('tom', 19, 'male')
st1.choose_course(python)  # 就把python课程加入到st1对象中，需要注意的是，python也是一个对象

面向对象的内置函数

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)

# with上下文管理协议
class Open:
    def __init__(self, name):
        self.name = name

    def __enter__(self):
        print('出现with语句，对象的__enter__被触发，有返回值则赋值给as声明的变量')
        # return self
    def __exit__(self, exc_type, exc_val, exc_tb):
        print('with中代码块执行完毕时执行我啊')


with Open('a.txt') as f:
    print('=====>执行代码块')
    # print(f,f.name)

反射

反射就是指对象通过字符串来操作类或者对象的属性
反射本质就是在使用内置函数，其中反射有以下四个内置函数:
    
1. hasattr：判断一个方法是否存在与这个类中
2. getattr：根据字符串去获取obj对象里的对应的方法的内存地址，加"()"括号即可执行
3. setattr：通过setattr将外部的一个函数绑定到实例中
4. delattr：删除一个实例或者类中的方法和属性

在python中一切皆对象，我们以time类(time模块)  和 People类为例
class People():
    school = 'SH'

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

print(hasattr(time, 'sleep'))  # True

# getattr 获取方法加括号就能执行 获取属性print就能打印出来
getattr(time, 'sleep')(1)  # 运行后程序会等待一秒
1. 设置属性
setattr(People, 'x', 123)
print(People.x)  # 123

2. 设置方法(用的很少)
def func():
    print('func')
    
setattr(People, 'print_func', func)  # 类名(属性名)  , 添加的方法名, 定义的函数名
People.print_func(People)  # 使用时不会自动传入，需要自己添加类名或对象名


delattr(People, 'school')
print(hasattr(People,'school'))  # False