面向对象之封装 及@property装饰器使用

封装

1.封装的定义

	将复杂的丑陋的,隐私的细节隐藏到内部,对外提供简单的使用接口, 对外隐藏内部实现细节,并提供访问的接口;

2.封装的目的:

	 封装的目的: 面向对象的核心是对象二字,精髓在于整合,封装的目的其实就是把一堆数据属性和方法属性整合到对象中,我们可以把对象比喻成一个容器,其实就是为了把数据存入一个容器中。存的目的就是为了取的,那封装到对象中的好处就是可以通过 "对象.属性" 的方式把属性取出来。

3.封装的三种方式

	1.publish: 对所有人**公开权限**,在外部哪里都可以访问。

	2.protected: 这种只有在当前类,或者是继承它的 “**子类**” (派生类) 可以访问。

	3.private: 这种封装相当于**属性的私有化**,让任何人都不可以访问。但是python没有这种强	制限制的机制,只能通过访问限制机制去实现表面上的属性私有化

4.封装的优点

1.良好的封装能够减少耦合。

2.类内部的结构可以*修改。

3.可以对成员变量进行更精确的控制。

4.隐藏信息,实现细节。
# 不封装
def login(name, pwd, root):
if name == 'tank' and pwd == '123' and root == 'vip':
print('登录成功!')
else:
print('登录失败!') login('tank', '123', 'vip') # 封装
class User:
def __init__(self, name, pwd, root):
self.__name = name
self.__pwd = pwd
self.__root = root def change_pwd(self, new_pwd):
self.__pwd = new_pwd @property
def get_name(self):
return self.__name @property
def get_pwd(self):
return self.__pwd @property
def get_root(self):
return self.__root user_obj = User('tank', '123', 'vip') def login(obj):
if obj.get_name == 'nim' and obj.get_pwd == '123' and obj.get_root == 'vip':
print('登录成功!') else:
print('登录失败') user_obj.change_pwd('321')
login(user_obj)

5.访问限制(封装)

	隐藏对象的属性和实现细节,仅对外提供公共访问方式。
目的:
1.为了保证 关键数据的安全性
2.对外部隐藏实现细节,隔离复杂度

1)私有变量

#其实这仅仅这是一种变形操作
#类中所有双下划线开头的名称如__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,即双下划线开头的属性在继承给子类时,子类时无法覆盖的。

这种变形需要注意的问题是:

1.这种机制也并没有真正意义上限制我们从外部直接访问属性,知道了类名和属性名就可以拼出名字:_类名__属性,然后就可以访问了,如a._A__N

2.变形的过程只在类的内部生效,在定义后的赋值操作,不会变形

>>> a=A()
>>> a.__dict__
{'_A__X':10}
>>> a.__Y = 1
>>> a.__dict__
{'_A__X':10,'__Y':1}

面向对象之封装 及@property装饰器使用

2)私有方法

	在继承中,父类如果不想让子类覆盖自己的方法,可以将方法定义成私有的。
# 正常情况
class A:
def fa(self):
print('from A')
def test(self):
print(self) # <__main__.B object at 0x00000000023A6FD0>
self.fa() class B(A):
def fa(self):
print('from B') b=B()
b.test() # 把fa定义成私有的,即__fa
class A:
def __fa(self): #在定义时就变形为_A__fa
print('from A')
def test(self):
print(self) # <__main__.B object at 0x00000000023A6FD0>
self.__fa() #只会与自己所在的类为准,即调用_A__fa class B(A):
def __fa(self):
print('from B') b=B()
b.test()

示例1:

面向对象之封装 及@property装饰器使用

#222  我们通过对__id_number进行修改,来对比外部是否能对__开头的属性进行修改.# p.show_id()  #12312  内部值并没有发生变化,所以通过__开头进行封装,外部通过普通方法并不能对内部的值进行修改.

