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

目录

• 封装
  • 1.封装的定义
  • 2.封装的目的:
  • 3.封装的三种方式
  • 4.封装的优点
  • 5.访问限制（封装）
    • 1）私有变量
    • 2)私有方法
• @property 装饰器
  • 属性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}

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:

#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     # 删除商品原价