组合\封装\property装饰器\多态

最新推荐文章于 2019-08-09 19:16:57 发布
最新推荐文章于 2019-08-09 19:16:57 发布
阅读量177 收藏
点赞数
分类专栏： Python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Wood_Ren/article/details/83316798
版权

组合与重用性

软件重用的重要方式除了继承之外还有另外一种方式,即:组合

  • 组合:是指,在一个类中以另一个类的对象作为数据属性,称为类的组合
# 在一个类中以另一个类的对象作为数据属性
# 类的组合
class Equip:    #武器装备类
    def fire(self):
        print('release Fire skill')

class Riven:    #英雄Riven的类,需要武器装备
    camp = 'Noxus'
    def __init__(self,nickname):
        self.nickname = nickname
        self.equip = Equip() #用Equip类产生一个装备,赋值给实例的equip

r1 = Riven('锐雯')
r1.equip.fire()    # 可以使用组合的类产生的对象所只有的方法

组合与继承都是有效地利用已有类的资源的重要方式.但是二者的概念和使用场景借不同

  • 1.继承的方式:
    通过继承建立了派生类与基类之间的关系,它是一种’是’的关系,比如人是动物,树是植物.
    当类之间有很多相同的功能,提供这些共同的功能作为基类,用继承比较好,如老师在学校,学生也在学校
  • 2.组合的方式
    用组合的方式建立了类与组合的类之间的关系,它是一种’有’的关系,比如教授有生日,教授有python和linux课程,教授有学生s1.s2.s3…

    我们把类看成一个工厂,有两个类,就是两个工厂.工厂一是用来造机器人(工厂一对象)的,工厂二是用来造机器人胳膊的,工厂二造一个机器人胳膊(工厂二对象),工厂一把这个胳膊装到自己的机器人上(作为对象的一个属性),工厂二创建的对象是工厂一创建对象的一个属性.我们通过工厂一创建的对象就能访问到工厂二创建的对象的所有数据属性和函数属性

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

class Course:
    def __init__(self,name,period,price):    # 参数名字 哪一期 价格
        self.name = name
        self.period = period
        self.price = price

    def tell_info(self):
        print('<%s %s %s>' %(self.name,self.period,self.price))

class Teacher(Penple):
    def __init__(self,name,age,sex,job_title):
        Penple.__init__(self,name,age,sex)
        self.job_title = job_title
        self.course = []
        self.student = []

class Student(Penple):
    def __init__(self,name,age,sex):
        Penple.__init__(self,name,age,sex)
        self.course = []
    def tell_info(self):
        print('<%s %s %s %s>' % (self.name, self.age, self.sex, self.course))


# 创建类Penple的对象老师和学生
egon = Teacher('egon',18,'male','沙河霸道金牌讲师')
wood = Student('wood',18,'male')
# 创建类Course的对象课程
python = Course('python','9mons',20000)
linux = Course('linux','11mons',20000)

#给老师egon和学生wood添加课程
egon.course.append(python)
egon.course.append(linux)
wood.course.append(python)

#为老师egon添加学生wood
egon.student.append(wood)

# 使用
for obj in egon.course:
    obj.tell_info()

for obj in egon.student:
    obj.tell_info()

当类之间有显著不同，并且较小的类是较大的类所需要的组件时，用组合比较好

  • 使用组合解决了两个问题:
    • 1.解决了代码冗余的问题,减少了代码
    • 2.解决了同一数据多次存储,浪费内存空间的问题

封装

什么是封装?

装:是讲一堆属性装进一个容器.
封:是把这些东西隐藏起来,但这种隐藏式对内不对外的

为何要封装?

封装不是单纯意义的隐藏

  • 封装数据属性的目的:
    将数据属性封装起来,类外部的使用就无法直接操作该数据属性了,需要类内部开一个接口给使用者,类的设计者可以在接口之上附加任意逻辑,从而严格控制使用者对属性的操作
  • 封装函数属性的目的:
    隔离复杂度

如何封装?

只需要在属性前加上__开头,该属性就会被隐藏起来.
尝试一:

class Foo:
    # 给属性x前加上__,隐藏
    __x = 111
    def __init__(self,m,n):
        self.__m = m
        self.n = n

    def __func(self):
        print('Foo.func')
