day19-面向对象之封装property特性绑定与非绑定

Posted wcl0517

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了day19-面向对象之封装property特性绑定与非绑定相关的知识,希望对你有一定的参考价值。

一、面向对象之封装

1.1、引言

从封装本身的意思去理解,封装就好像是拿来一个麻袋,把小猫,小狗,小王八,还有alex一起装进麻袋,然后把麻袋封上口子。照这种逻辑看,封装=‘隐藏’,这种理解是相当片面的

2.1-如何隐藏(在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的形式访问到.

#A._A__N是可以访问到的,
#这种,在外部是无法通过__x这个名字访问到。
技术分享图片
 1 这种变形需要注意的问题是:
 2 
 3 1.这种机制也并没有真正意义上限制我们从外部直接访问属性,知道了类名和属性名就可以拼出名字:_类名__属性,然后就可以访问了,如a._A__N,即这种操作并不是严格意义上的限制外部访问,仅仅只是一种语法意义上的变形,主要用来限制外部的直接访问。
 4 
 5 2.变形的过程只在类的定义时发生一次,在定义后的赋值操作,不会变形
 6 
 7 class People:
 8     __country=China #_People__country=‘China‘
 9     __n=100 #_People__n=100
10     def __init__(self,name,age,sex):
11         self.__name=name #self._People__name=name
12         self.age=age
13         self.sex=sex
14 
15     def eat(self):
16         print(eat.....)
17         print(People.__country) #People._People__country
18         print(self.__name) #self._People__name
19 而是将所需要取的属性变成了_类名__属性名形式
20 如果实在要取值可以通过如
21 peo1 = people(‘wcl’,18,male)
22 print(peo1._people__name)得到name的名字
注意本质上并没有隐藏

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

技术分享图片
 1 正常情况:
 2 class Foo:
 3     def f1(self): 
 4         print(Foo.f1)
 5 
 6     def f2(self):
 7         print(Foo.f2)
 8         self.f1() 
 9 
10 class Bar(Foo):
11     def f1(self):
12         print(Bar.f1)
13 
14 obj=Bar()
15 obj.f2()
16 先调用父类中的f2(),打印出Foo.f2,在调用发f1,回到自己的对象名称空间中先找,找到了 于是打印Bar.f1
17 Foo.f2
18 Bar.f1
19 
20 
21 隐藏情况:
22 class Foo:
23     def __f1(self): #_Foo__f1
24         print(Foo.f1)
25 
26     def f2(self):
27         print(Foo.f2)
28         self.__f1() #self._Foo__f1
29 
30 class Bar(Foo):
31     def __f1(self): #_Bar__f1
32         print(Bar.f1)
33 
34 obj=Bar()
35 obj.f2()
36 #1同样先调用f2 打印出Foo.f2 
37 #2再次调用f1的时候此时的f1由于被隐藏了 名称实质变成了self._Foo__f1() BAR中的f1变成了_Bar__f1
38 Foo.f2
39 Foo.f1
继承中属性查找如果遇到同名函数,且被隐藏查找的顺序

 3、封装不是单纯意义的隐藏

封装的真谛在于明确地区分内外,封装的属性可以直接在内部使用,而不能被外部直接使用,然而定义属性的目的终归是要用,外部要想用类隐藏的属性,需要我们为其开辟接口,让外部能够间接地用到我们隐藏起来的属性,那这么做的意义何在???

 3.1-封装数据:将数据隐藏起来这不是目的。隐藏起来然后对外提供操作该数据的接口,然后我们可以在接口附加上对该数据操作的限制,以此完成对数据属性操作的严格控制。

技术分享图片
 1 class Teacher:
 2     def __init__(self,name,age):
 3         # self.__name=name
 4         # self.__age=age
 5         self.set_info(name,age)
 6 
 7     def tell_info(self):
 8         print(姓名:%s,年龄:%s %(self.__name,self.__age))
 9     def set_info(self,name,age):
10         if not isinstance(name,str):
11             raise TypeError(姓名必须是字符串类型)
12         if not isinstance(age,int):
13             raise TypeError(年龄必须是整型)
14         self.__name=name
15         self.__age=age
16 
17 
18 t=Teacher(egon,18)
19 t.tell_info()
20 
21 t.set_info(egon,19)
22 t.tell_info()
通过调用tell接口访问数据

3.2-封装方法:目的是隔离复杂度

封装方法举例: 

1. 你的身体没有一处不体现着封装的概念:你的身体把膀胱尿道等等这些尿的功能隐藏了起来,然后为你提供一个尿的接口就可以了(接口就是你的。。。,),你总不能把膀胱挂在身体外面,上厕所的时候就跟别人炫耀:hi,man,你瞅我的膀胱,看看我是怎么尿的。

2. 电视机本身是一个黑盒子,隐藏了所有细节,但是一定会对外提供了一堆按钮,这些按钮也正是接口的概念,所以说,封装并不是单纯意义的隐藏!!!

3. 快门就是傻瓜相机为傻瓜们提供的方法,该方法将内部复杂的照相功能都隐藏起来了

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

技术分享图片
 1 #取款是功能,而这个功能有很多功能组成:插卡、密码认证、输入金额、打印账单、取钱
 2 #对使用者来说,只需要知道取款这个功能即可,其余功能我们都可以隐藏起来,很明显这么做
 3 #隔离了复杂度,同时也提升了安全性
 4 
 5 class ATM:
 6     def __card(self):
 7         print(插卡)
 8     def __auth(self):
 9         print(用户认证)
10     def __input(self):
11         print(输入取款金额)
12     def __print_bill(self):
13         print(打印账单)
14     def __take_money(self):
15         print(取款)
16 
17     def withdraw(self):
18         self.__card()
19         self.__auth()
20         self.__input()
21         self.__print_bill()
22         self.__take_money()
23 
24 a=ATM()
25 a.withdraw()
26 
27 隔离复杂度的例子
正常的取款流程,可以通过封装只提供一个接口给用户调用

 4、特性(property) 

4.1-什么是特性property

  property是一种特殊的属性,访问它时会执行一段功能(函数)然后返回值

技术分享图片
 1 例一:BMI指数(bmi是计算而来的,但很明显它听起来像是一个属性而非方法,如果我们将其做成一个属性,更便于理解)
 2 
 3 成人的BMI数值:
 4 过轻:低于18.5
 5 正常:18.5-23.9
 6 过重:24-27
 7 肥胖:28-32
 8 非常肥胖, 高于32
 9   体质指数(BMI)=体重(kg)÷身高^2(m)
10   EX:70kg÷(1.75×1.75)=22.86
11 
12 class People:
13     def __init__(self,name,weight,height):
14         self.name=name
15         self.weight=weight
16         self.height=height
17     @property
18     def bmi(self):
19         return self.weight / (self.height**2)
20 
21 p1=People(egon,75,1.85)
22 print(p1.bmi)
23 
24 #property 特性可以去掉()后直接调用函数得到返回值
人体指数BMI
技术分享图片
 1 import math
 2 class Circle:
 3     def __init__(self,radius): #圆的半径radius
 4         self.radius=radius
 5 
 6     @property
 7     def area(self):
 8         return math.pi * self.radius**2 #计算面积
 9 
10     @property
11     def perimeter(self):
12         return 2*math.pi*self.radius #计算周长
13 
14 c=Circle(10)
15 print(c.radius)
16 print(c.area) #可以向访问数据属性一样去访问area,会触发一个函数的执行,动态计算出一个值
17 print(c.perimeter) #同上
18 ‘‘‘
19 输出结果:
20 314.1592653589793
21 62.83185307179586
22 ‘‘‘
23 
24 #注意:此时的特性arear和perimeter不能被赋值
25 c.area=3 #为特性area赋值
26 ‘‘‘
27 抛出异常:
28 AttributeError: can‘t set attribute
29 ‘‘‘
计算园的面积及周长
将一个类的函数定义成特性以后,对象再去使用的时候obj.name,根本无法察觉自己的name是执行了一个函数然后计算出来的,这种特性的使用方式遵循了统一访问的原则
除此之外,看下
ps:面向对象的封装有三种方式:
【public】
这种其实就是不封装,是对外公开的
【protected】
这种封装方式对外不公开,但对朋友(friend)或者子类(形象的说法是“儿子”,但我不知道为什么大家 不说“女儿”,就像“parent”本来是“父母”的意思,但中文都是叫“父类”)公开
【private】
这种封装对谁都不公开

 python并没有在语法上把它们三个内建到自己的class机制中,在C++里一般会将所有的所有的数据都设置为私有的,然后提供set和get方法(接口)去设置和获取,在python中通过property方法可以实

技术分享图片
 1 class Foo:
 2     def __init__(self,val):
 3         self.__NAME=val #将所有的数据属性都隐藏起来
 4 
 5     @property
 6     def name(self):
 7         return self.__NAME #obj.name访问的是self.__NAME(这也是真实值的存放位置)
 8 
 9     @name.setter
10     def name(self,value):
11         if not isinstance(value,str):  #在设定值之前进行类型检查
12             raise TypeError(%s must be str %value)
13         self.__NAME=value #通过类型检查后,将值value存放到真实的位置self.__NAME
14 
15     @name.deleter
16     def name(self):
17         raise TypeError(Can not delete)
18 
19 f=Foo(egon)
20 print(f.name)
21 # f.name=10 #抛出异常‘TypeError: 10 must be str‘
22 del f.name #抛出异常‘TypeError: Can not delete‘
property中的setter、deleter使用

封装的好处

封装在于明确区分内外,使得类实现者可以修改封装内的东西而不影响外部调用者的代码;而外部使用用者只知道一个接口(函数),只要接口(函数)名、参数不变,使用者的代码永远无需改变。这就提供一个良好的合作基础——或者说,只要接口这个基础约定不变,则代码改变不足为虑。 

技术分享图片
 1 #类的设计者
 2 class Room:
 3     def __init__(self,name,owner,width,length,high):
 4         self.name=name
 5         self.owner=owner
 6         self.__width=width
 7         self.__length=length
 8         self.__high=high
 9     def tell_area(self): #对外提供的接口,隐藏了内部的实现细节,此时我们想求的是面积
10         return self.__width * self.__length
11 
12 
13 #使用者
14 >>> r1=Room(卧室,egon,20,20,20)
15 >>> r1.tell_area() #使用者调用接口tell_area
16 
17 
18 #类的设计者,轻松的扩展了功能,而类的使用者完全不需要改变自己的代码
19 class Room:
20     def __init__(self,name,owner,width,length,high):
21         self.name=name
22         self.owner=owner
23         self.__width=width
24         self.__length=length
25         self.__high=high
26     def tell_area(self): #对外提供的接口,隐藏内部实现,此时我们想求的是体积,内部逻辑变了,只需求修该下列一行就可以很简答的实现,而且外部调用感知不到,仍然使用该方法,但是功能已经变了
27         return self.__width * self.__length * self.__high
28 
29 
30 #对于仍然在使用tell_area接口的人来说,根本无需改动自己的代码,就可以用上新功能
31 >>> r1.tell_area()
View Code

 5、类中定义的函数分成两大类

一:绑定方法(绑定给谁,谁来调用就自动将它本身当作第一个参数传入):

    1. 绑定到类的方法:用classmethod装饰器装饰的方法。

                为类量身定制

                类.boud_method(),自动将类当作第一个参数传入

              (其实对象也可调用,但仍将类当作第一个参数传入)

    2. 绑定到对象的方法:没有被任何装饰器装饰的方法。

               为对象量身定制

               对象.boud_method(),自动将对象当作第一个参数传入

             (属于类的函数,类可以调用,但是必须按照函数的规则来,没有自动传值那么一说)

二:非绑定方法:用staticmethod装饰器装饰的方法

        1. 不与类或对象绑定,类和对象都可以调用,但是没有自动传值那么一说。就是一个普通工具而已

    注意:与绑定到对象方法区分开,在类中直接定义的函数,没有被任何装饰器装饰的,都是绑定到对象的方法,可不是普通函数,对象调用该方法会自动传值,而staticmethod装饰的方法,不管谁来调用,都没有自动传值一说

技术分享图片
 1 class mysql:
 2     def __init__(self, ip, port, net):
 3         self.uid = self.create_uid()
 4         self.ip = ip
 5         self.port = port
 6         self.net = net
 7 
 8     def tell_info(self):
 9         print(%s:%s % (self.ip, self.port))
10 
11     @classmethod
12     def from_conf(cls):
13         return cls(settings.IP, settings.NET, settings.PORT)
14 
15     @staticmethod
16     def func(x, y):
17         print(不与任何人绑定)
18 
19     @staticmethod
20     def create_uid():
21         return uuid.uuid1()
22 
23 
24 # 默认的实例化方式:类名(..)
25 obj=Mysql(10.10.0.9,3307,27)
26 obj.tell_info()
27 
28 # 一种新的实例化方式:从配置文件中读取配置完成实例化
29 obj1 = Mysql.from_conf()
30 obj1.tell_info()
classmethod绑定类的用法——一般用来读取配置中的配置

在类内部用staticmethod装饰的函数即非绑定方法,就是普通函数

statimethod不与类或对象绑定,谁都可以调用,没有自动传值效果

技术分享图片
 1 import hashlib
 2 import time
 3 class MySQL:
 4     def __init__(self,host,port):
 5         self.id=self.create_id()
 6         self.host=host
 7         self.port=port
 8     @staticmethod
 9     def create_id(): #就是一个普通工具
10         m=hashlib.md5(str(time.time()).encode(utf-8))
11         return m.hexdigest()
12 
13 print(MySQL.create_id) #<function MySQL.create_id at 0x0000000001E6B9D8> #查看结果为普通函数
14 conn=MySQL(127.0.0.1,3306)
15 print(conn.create_id) #<function MySQL.create_id at 0x00000000026FB9D8> #查看结果为普通函数
非绑定函数

 

以上是关于day19-面向对象之封装property特性绑定与非绑定的主要内容,如果未能解决你的问题,请参考以下文章

day32--面向对象的程序设计之继承实现的原理(继承顺序)封装property

面向对象进阶2

day 封装,面向对象,@property @classmethod @staticmethod方法

day_25 面向对象

19.Python面向对象之:三大特性:继承,封装,多态。

oldboy 21th day. I love Python. 面向对象之封装, 多态, 继承 三大特性