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. 调用时，无需括号