# 通过类调__x,__func
Foo.__x
Foo.__func()
'''运行结果
AttributeError: type object 'Foo' has no attribute '__x'
AttributeError: type object 'Foo' has no attribute '__func'
找不到
'''
# 创建一个对象obj
obj = Foo(10,20)
# 用对象分别来调n,__x,__func
print(obj.n)
print(obj.__x)
obj.__func()
'''执行结果:
20
AttributeError: 'Foo' object has no attribute '__x'
AttributeError: 'Foo' object has no attribute '__func'
'''
# 可以看到没有隐藏的n可以找到,隐藏的找不到
# 我们会想到有一个__dict__可以查看类里的属性和对象里的属性
print(Foo.__dict__)
print(obj.__dict__)
'''执行结果:
{'_Foo__x': 111,'_Foo__func': <function Foo.__func at 0x0000023278E888C8>,...}
{'_Foo__m': 10, 'n': 20}
'''
# 我们会发现在他的属性了其实是有这两个的,只是改了名字,在前面又加了个_Foo
# 如果我们用_Foo__x或者_Foo__func去在对象或者类里调用
Foo._Foo__x
Foo._Foo__func()
print(obj._Foo__x)
obj._Foo__func()
'''执行结果:
111
Foo.func
111
Foo.func
'''
# 显而易见是可以找到的,但我们不会那么去掉,我们隐藏它就是为了不给你直接调,你还要去调,那不是傻吗
  • 根据上面的尝试一,我们来说隐藏具备的特点一:
    隐藏只是一种语法意义上的变形,即__开头的属性会在检查语法时发生变形,变成:_类名__属性名,如:_Foo__x

尝试二:

# 我们已经了解到在检查语法时,__开头的会变形为_类名__属性名
class Foo:
    # 给属性x前加上__,隐藏
    __x = 111     # _Foo__x
    def __init__(self,m,n):
        self.__m = m   # _Foo__m
        self.n = n
    def __func(self):     # _Foo__func
        print('Foo.func')
    #在内部写一个函数,来调用类里的隐藏属性
    def tell_info(self):
        print(self.__x,self.__m,self.n)   # self._Foo__x,self._Foo__m
        self.__func()    #self._Foo__func()

obj = Foo(10,20)
Foo.tell_info(obj)
obj.tell_info()
'''执行结果:
111 10 20
Foo.func
111 10 20
Foo.func
'''
# 结果显示能找到,我们也可以分析出原因
  • 根据上面的尝试二,我们来说隐藏具备的特点二:
    这种隐藏是对外不对内的,因为在类内部检测语法时所有的代码统一发生了变形

尝试三

class Foo:
    # 给属性x前加上__,隐藏
    __x = 111
    def __init__(self,m,n):
        self.__m = m
        self.n = n
    def __func(self):
        print('Foo.func')
obj = Foo(10,20)
# 我们手动给类或者对象加一个带有__的属性
Foo.__y = 222
obj.__z= 3333
print(obj.__y)
print(Foo.__y)
print(obj.__z)
'''执行结果:
222
222
3333
'''
# 手动加的并没有被隐藏

  • 根据上面的尝试三,我们来说隐藏具备的特点三:
    这种变形只在检测语法时发生一次,在类定义之后新增的__开头的属性并不会发生变形

  • 还有一个隐藏具备的特点四:
    如果父类不想让子类覆盖自己的属性,可以在属性前加__开头

class Foo:
    def f1(self):
        print('Foo.f1')

    def f2(self):
        print('Foo.f2')
        self.f1()

class Bar(Foo):
    def f1(self):
        print('Bar.f1')

b=Bar()
b.f2()
'''执行结果:
Foo.f2
Bar.f1
'''
# 子类会覆盖掉父类的属性
# 如果父类不想让子类覆盖自己的属性
class Foo:
	#给父类的属性加上__
    def __f1(self):   # _Foo__f1
        print('Foo.f1')

    def f2(self):
        print('Foo.f2')
        self.__f1()   # _Foo__f1  这个如果你想调父类的你就加__,想调子类就不加

class Bar(Foo):
    def f1(self):
        print('Bar.f1')

b=Bar()
b.f2()
'''执行结果:
Foo.f2
Foo.f1
'''

property装饰器

我们有一个例子:

  • 例一：BMI指数（bmi是计算而来的，但很明显它听起来像是一个属性而非方法，如果我们将其做成一个属性，更便于理解）
    成人的BMI数值：
    过轻：低于18.5
    正常：18.5-23.9
    过重：24-27
    肥胖：28-32
    非常肥胖, 高于32
    　　体质指数（BMI）=体重（kg）÷身高^2（m）
    　　EX：70kg÷（1.75×1.75）=22.86

没有property装饰器

class People:
    def __init__(self,name,weight,height):
        self.name=name
        self.weight=weight
        self.height=height
        
    def bmi(self):
        return self.weight / (self.height ** 2)

