python-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. 序列数据类型有多种形态:字符串,列表,元组
  2. 动物有多种形态:人,狗,猪

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本身就是支持多态性的,这么做的好处是什么呢?

  1. 增加了程序的灵活性:以不变应万变,不论对象千变万化,使用者都是同一种形式去调用,如func(animal)
  2. 增加了程序额可扩展性:通过继承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的形式访问到.

这种自动变形的特点:

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

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

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

  1. 这种机制也并没有真正意义上限制我们从外部直接访问属性,知道了类名和属性名就可以拼出名字:_类名__属性,然后就可以访问了,如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'
  1. 变形的过程只在类的定义时发生一次,在定义后的赋值操作,不会变形
a = A()
print(a.__dict__)
{'_A__X': 10}
a.__Y = 1
print(a.__dict__)
{'_A__X': 10, '__Y': 1}
  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-08-28 16:40  wind叶  阅读(170)  评论(0编辑  收藏  举报