组合

一、什么是组合

对象的某个属性是另外定义的一个类的对象

#举个栗子
class Animal：
	def __init__(self, level):
        self.level = level
        
class Level:
        pass
    
#Animal类的属性level是另一个类的对象
level = Level()
l = Animal(level)

二、为什么使用组合

减少代码冗余

class Person:
    school = 'oldboy'

class Teacher(Person):
    def __init__(self,name,age,level,course):
        self.name = name
        self.age = age
        self.level = level
        #course是课程对象,表示老师教授的课程
        self.course = course

class Student(Person):
    def __init__(self,name,age,course):
        self.name = name
        self.age = age
        # course是课程对象,表示学生选的课程
        self.course = course

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

        
course=Course('Python', 20000, 6)
stu=Student('nick', 19, course)
teacher=Teacher('nick', 19, '高级', course)

#查看老师教授的课程名
print(teacher.course.name)  #Python

三、如何使用组合

class Person:
    school = 'oldboy'
    
class Teacher(Person):
    def __init__(self, name, age, level, course):
        self.name = name
        self.age = age
        self.level = level
        #course是课程对象,表示老师教授的课程
        self.course = course

class Student(Person):
    # course=[]  #错误
    def __init__(self, name, age):
        self.name = name
        self.age = age
        # course是课程对象,表示学生选的课程
        self.course_list = []
    def choose_course(self, course):
        # self.course=[]  #错误
        #把课程对象追加到学生选课的列表中
        self.course_list.append(course)

    def tell_all_course(self):
        #循环学生选课列表,每次拿出一个课程对象
        for course in self.course_list:
            #课程对象.name  取到课程名字
            print(course.name)

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



course = Course('Python',20199,7)
stu1 = Student('nick',19)
stu1.choose_course(course)
stu2 = Student('王二丫',19)
stu2.choose_course(course)
stu2.choose_course(Course('linux',19999,5))


#查看stu1选的所有课程名称
#方式一(通过普通函数)
 def tell_all_course(student):
     for course in student.course_list:
        print(course.name)

tell_all_course(stu1)
tell_all_course(stu2)

#方式二(通过对象的绑定方法)
stu1.tell_all_course()
stu2.tell_all_course()

多态和多态性

一、什么是多态

表示一类事物具有多种形态，例如class Animal，这个Animal类里又分为人、猪、猫等等

二、什么是多态性

表示向不同的对象发送同一条消息，不同的对象在接收时会产生不同的行为（即方法）

class Animal:
    def run(self):  # 子类约定俗称的必须实现这个方法  #def click(self):....等
        raise AttributeError('子类必须实现这个方法')


class People(Animal):
    def run(self):
        print('人正在走')


class Pig(Animal):
    def run(self):
        print('pig is walking')


class Dog(Animal):
    def run(self):
        print('dog is running')


peo1 = People()
pig1 = Pig()
d1 = Dog()     

# 多态性：一种调用方式，不同的执行效果（多态性）
def func(obj):
    obj.run()
 	#obj.click()
    #ocj.bite()
    ...


func(peo1)
func(pig1)
func(d1)

#人正在走
#pig is walking
#dog is running

总结：多态性是一个接口（函数func）的多种实现（如obj.run()，obj.talk()，obj.click()，len(obj)）

三、多态性的优点

增加了程序的灵活性：以不变应万变，不论对象千变万化，使用者都是同一种形式去调用，如func(animal)
增加了程序额可扩展性：通过继承Animal类创建了一个新的类，使用者无需更改自己的代码，还是用func(animal)去调用

class Cat(Animal):  # 属于动物的另外一种形态：猫
    def talk(self):
        print('say miao')


def func(animal):  # 对于使用者来说，自己的代码根本无需改动
    animal.talk()


cat1 = Cat()  # 实例出一只猫
func(cat1)  # 甚至连调用方式也无需改变，就能调用猫的talk功能

四、鸭子类型

可以用一个函数去调用任意定义的类中的方法，例如：

#崇尚鸭子类型:只要走路像鸭子(对象中有某个绑定方法),那你就是鸭子

class Pig:
    def speak(self):
        print('哼哼哼')
class People:
    def speak(self):
        print('say hello')

pig=Pig()
pe=People()

def animal_speak(obj):  #同一函数调用
    obj.speak()

    
animal_speak(pig)
animal_speak(pe)

封装

一、什么是封装

封装即将许多东西装进麻袋，然后封口隐藏，使得外部无法访问。

二、如何隐藏属性/方法

隐藏属性：通过__变量名来隐藏（可以内部调用）

更安全

class Person:
    def __init__(self, name):
        self.__name = name
    def check_name(self):
        return '%s' %self.__name   #可以内部调用

p = Person('nick')

#访问name
print(p.name)
print(p.__name)
#以上两种无法获取，已被隐藏。
print(p.get_name())  #可通过函数内部调用获取

#获取方法
①--> print(p.__dict__)  #获取隐藏名
②--> print(p._Person__name)

隐藏方法：通过__方法名来隐藏

隔离复杂度

class Person:
    def __init__(self,name,age):
        self.__name = name
        self.__age = age
    def __speak(self):
        print('6666')

p=Person('nick',89)
#p.__speak() 无法调用

#获取方法
①--> print(Person.__dict__)
②--> p._Person__speak()

注意：在类内部以__变量名命名的变量，都会被隐藏。在外部放入的__变量名，属性不隐藏。

举个栗子：

class Person:
    def __init__(self,name,age):
        self.__name = name
        self.__age = age
    def set_xx(self,xx):
        self.__xx = xx
        print(self.__xx)

p=Person('nick',18)

p.__level = 5 #在类外__变量名放入新变量，不会隐藏属性

p.set_xx('6688')

property装饰器

一、什么是property

将方法包装成数据属性

#计算人的bmi指数
#property装饰器：把方法包装成数据属性

class Person:
    def __init__(self, name, height, weight):
        self.name = name
        self.height = height
        self.weight = weight
    
    @property
    def bmi(self):
        return self.weight/(self.height**2)


p = Person('lqz', 1.82, 70)
# print(p.bmi()) #用了@property，不需要再加括号调用
print(p.bmi)

p.name='ppp'
print(p.name)  #ppp

p.bmi=90
print(p.bmi) #报错，因为此时的bmi已转为数据属性，是会随着参数而改变的，所以不可修改。

二、property之setter和deleter

class Person:
    def __init__(self, name, height, weight):
        self.__name = name
        self.__height = height
        self.__weight = weight
    
    @property
    def name(self):
        return '[我的名字是：%s]' %self.__name
    #用property装饰的方法名.setter
    
    @name.setter
    def name(self,new_name):
        # if not isinstance(new_name,str):
        if type(new_name) is not str:
            raise Exception('改不了')
        if new_name.startswith('sb'):
            raise Exception('不能以sb开头')
        self.__name = new_name

    # 用property装饰的方法名.deleter
    
    @name.deleter
    def name(self):
        # raise Exception('不能删')
        print('删除成功')
        # del self.__name

p=Person('lqz',1.82,70)
# print(p.name)
# p.name='pppp'
# p.name='xxx'
#改不了，直接抛一异常
# p.name=999
# p.name='sb_nick'

# print(p.name)

del p.name
print(p.name)