组合

组合就是一个类的对象具备某一个属性，该属性的值是指向另外外一个类的对象
组合是用来解决类与类之间代码冗余的问题
首先我们先写一个简单版的选课系统

class OldboyPeople:

    school = 'oldboy'

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

        self.name = name

        self.age = age

        self.sex = sex

class OldboyStudent(OldboyPeople):

    def __init__(self, name, age, sex, stu_id):

        OldboyPeople.__init__(self, name, age, sex)

        self.stu_id = stu_id

    def choose_course(self):

        print('%s is choosing course' % self.name)

class OldboyTeacher(OldboyPeople):

    def __init__(self, name, age, sex, level):

        OldboyPeople.__init__(self, name, age, sex)

        self.level = level

    def score(self, stu, num):

        stu.score = num

        print('老师[%s]为学生[%s]打分[%s]' % (self.name, stu.name, num))

stu1 = OldboyStudent('tank', 19, 'male', 1)

tea1 = OldboyTeacher('nick', 18, 'male', 10)

stu1.choose_course()

tank is choosing course

tea1.score(stu1, 100)

老师[nick]为学生[tank]打分[100]

print(stu1.__dict__)

{'name': 'tank', 'age': 19, 'sex': 'male', 'stu_id': 1, 'score': 100}

需求：假如我们需要给学生增添课程属性，但是又不是所有的老男孩学生一进学校就有课程属性，课程属性是学生来老男孩后选出来的，也就是说课程需要后期学生们添加进去的
实现思路：如果我们直接在学生中添加课程属性，那么学生刚被定义就需要添加课程属性，这就不符合我们的要求，因此我们可以使用组合能让学生未来添加课程属性

class Course:

    def __init__(self, name, period, price):

        self.name = name

        self.period = period

        self.price = price

    def tell_info(self):

        msg = """

        课程名：%s

        课程周期：%s

        课程价钱：%s

        """ % (self.name, self.period, self.price)

        print(msg)

class OldboyPeople:

    school = 'oldboy'

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

        self.name = name

        self.age = age

        self.sex = sex

class OldboyStudent(OldboyPeople):

    def __init__(self, name, age, sex, stu_id):

        OldboyPeople.__init__(self, name, age, sex)

        self.stu_id = stu_id

    def choose_course(self):

        print('%s is choosing course' % self.name)

class OldboyTeacher(OldboyPeople):

    def __init__(self, name, age, sex, level):

        OldboyPeople.__init__(self, name, age, sex)

        self.level = level

    def score(self, stu, num):

        stu.score = num

        print('老师[%s]为学生[%s]打分[%s]' % (self.name, stu.name, num))

# 创造课程

python = Course('python全栈开发', '5mons', 3000)

python.tell_info()

        课程名：python全栈开发

        课程周期：5mons

        课程价钱：3000

linux = Course('linux运维', '5mons', 800)

linux.tell_info()

        课程名：linux运维

        课程周期：5mons

        课程价钱：800

# 创造学生与老师

stu1 = OldboyStudent('tank', 19, 'male', 1)

tea1 = OldboyTeacher('nick', 18, 'male', 10)

组合

# 将学生、老师与课程对象关联/组合

stu1.course = python

tea1.course = linux

stu1.course.tell_info()

        课程名：python全栈开发

        课程周期：5mons

        课程价钱：3000

tea1.course.tell_info()

        课程名：linux运维

        课程周期：5mons

        课程价钱：800

多态

多态指的是一类事物有多种形态，（一个抽象类有多个子类，因而多态的概念依赖于继承）

序列数据类型有多种形态：字符串，列表，元组
动物有多种形态：人，狗，猪

1.1 动物的多种形态

# 动物有多种形态：人类、猪、狗

