Python入门学习

DAY25

今日内容: 组合多态封装 property装饰器

组合

1.什么是组合

组合:就是某一个对象拥有一个属性,该属性的值是另一个类的对象

2.为什么要用组合

通过为一个对象添加一个属性(该属性是另一个类的对象)的方式,可以间接的将两个类关联/整合/组合到一起

从而减少类与类之间的代码冗余

3.如何用组合

列:

class People:
    """父类"""
    school = 'oldboy'

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


class Student(People):
    """学生类"""
    def __init__(self, name, age, sex, score=0):
        People.__init__(self, name, age, sex)
        self.score = score
        self.course = []

    def choose_course(self):
        print('%s choosing course' % self.name)

    def tell_all_course(self):
        for i in self.course:
            i.tell_info()


class Teacher(People):
    """老师类"""
    def __init__(self, name, age, sex, level):
        People.__init__(self, name, age, sex)
        self.level = level
        self.course = []

    def score(self, stu, num):
        stu.name = num

    def tell_all_course(self):
        for i in self.course:
            i.tell_info()


class Course:
    """课程类"""
    def __init__(self, c_name, c_price, c_period):
        self.c_name = c_name
        self.c_price = c_price
        self.c_period = c_period

    def tell_info(self):
        print('<课程名:%s 价钱:%s 周期:%s>' % (self.c_name, self.c_price, self.c_period))


python = Course('python', 1900, '5mons')
linux = Course('Linux', 900, '3mons')    

stu1 = Student('路人甲', 16, 'male')
stu1.course.append(python)             #利用组合,将课程类Course的对象成为学生对象stu1的属性
tea1 = Teacher('王老师', 38, 'male',5)
tea1.course.append(python)             #利用组合,将课程类Course的对象成为老师对象tea1的属性   
tea1.course.append(linux)              #利用组合,将课程类Course的对象成为老师对象tea1的属性
stu1.tell_all_course()
tea1.tell_all_course()

扫描二维码关注公众号，回复： 2928160 查看本文章

多态

1.什么是多态

多态:指同一种类/事物的不同的形态

2.为什么要用多态

多态性:在多态的背景下,可以不用考虑对象的具体类型的前提下而直接使用对象

多态性的精髓就是统一

3.如何使用多态

列:如果不按父类规范会报错:Can't instantiate abstract class Cat with abstract methods run（不能用抽象的方法实例化抽象类）

import abc

class Animal(metaclass=abc.ABCMeta):
    @abc.abstractmethod
    def speak(self):
        pass

    @abc.abstractmethod
    def run(self):
        pass
#父类只是用来建立规范的,不能用来实列化,更无需实现内部的方法


class Cat(Animal):
    def speak(self):
        print('喵喵喵')

    def run(self):
        pass

class Dog(Animal):
    def speak(self):
        print('汪汪汪')

    def run(self):
        pass

class Pig(Animal):
    def speak(self):
        print('哼哼哼')

    def run(self):
        pass

obj1=Cat()
obj2=Dog()
obj3=Pig()
obj1.speak()
obj2.speak()
obj3.speak()

python崇尚鸭子类型

“鸭子测试”可以这样表述：
“当看到一只鸟走起来像鸭子、游泳起来像鸭子、叫起来也像鸭子，那么这只鸟就可以被称为鸭子。”

在鸭子类型中，关注的不是对象的类型本身，而是它是如何使用的

列如:

class Disk:
    def read(self):
        print('Disk read')

    def write(self):
        print('Disk write')


class Memory:
    def read(self):
        print('Mem read')

    def write(self):
        print('Mem write')


class Cpu:
    def read(self):
        print('Cpu read')

    def write(self):
        print('Cpu write')


obj1=Disk()
obj2=Memory()
obj3=Cpu()

obj1.read()
obj2.read()
obj3.read()

封装

1.什么是封装

装:在容器/名称空间中存入名字

封:将名称空间中的名字给隐藏起来,这种隐藏对外不对内

2.为什么要封装

封装数据属性:将数据隐藏起来,类外就无法直接操作属性,需要在类内开辟一个接口让外部可以间接的操作属性

我们可以在接口内定义任意的控制逻辑的代码,从而严格控制对属性的操作

封装函数属性:隔离复杂度

3.如何封装

在类定义的属性前加__开头(没有__结尾)

列:

class Foo:
    __x=111     #_Foo__x
    __y=222     #_Foo__y


    def __init__(self,name,age):
        self.__name=name
        self.__age=age

    def __func(self):    #_Foo__func
        print('func')

    def get_info(self):   #get_info 就是为外部提供的接口
        print(self.__name,self.__age,self.__x)

总结:

1. __开头的属性实现的隐藏仅仅只是一种语法意义上的变形,并不会真的限制类外部的访问
2. 该变形操作只在类定义阶段检测语法时发生一次,类定义阶段之后新增的__开头的属性并不会变形
3. 如果父类不想让子类覆盖自己的属性,可以在属性前加__开头

property装饰器

property是用来将类内的函数属性伪装成数据属性

列:

class People:
    def __init__(self,name,weight,height):
        self.name=name
        self.weight=weight
        self.height=height
    
    @property    #用property装饰后,调用时既不需要带括号
    def bmi(self):
        return self.weight/(self.height**2)


obj=People('xxx',60,1.75)
print(obj.bmi)