obj=People('egon',70,1.82)
obj.bmi()

要求是达到了,但是人吗,总是喜欢自己给自己找问题,有人会说这个bmi不是一个值吗,应该和身高什么一样,我obj.height就可以,这个也obj.bmi就要能调出来,为什么要加()呢,给与程序员来说,你有需求,我满足你,你是上帝.

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('wood',80,1.8)  #好像暴露体重了
print(obj.bmi)
'''执行结果
24.691358024691358
'''
# 需求可以了
# 如果我长个了
obj.height = 1.85
print(obj.bmi)
'''执行结果:
23.37472607742878
'''
# 也可以,伪装应该成功了
# 那bmi现在是数据属性了,我应该可以直接改
obj.bmi = 23.1231231
print(obj.bmi)
'''执行结果:
AttributeError: can't set attribute
'''
# 报错不能修改,想想函数怎么能修改呢?所以我们还要继续伪装加功能
  • 我们来说一下property装饰器的用法
    写法一(提倡使用):
class People:
    def __init__(self,name):
    	# 封装了name属性
        self.__name=name
	
	# 做一个接口,使用property装饰器
    @property
    def name(self):
    	# 隐藏数据通过接口严格控制使用者对属性的操作
        return '<name:%s>' %self.__name
	
	# 当property装饰器装饰name后,会生成一个name.setter装饰器,装饰的是修改name的接口
    @name.setter
    def name(self,new_name):
        if type(new_name) is not str:
            print('名字必须是str类型')
            return
        self.__name=new_name
	
	# 当property装饰器装饰name后,会生成一个name.deleter装饰器,装饰的是删除name的接口
    @name.deleter
    def name(self):
        del self.__name
# 查就调用查的接口
obj=People('egon')
print(obj.name)
# 改就调用改的接口
obj.name=123
print(obj.name)
# 删就调用删的接口
del obj.name
print(obj.__dict__)

写法二(出现要能看得懂):

lass People:
    def __init__(self,name):
        self.__name=name
	# 分别写删/改/查的三个接口
	# 注意: 1.接口函数名没有要求,正常的下划线格式你能辨认就好
	#      2.三个函数定义的先后顺序也没有要求,无所谓先后
    def get_name(self):
        return '<name:%s>' %self.__name

    def set_name(self,new_name):
        if type(new_name) is not str:
            print('名字必须是str类型')
            return
        self.__name=new_name

    def del_name(self):
        del self.__name
	
	# 注意:有硬性要求:
	# 依次对应property(查看接口,修改接口,删除接口) 
    name=property(get_name,set_name,del_name)

obj=People('egon')
print(obj.name)

obj.name=123
print(obj.name)

del obj.name
print(obj.__dict__)

现在我们在来写一下例一:

class People:
    def __init__(self,name,weight,height):
        self.name = name
        self.weight = weight
        self.height =height

    @property
    def bmi(self):
        return self.weight/(self.height**2)

    @bmi.setter  # 注意:被setter装饰器装饰的函数必须有两个参数,因为它装饰的是改,还需要接收一个修改的值得参数
    def bmi(self,new_bmi):
        print('bmi是根据身高体重算出不能修改')

    @bmi.deleter
    def bmi(self):
        print('bmi是根据身高体重算出不能删除')

obj = People('wood',80,1.8)
obj.weight = 70
print(obj.bmi)
obj.height = 1.85
print(obj.bmi)
obj.bmi = 12
print(obj.bmi)
del obj.bmi

多态

  • 什么是多态?
    同一种事物的多种形态,比如会水有固态/液态/气态,它们有各自的特性,又有共同的特性.我们很容易就会想到继承,子类是父类的多种形态.
  • 为何要用多态?
    多态性:指的是可以在不用考虑对象具体类型的前提下而直接使用对象下的方法
  • 如何用多态?
import abc
class Animal(metaclass=abc.ABCMeta):  #动物
	# 这个装饰器是用来统一规范的,子类必须也有这个方法
	@abc.abstractmethod
    def speak(self):
        pass
    
class People(Animal):  #形态一:人
    def speak(self):
        print('say hello')

class Dog(Animal):    #形态二:狗
    def speak(self):
        print('汪汪汪')

class Pig(Animal):    #形态三:猪
    def speak(self):
        print('哼哼哼')

