封装
封装
封装
广义上的封装 : 属于一个类的静态和动态属性 总是出现在一个类中
使用的使用永远用类名或者对象名调用
狭义上的封装 : 就是把变量\方法私有化,在类的外部以及子类中不能直接使用了
隐藏对象的属性和实现细节，仅对外提供公共访问方式。
class A: STATIC = 'aaa' # 静态变量 __S = 'bbb' # 私有的静态变量 def wahaha(self): print(A.__S) #内部转化 _A__S print(A.STATIC)#类名调用静态属性 print(A.__dict__)#显示A类中的存储的字典 print(A._A__S) # 在类的外面调用私有的变量 a = A()#创建对象 a.wahaha()#实例化 A.__B = 'ccc' #在类的外部添加了一个静态变量，并不是添加一个类的私有静态属性 print(A.__dict__) #我们不能在一个类的外部创建一个"私有的"变量 print(A.__B)#打印c出来只是A的一个静态属性
class B: def __init__(self,name,pwd): self.name = name self.__pwd = pwd # 也可以创建对象的私有属性，因为__pwd会自动转化成_B__pwd def qqxing(self): self.__a = 'A' # 自动转化_B__a def get_pwd(self): print(self.__pwd) b = B('alex','Alex3714') b.qqxing() print(b.name)#打印类的.name方法 print(b._B__pwd) # 当在类外部的时候,我们也不能直接使用对象的私有属性 b.get_pwd()#获取pwd
class C: def __ppt(self): # 私有的方法 print('ppt') self.age = 83 def open(self):#open方法 self.__ppt print('打开文件') c = C() c._C__ppt() # 不能直接调用 c.open()#使用对象中的函数方法 c.name = 'Alex'#添加一个对象的静态变量 print(c.name)#打印实例的静态变量
私有de 静态变量 对象属性 方法
私有的 只能在类的内部定义和使用
__名字
在类外部使用私有静态变量 _类名__私有的名字
私有的名字 不能被子类继承java
# private 私有的 - __变量名
# protect 保护的 - N/A
# public 公共的 - 正常的变量
【好处】
1. 将变化隔离；
2. 便于使用；
3. 提高复用性；
4. 提高安全性；
【封装原则】
1. 将不需要对外提供的内容都隐藏起来；
2. 把属性都隐藏，提供公共方法对其访问。
私有变量和私有方法
在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是可以访问到的，即这种操作并不是严格意义上的限制外部访问，仅仅只是一种语法意义上的变形
这种自动变形的特点：
1.类中定义的__x只能在内部使用，如self.__x，引用的就是变形的结果。
2.这种变形其实正是针对外部的变形，在外部是无法通过__x这个名字访问到的。
3.在子类定义的__x不会覆盖在父类定义的__x，因为子类中变形成了：_子类名__x,而父类中变形成了：_父类名__x，即双下滑线开头的属性在继承给子类时，子类是无法覆盖的。
class D: __DDD = 'ddd' # 私有静态属性_D__DDD AAA = 'aaa' #静态属性 class E(D):#继承父类属性 def qqxing(self):#对象函数 print(E.AAA) #调用父类静态属性 print(E.__DDD) #无法被调用因为会变形成E._E__DDD e = E()#对象实例化 e.qqxing()#调用对象函数
这种变形需要注意的问题是：
1.这种机制也并没有真正意义上限制我们从外部直接访问属性，知道了类名和属性名就可以拼出名字：_类名__属性，然后就可以访问了，如a._A__N
2.变形的过程只在类的内部生效,在定义后的赋值操作，不会变形
私有方法
3.在继承中，父类如果不想让子类覆盖自己的方法，可以将方法定义为私有的
#正常情况 >>> 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
封装与扩展性
封装在于明确区分内外，使得类实现者可以修改封装内的东西而不影响外部调用者的代码；而外部使用用者只知道一个接口(函数)，只要接口（函数）名、参数不变，使用者的代码永远无需改变。这就提供一个良好的合作基础——或者说，只要接口这个基础约定不变，则代码改变不足为虑。
#类的设计者 class Room: def __init__(self,name,owner,width,length,high): self.name=name self.owner=owner self.__width=width self.__length=length self.__high=high def tell_area(self): #对外提供的接口，隐藏了内部的实现细节，此时我们想求的是面积 return self.__width * self.__length #使用者 >>> r1=Room('卧室','egon',20,20,20) >>> r1.tell_area() #使用者调用接口tell_area #类的设计者，轻松的扩展了功能，而类的使用者完全不需要改变自己的代码 class Room: def __init__(self,name,owner,width,length,high): self.name=name self.owner=owner self.__width=width self.__length=length self.__high=high def tell_area(self): #对外提供的接口，隐藏内部实现，此时我们想求的是体积,内部逻辑变了,只需求修该下列一行就可以很简答的实现,而且外部调用感知不到,仍然使用该方法，但是功能已经变了 return self.__width * self.__length * self.__high #对于仍然在使用tell_area接口的人来说，根本无需改动自己的代码，就可以用上新功能 >>> r1.tell_area()
#房间类 : 所有人 价格 面积 class Room:#定义房间类 def __init__(self,owner,price,length,width,height):#动态属性 self.owner = owner#类的属性 self.__price_single = price #单价私有属性 self.__length = length#长度私有属性 self.__width = width#长度私有属性 self.height = height#高度属性 def get_area(self):#面积方法 return self.__length * self.__width def get_price(self):#价格方法 return self.__price_single * self.get_area() alex = Room('alex',1000000,2,1,0.8)#实例化 print(alex.get_area())#打印面积 print(alex.get_price())#打印价格
property属性
什么是特性property
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 类 能够计算人体的BMI指数 class Person: def __init__(self,name,height,weight): self.name = name self.__height = height#私有身高 self.__weight = weight#私有质量 @property #将一个方法伪装成属性property财产 def bmi(self): return self.__weight / (self.__height**2) wang = Person('王子',1.77,69) print(wang.bmi)
圆形类 : r 面积area 周长perimeter from math import pi class Circle: def __init__(self,r): self.r = r @property#转换成属性的装饰器 def area(self): return self.r*self.r*pi @property#方法转换成属性的装饰器 def perimeter(self): return 2*pi*self.r c = Circle(10) print(c.area) print(c.perimeter)
#注意：此时的特性area和perimeter不能被赋值 c.area=3 #为特性area赋值 ''' 抛出异常: AttributeError: can't set attribute '''
为什么要用property
将一个类的函数定义成特性以后，对象再去使用的时候obj.name,根本无法察觉自己的name是执行了一个函数然后计算出来的，这种特性的使用方式遵循了统一访问的原则
除此之外，看下
ps：面向对象的封装有三种方式:
【public】
这种其实就是不封装,是对外公开的
【protected】
这种封装方式对外不公开,但对朋友(friend)或者子类(形象的说法是“儿子”,但我不知道为什么大家 不说“女儿”,就像“parent”本来是“父母”的意思,但中文都是叫“父类”)公开
【private】
这种封装对谁都不公开
python并没有在语法上把它们三个内建到自己的class机制中，在C++里一般会将所有的所有的数据都设置为私有的，然后提供set和get方法（接口）去设置和获取，在python中通过property方法可以实现
class Foo: def __init__(self,name): self.__name = name#私有属性 @property def name(self):#函数转化成一个私有属性 return self.__name @name.setter def name(self,new_name): if type(new_name) == str: self.__name = new_name alex = Foo('alex') print(alex.name) alex.name = 123 # 为了迎合属性的设置方式 print(alex.name)
class Foo: def __init__(self,val): self.__NAME=val #将所有的数据属性都隐藏起来 @property#将方法伪装成特性 def name(self): return self.__NAME #obj.name访问的是self.__NAME(这也是真实值的存放位置) @name.setter def name(self,value): if not isinstance(value,str): #在设定值之前进行类型检查 raise TypeError('%s must be str' %value) self.__NAME=value #通过类型检查后,将值value存放到真实的位置self.__NAME @name.deleter def name(self): raise TypeError('Can not delete') f=Foo('egon') print(f.name) # f.name=10 #抛出异常'TypeError: 10 must be str' del f.name #抛出异常'TypeError: Can not delete'
一个静态属性property本质就是实现了get，set，delete三种方法
class Foo: @property def AAA(self): print('get的时候运行我啊') @AAA.setter def AAA(self,value): print('set的时候运行我啊') @AAA.deleter def AAA(self): print('delete的时候运行我啊') #只有在属性AAA定义property后才能定义AAA.setter,AAA.deleter f1=Foo() f1.AAA f1.AAA='aaa' del f1.AAA
class Foo: def get_AAA(self): print('get的时候运行我啊') def set_AAA(self,value): print('set的时候运行我啊') def delete_AAA(self): print('delete的时候运行我啊') AAA=property(get_AAA,set_AAA,delete_AAA) #内置property三个参数与get,set,delete一一对应 f1=Foo() f1.AAA f1.AAA='aaa' del f1.AAA
怎么用？
class Goods: def __init__(self): # 原价 self.original_price = 100 # 折扣 self.discount = 0.8 @property def price(self): # 实际价格 = 原价 * 折扣 new_price = self.original_price * self.discount return new_price @price.setter def price(self, value): self.original_price = value @price.deleter def price(self): del self.original_price obj = Goods() obj.price # 获取商品价格 obj.price = 200 # 修改商品原价 print(obj.price) del obj.price # 删除商品原价
classmethod：
将一个普通方法装饰为一个类方法
class Goods: __discount = 0.8 def __init__(self,name,price): self.name = name self.__price = price @property def price(self): return self.__price*Goods.__discount @classmethod #将一个普通方法装饰为一个类方法 def change_discount(cls,new_dis): # 类方法 cls.__discount = new_dis Goods.change_discount(2)#定义了Good的一个静态属性 cig = Goods('cigrette',20) print(cig.price)#40 20*2 cig.change_discount(0.2) print(cig.price)#4.0 20*0.2 cig.change_discount(1) print(cig.price)#20 *1 #类方法是被@classmethod装饰的特殊方法 #被装饰之后,方法默认接收一个 类 作为参数 # 之后所有的操作都只能和 类中的静态变量相关 而不应该和对象相关 # 类名 和 对象名 都可以直接调用类方法
staticmethod：
外部函数可以直接类名+函数名使用内部函数
class Student: def __init__(self,name): self.name = name @staticmethod #装饰一个不需要self参数 也不需要cls参数的函数 def login(a,b,c): # 普通的函数 usr = input('username>>>') pwd = input('password>>>') if usr == 'alex' and pwd == '123': obj = Student(usr) return obj # 学生 login # 用户名 密码 属性 ret = Student.login(1,2,3)#外部函数可以直接类名+函数名使用内部函数 print(ret)
