Blueherb In solitude, where we are least alone

day25

组合
组合就是一个类的对象具备某一个属性,该属性的值是指向另外外一个类的对象
组合是用来解决类与类之间代码冗余的问题
首先我们先写一个简单版的选课系统
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. 调用时,无需括号

posted @ 2019-09-11 19:25  奏乐乐章  阅读(102)  评论(0编辑  收藏  举报