示例2:

  # 通过__方法名()的方式,将内部内部具体实现细节封装起来,只给外部暴露一个简单的开机(open函数)接口
class PC:
def __init__(self,price,color,kind):
self.color=color
self.price=price
self.kind=kind
def open(self):
print('接通电源')
self.__check_device()
print('载入内核')
print('初始化内核')
self.__start_service()
print('启动GUI')
self.__login() def __check_device(self):
print('检测硬件1')
print('检测硬件2')
print('检测硬件3')
print('检测硬件4')
def __start_service(self):
print('启动服务1')
print('启动服务2')
print('启动服务3')
def __login(self):
print('login..') pc=PC(6000,'white','lenvo')
pc.open()
'''
接通电源
检测硬件1
检测硬件2
检测硬件3
检测硬件4
载入内核
初始化内核
启动服务1
启动服务2
启动服务3
启动GUI
login.. '''

示例3:

# e.g.1
class Downloader:
def __init__(self,filename,url,buffer_size):
self.filename=filename
self.url=url
self.__buffer_size=buffer_size def start_download(self):
if self.__buffer_size<=1024*1024:
print('开始下载...')
else:
print('内存不足..') d=Downloader('葫芦娃','http://www.baidu.com',1024*1024) d.buffer_size=1024*1024*10 #类中__开头的属性无法直接访问,所以无法修改。
d.start_download()
'''
开始下载...
''' # e.g.2
class Downloader:
def __init__(self,filename,url,buffer_size):
self.filename=filename
self.url=url
self.__buffer_size=buffer_size def start_download(self):
if self.__buffer_size<=1024*1024:
print('开始下载...')
print('当前缓冲区大小为%s'%self.__buffer_size)
else:
print('内存不足..') def set_buffer_size(self,size):
self.__buffer_size=size
def get_buffer_size(self):
return self.__buffer_size d=Downloader('葫芦娃','http://www.baidu.com',1024*1024) #通过函数去修改内部封装的属性
d.set_buffer_size(1024*1024/2) #通过函数访问内部封装的属性
print(d.get_buffer_size())
d.start_download() '''
524288.0
开始下载...
当前缓冲区大小为524288.0
'''

示例4

class Foo:
__name = 'rose' # 变形成 _Foo__name
def __init__(self,sex):
self.__sex=sex @property
def __sing(self): # 变形成_Foo__sing,外部可以通过变形后的名字从外部直接访问。
print('我是隐藏属性,不懂其变形情况在外部是无法访问的!') f = Foo('male')
print(f._Foo__name)
f._Foo__sing '''
rose
我是隐藏属性,不懂其变形情况在外部是无法访问的! '''

@property 装饰器

	@property 用来装饰类内部的函数:@property使对象调用某个方法时,将对象.方法()变成对	象.方法得形式,使对象点函数(方法)看起来像是点普通的数据属性一样,使得调用方式一	致。切记:装饰过后的函数名后就不要再加括号啦!!!

@key.setter 该装饰器用在修改属性的方法上
@key.deleter 该装饰器用在删除属性的方法上 注意:key是被property装饰的方法的名称,也就是属性的名称 ;内部会创建一个对象 变量名称就是函数名称,所以在使用setter和deleter时 必须保证使用对象去调用方法,所以是 key.setter和key.deletter。

属性property底层实现

一个静态属性property本质就是实现了get,set,delete三种方法

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

示例1

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('tank')
# print(f.name)
# f.name = 10 # 抛出异常'TypeError: 10 must be str'
f.name = 'zhang'
print(f.__dict__) # {'_Foo__NAME': 'zhang'}
# del f.name #抛出异常'TypeError: Can not delete'

示例2

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) p1=People('egon',75,1.85)
print(p1.bmi) #直接实例对象 点 方法名称就可以了

示例3

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 # 删除商品原价
上一篇:windows平台下基于VisualStudio的Clang安装和配置


下一篇:erlang 虚机CPU 占用高排查