peo = People()
dog=Dog()
pig=Pig()
# peo、dog、pig都是动物,只要是动物肯定有speak方法
# 基于多态性 于是我们可以不用考虑它们三者的具体是什么类型,而直接使用speak方法
peo.talk()
dog.talk()
pig.talk()
# 更进一步,我们可以定义一个统一的接口来使用
def func(obj):
    obj.talk()

  • 多态性的好处
    其实多态没有什么新知识,它就是一个概念
    好处:

    • 1.增加了程序的灵活性
      不论对象怎么变化,使用者都是同一种形式调用

    • 2.增加了程序额可扩展性
      通过animal类创建的派生类(子类),使用者无需更改自己的代码,还是同一种形式调用

    • 鸭子类型
      我们在学校Python的过程中会发现,我们硬性规定的不多,有很多都是约定俗称的规格,这个我们叫鸭子类型.
      意思是:我们认为,如果看起来像,叫声性/走路也像鸭子,那它就是鸭子,不是也是.
      这个就好多态性概念有点像

  • 我们一直用的多态性带来的好处:Python的序列类型有多种形态:字符串,列表,元祖,多态性就体现了

#str,list,tuple都是序列类型
s=str('hello')
l=list([1,2,3])
t=tuple((4,5,6))

#我们可以在不考虑三者类型的前提下使用s,l,t
s.__len__()
l.__len__()
t.__len__()
# 定义出统一的接口使用
len(s)
len(l)
len(t)
Wood_Ren
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
django_orm数据库查询语句
Wood_Ren的博客
01-14 974
一.单表操作 创建表 1.创建模型 创建名为 book 的 app, 在 book 下的 models.py 中创建模型: from django.db import models # Create your models here. class Book(models.Model): id = models.AutoField(primary_key=True) name =...
异常
Wood_Ren的博客
11-01 671
很久没写博客了 什么是异常 异常就是程序运行时发生错误的信号(在程序出现错误时,则会产生一个异常,若程序没有处理它,则会抛出该异常,程序的巡行也随之终止). 异常的组成 1.追踪信息(具体发生异常的位置 以及函数的调用顺序) 2.异常的类型(错误的类型) 3.异常的消息(详细的错误信息) 异常的分类 1.语法异常:就是语法检查时就会报错的异常,这种异常很low,不应该犯 比较好避免...
面型对象的进阶：装饰器，继承与多态
Gherry_sweet的博客
08-09 264
面向对象进阶 在前面的章节我们已经了解了面向对象的入门知识，知道了如何定义类，如何创建对象以及如何给对象发消息。为了能够更好的使用面向对象编程思想进行程序开发，我们还需要对Python中的面向对象编程进行更为深入的了解。 @property装饰器 之前我们讨论过Python中属性和方法访问权限的问题，虽然我们不建议将属性设置为私有的，但是如果直接将属性暴露给外界也是有问题的，比如我们没有办法检查赋...
面向对象三大特性之多态、封装与装饰器
08-29 175
一、多态 什么是多态：Animal类表现出Dog，Cat两种形态 # class Animal:pass # class Dog(Animal):pass # class Cat(Animal):pass 什么是多态： 　　一个类表现出来的多种形态：通过继承来实现 　　在Java中的表现：在一个函数中需要给参数指定数据类型，如果这个地方可以接收两个以上的参...
组合、封装、property装饰器和多态
weixin_30596343的博客
10-24 72
　　今天学习了组合、封装、property装饰器和多态 　　一、组合 　　　　软件重用的重要方式除了继承之外还有另外一种方式，即：组合 　　　　组合指的是，在一个类中以另外一个类的对象作为数据属性，称为类的组合 class Equip: #武器装备类 def fire(self): print('release Fire skill') ...
PYTHON-组合 封装 多态 property装饰器
weixin_33762130的博客
10-25 109
# 组合'''软件重用的重要方式除了继承之外还有另外一种方式，即：组合组合指的是，在一个类中以另外一个类的对象作为数据属性，称为类的组合1. 什么是组合 一个对象的属性是来自于另外一个类的对象,称之为组合2. 为何用组合 组合也是用来解决类与类代码冗余的问题3. 如何用组合# obj1.xxx=obj2'''''' >>> class Equip: #武器装备类...
python中自带的三个装饰器的实现
01-20
这些装饰器在Python编程中具有广泛的应用，它们提高了代码的可读性和可维护性，同时也实现了面向对象编程中的许多重要设计原则，如封装、多态和继承。了解并熟练掌握这些装饰器的使用，对于编写高效、灵活的Python...
Python类继承和多态原理解析
12-20
在`Screen`类中，`width`、`height`和`resolution`属性使用了`@property`装饰器，使得对外部来说，这些属性像是可以直接访问的，但实际上它们通过getter和setter方法进行了封装，从而可以在不影响外部调用的情况下...
定义一个学生类（Student），要求： （1）初始化数据成员数据成员（_Sno，_Sname，_Sage）； （2）通过属性装饰器定义数据成员（Sno，Sname，Sage）； （3）定义特殊方法
12-21
在`Student`类中，可以使用`@property`装饰器来创建公共的getter方法，同时使用`@<property_name>.setter`来创建setter方法： ```python class Student: def __init__(self, sno, sname, sage): self._Sno = sno...
PythonAdvanced:python高级用法知识，涵盖多线程、并发、协程、网络编程，装饰器等
05-10
python高级用法知识，涵盖多线程、并发、协程、网络编程，装饰器等 1.python高级知识-多线程 2.python高级知识-多进程 3.python高级知识-协程 5.协程gevent 6.进程、线程、协程区别 4.python网络编程 1.认识互联网 2...
Python-函数和内存分析 2.zip
最新发布
05-29
100.@property装饰器_get和set方法 101.面向对象的三大特征说明(封装、继承、多态) 102.继承 103.方法的重写 104.object根类_dir() 105.重写__str__()方法 106.多重继承 107.mro() 108.super()获得父类的定义 109....
开发目录规范
Wood_Ren的博客
10-15 667
我们已经学习了模块和包以后,在开发项目就不应该再是面条版了,应该分文件,分文件夹,这次就是来说固定的文件结构,也就是开发目录规范. # 1.文件夹的规范写法 ''' bin #可执行文件 conf #配置文件 core #主要业务逻辑 db #数据文件 lib #库(公共代码 第三方模块) log #日志文件 readme #说明文...
第一周练习题
Wood_Ren的博客
09-16 572
1.实现用户输入用户名和密码,当用户名为 seven 且 密码为 123 时,显示登陆成功,否则登陆失败! ag = True while tag: name = input('please your name:') psw = input('please your password:') if name == 'seven' and psw == '123': ...
继承与派生
Wood_Ren的博客
10-23 299
继承 什么是继承: 继承是一种创建新类的方式,新建的类可以继承一个或多个父类(python支持多继承), 父类又可以称之为基类或超类,新建的类称为派生类或子类. 子类会’遗传’父类的属性,从而解决代码重用问题 python中类的继承分为: 单继承和多继承 class ParentClass1: #定义父类 pass class ParentClass2: #定义另一个父类 pas...
面向对象的程序设计
Wood_Ren的博客
10-22 280
人生三问 什么是面向对象的程序设计? 提面向对象编程肯定会说到面向过程编程. 面向过程:核心是过程,即先干什么再干什么,流水线\机械式的思维方式 优点:复杂的问题流程化,进而简单化 缺点:牵一发而动全身,可扩展性差 面向对象的程序设计:核心是对象, 对象在现实世界中是实实在在存在的,是具备特征与(行为)技能的集合体,如果能够准确找到这个事物,那它就是一个对象 面向对象编程:我们关注的是,使用什...
数据库高级
Wood_Ren的博客
11-27 277
一.视图 什么是视图 视图是有一张表或多张表的查询结果构成一张虚拟表 为什么使用视图 当我们在使用多表查询时,sql语句可能很复杂,如果每次都编写一遍sql语气,无疑是一件很麻烦的事情,这时候就可以使用视图来避免多次编写sql的问题 视图可以帮我们节省sql的编写 视图另一个作用:可以不同的视图来展示开放不同数据的访问 例如,同一张工资表,老板可以查看全部,部门主管可以查看该部门所有人,员工...
匿名函数\函数递归与二分法
Wood_Ren的博客
10-10 253
匿名函数 1.什么是匿名函数? def定义的是有名的函数:特点是可以通过名字重复调用 def func(): #func=函数的内存地址 匿名函数就是没有名字的函数:特点是只能再定义时使用一次 2.为何要用匿名函数 强调: 匿名函数的定义就相当于只产生一个变量的值,而没有绑定任何名字, 所以会在定义完之后就被回收,无法重复使用,只能在定义时使用一次 应用:当某一个功能值使用一...
python全栈学习day02编程语言、python解释器、变量
Wood_Ren的博客
09-12 240
1.编程语言介绍 语言是一个事物与另一个事物沟通的介质或者说是表达方式 编程语言就是指程序员与计算机沟通的介质（就是一门计算机看得到的语言） 1.机器语言：直接用二进制编程去直接控制硬件，需要掌握硬件的操作细节。 优点：执行效率高 缺点：开发效率低（写起来太麻烦复制） 2.汇编语言：用英文标签取代二进制指令去编写程序，也需要掌握硬件的操作细节。 优点：开发效率比机器语言高...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值