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()

 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> #查看结果为普通函数

非绑定函数

原文地址：https://www.cnblogs.com/wcl0517/p/9239246.html