一、面向对象之封装
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()
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 特性可以去掉（）后直接调用函数得到返回值
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'
封装的好处
封装在于明确区分内外，使得类实现者可以修改封装内的东西而不影响外部调用者的代码；而外部使用用者只知道一个接口(函数)，只要接口（函数）名、参数不变，使用者的代码永远无需改变。这就提供一个良好的合作基础——或者说，只要接口这个基础约定不变，则代码改变不足为虑。
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()
在类内部用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> #查看结果为普通函数