class Animal:

    def run(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()

peo1.run()

pig1.run()

d1.run()

人正在走

pig is walking

dog is running

import abc

class Animal(metaclass=abc.ABCMeta):  # 同一类事物:动物

    @abc.abstractmethod  # 上述代码子类是约定俗称的实现这个方法，加上@abc.abstractmethod装饰器后严格控制子类必须实现这个方法

    def talk(self):

        raise AttributeError('子类必须实现这个方法')

class People(Animal):  # 动物的形态之一:人

    def talk(self):

        print('say hello')

class Dog(Animal):  # 动物的形态之二:狗

    def talk(self):

        print('say wangwang')

class Pig(Animal):  # 动物的形态之三:猪

    def talk(self):

        print('say aoao')

peo2 = People()

pig2 = Pig()

d2 = Dog()

peo2.talk()

pig2.talk()

d2.talk()

say hello

say aoao

say wangwang

1.2 文件的多种形态

# 文件有多种形态：文件、文本文件、可执行文件

import abc

class File(metaclass=abc.ABCMeta):  # 同一类事物:文件

    @abc.abstractmethod

    def click(self):

        pass

class Text(File):  # 文件的形态之一:文本文件

    def click(self):

        print('open file')

class ExeFile(File):  # 文件的形态之二:可执行文件

    def click(self):

        print('execute file')

text = Text()

exe_file = ExeFile()

text.click()

exe_file.click()

open file

execute file

多态性

注意：多态与多态性是两种概念

多态性是指具有不同功能的函数可以使用相同的函数名，这样就可以用一个函数名调用不同内容的函数。在面向对象方法中一般是这样表述多态性：向不同的对象发送同一条消息，不同的对象在接收时会产生不同的行为（即方法）。也就是说，每个对象可以用自己的方式去响应共同的消息。所谓消息，就是调用函数，不同的行为就是指不同的实现，即执行不同的函数。

2.1 动物形态多态性的使用

# 多态性：一种调用方式，不同的执行效果（多态性）

def func(obj):

    obj.run()

func(peo1)

func(pig1)

func(d1)

人正在走

pig is walking

dog is running

# 多态性依赖于：继承

# 多态性：定义统一的接口

def func(obj):  # obj这个参数没有类型限制，可以传入不同类型的值

    obj.talk()  # 调用的逻辑都一样，执行的结果却不一样

func(peo2)

func(pig2)

func(d2)

say hello

say aoao

say wangwang

2.2 文件形态多态性的使用

def func(obj):

    obj.click()

func(text)

func(exe_file)

open file

execute file

2.3 序列数据类型多态性的使用

def func(obj):

    print(len(obj))

func('hello')

func([1, 2, 3])

func((1, 2, 3))

5

3

3

综上可以说，多态性是一个接口（函数func）的多种实现（如obj.run()，obj.talk()，obj.click()，len(obj)）

好处

其实大家从上面多态性的例子可以看出，我们并没有增加新的知识，也就是说Python本身就是支持多态性的，这么做的好处是什么呢？

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

class Cat(Animal):  # 属于动物的另外一种形态：猫

    def talk(self):

        print('say miao')

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

    animal.talk()

cat1 = Cat()  # 实例出一只猫

func(cat1)  # 甚至连调用方式也无需改变，就能调用猫的talk功能

say miao

上述代码我们新增了一个形态Cat，由Cat类产生的实例cat1，使用者可以在完全不需要修改自己代码的情况下。使用和人、狗、猪一样的方式调用cat1的talk方法，即func(cat1)

封装

你钱包的有多少钱（数据的封装）
你的性取向（数据的封装）
你撒尿的具体功能是怎么实现的（方法的封装）

为什么要封装？

封装数据的主要原因是：保护隐私（作为男人的你，脸上就写着：我喜欢男人，你害怕么？）

封装方法的主要原因是：隔离复杂度（快门就是傻瓜相机为傻瓜们提供的方法，该方法将内部复杂的照相功能都隐藏起来了，比如你不必知道你自己的尿是怎么流出来的，你直接掏出自己的接口就能用尿这个功能）

提示：在编程语言里，对外提供的接口（接口可理解为了一个入口），就是函数，称为接口函数，这与接口的概念还不一样，接口代表一组接口函数的集合体。

两个层面

封装其实分为两个层面，但无论哪种层面的封装，都要对外界提供好访问你内部隐藏内容的接口（接口可以理解为入口，有了这个入口，使用者无需且不能够直接访问到内部隐藏的细节，只能走接口，并且我们可以在接口的实现上附加更多的处理逻辑，从而严格控制使用者的访问）

第一个层面的封装（什么都不用做）：创建类和对象会分别创建二者的名称空间，我们只能用类名.或者obj.的方式去访问里面的名字，这本身就是一种封装

注意：对于这一层面的封装（隐藏），类名.和实例名.就是访问隐藏属性的接口

第二个层面的封装：类中把某些属性和方法隐藏起来(或者说定义成私有的)，只在类的内部使用、外部无法访问，或者留下少量接口（函数）供外部访问。

在python中用双下划线的方式实现隐藏属性（设置成私有的）

类中所有双下划线开头的名称如__x都会自动变形成：_类名__x的形式：

class A:

    __N = 0  # 类的数据属性就应该是共享的,但是语法上是可以把类的数据属性设置成私有的如__N,会变形为_A__N

    def __init__(self):

        self.__X = 10  # 变形为self._A__X

    def __foo(self):  # 变形为_A__foo

        print('from A')

    def bar(self):

        self.__foo()  # 只有在类内部才可以通过__foo的形式访问到.

这种自动变形的特点：

类中定义的__x只能在内部使用，如self.__x，引用的就是变形的结果。
这种变形其实正是针对内部的变形，在外部是无法通过__x这个名字访问到的。
在子类定义的__x不会覆盖在父类定义的__x，因为子类中变形成了：_子类名__x,而父类中变形成了：_父类名__x，即双下滑线开头的属性在继承给子类时，子类是无法覆盖的。

注意：对于这一层面的封装（隐藏），我们需要在类中定义一个函数（接口函数）在它内部访问被隐藏的属性，然后外部就可以使用了

这种变形需要注意的问题是：

这种机制也并没有真正意义上限制我们从外部直接访问属性，知道了类名和属性名就可以拼出名字：_类名__属性，然后就可以访问了，如a._A__N

# 对象测试

a = A()

print(a._A__N)

0

# 对象测试

print(a._A__X)

10

# 类测试

print(A._A__N)

0

# 类测试

try:

    print(A._A__X)  # 对象私有的属性

except Exception as e:

    print(e)

type object 'A' has no attribute '_A__X'

变形的过程只在类的定义时发生一次,在定义后的赋值操作，不会变形

a = A()

print(a.__dict__)

{'_A__X': 10}

a.__Y = 1

print(a.__dict__)

{'_A__X': 10, '__Y': 1}

在继承中，父类如果不想让子类覆盖自己的方法，可以将方法定义为私有的

# 正常情况

class A:

    def fa(self):

        print('from A')

    def test(self):

        self.fa()

class B(A):

    def fa(self):

        print('from B')

b = B()

b.test()

from B

# 把fa定义成私有的，即__fa

class A:

    def __fa(self):  # 在定义时就变形为_A__fa

        print('from A')

    def test(self):

        self.__fa()  # 只会与自己所在的类为准,即调用_A__fa

class B(A):

    def __fa(self):

        print('from B')

b = B()

b.test()

from A

python并不会真的阻止你访问私有的属性，模块也遵循这种约定，如果模块中的变量名_private_module以单下划线开头，那么from module import *时不能被导入该变量，但是你from module import _private_module依然是可以导入该变量的

其实很多时候你去调用一个模块的功能时会遇到单下划线开头的(socket._socket,sys._home,sys._clear_type_cache),这些都是私有的，原则上是供内部调用的，作为外部的你，一意孤行也是可以用的，只不过显得稍微傻逼一点点

python要想与其他编程语言一样，严格控制属性的访问权限，只能借助内置方法如__getattr__，详见面向对象高级部分。

property

property装饰器用于将被装饰的方法伪装成一个数据属性，在使用时可以不用加括号而直接使用

# ############### 定义 ###############

class Foo:

    def func(self):

        pass

    # 定义property属性

    @property

    def prop(self):

        pass

# ############### 调用 ###############

foo_obj = Foo()

foo_obj.func()  # 调用实例方法

foo_obj.prop  # 调用property属性

如下的例子用于说明如何定一个简单的property属性：

class Goods(object):

    @property

    def size(self):

        return 100

g = Goods()

print(g.size)

100

property属性的定义和调用要注意一下几点：

\1. 定义时，在实例方法的基础上添加 @property 装饰器；并且仅有一个self参数

\2. 调用时，无需括号

巴特西

python-day25(正式学习)

组合

多态

多态性

好处

封装

两个层面

property

最新文章

热门文章