Python面向对象三要素-封装(Encapsulation)

　　　　　　　　　　　　Python面向对象三要素-封装(Encapsulation)

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　作者：尹正杰

版权声明：原创作品，谢绝转载！否则将追究法律责任。

一.封装概述

　　将数据和操作组织到类中，即属性和方法
　　
　　将数据隐藏起来，给使用者提供操作(方法)。使用者通过操作就可以获取或者修改数据。getter和setter。
　　
　　通过访问控制，暴露适当的数据和操作给用户，该隐藏的隐藏起来，例如保护成员或私有成员。

二.类属性的访问控制 

1>.抛出问题

 #！/usr/bin/env python
 #_*_conding:utf-8_*_
 #@author :yinzhengjie
 #blog:http://www.cnblogs.com/yinzhengjie

 class Person:
     def __init__(self,name,age=18):
         self.name = name
         self.age = age

     def growup(self,i=1):
          if i > 0 and i < 150:  #控制逻辑
              self.age += i

 p1 = Person("jason")
 print(p1.age)

 p1.growup(20)           #在我们控制逻辑的范围内
 print(p1.age)

 p1.age = 9999           #直接修改对象的属性，超过了范围，并绕过了咱们控制逻辑，是不是很操蛋？Python提供了私有属性可以解决这个问题。
 print(p1.age)

 #以上代码输出结果如下:
 18
 38
 9999

2>.私有(Private)属性

 #！/usr/bin/env python
 #_*_conding:utf-8_*_
 #@author :yinzhengjie
 #blog:http://www.cnblogs.com/yinzhengjie

 class Person:
     def __init__(self,name,age=18):
         self.name = name
         """
             私有变量的本质: 类定义的时候，如果声明一个实例变量的时候，使用双下划线，Python解释器会将其改名，转换名称为"_类名__变量名"的名称，所以用原来的名字访问不到了。
         """
         self.__age = age            #使用双下划线开头的属性名，就是私有属性

     def growup(self,i=1):
          if i > 0 and i < 150:      #控制逻辑
              self.__age += i

     def getage(self):               #我们只对外提供访问"__age"的方法
         return self.__age

 p1 = Person("jason")
 print(p1.getage())
 print(p1.__dict__)

 p1.growup(120)
 print(p1.getage())

 print(Person.__dict__)
 print(p1.__dict__)

 #p1.__age == 9999                   #我们发现现在无法访问到"__age"这个属性啦，会抛出"AttributeError"异常
 p1._Person__age = 9999              #既然我们知道了私有变量的新名称，就可以直接从外部访问到，并修改它。因此尽管是私有属性我们依旧是可以对其进行更改,但建议大家不要去修改，因为这样就违背了私有变量但属性啦，但你如果一定要改的话你得知道去哪改哟。
 print(p1.getage())
 print(p1.__dict__)

 #以上代码输出结果如下:
 18
 {'name': 'jason', '_Person__age': 18}
 138
 {'__module__': '__main__', '__init__': <function Person.__init__ at 0x10075f950>, 'growup': <function Person.growup at 0x10075fae8>, 'getage': <function Person.getage at 0x10075fb70>, '__dict__': <attribute '__dict__' of 'Person' objects>, '__weakref__': <attribute '__weakref__' of 'Person' objects>, '__doc__': None}
 {'name': 'jason', '_Person__age': 138}
 9999
 {'name': 'jason', '_Person__age': 9999}

3>.保护(protected)属性

 #！/usr/bin/env python
 #_*_conding:utf-8_*_
 #@author :yinzhengjie
 #blog:http://www.cnblogs.com/yinzhengjie

 class Person:
     def __init__(self,name,age=18):
         self.name = name
         """
             在变量名前使用一个下划线，称为保护变量。
             可以看出，这个_age属性根本就没有改变名称，和普通的属性一样，解释器不做任何特殊处理。
             这只是开发者共同的约定，看见这种变量，就如同私有变量，不要直接使用。
         """
         self._age = age

 p1 = Person("jason")

 print(p1._age)
 print(p1.__dict__)              #

 #以上代码输出结果如下:
 18
 {'name': 'jason', '_age': 18}

4>.私有方法

 #！/usr/bin/env python
 #_*_conding:utf-8_*_
 #@author :yinzhengjie
 #blog:http://www.cnblogs.com/yinzhengjie

 """
 私有方法的本质
     单下划线的方法只是开发者之间的约定，解释器不做任何改变。
     双下划线的方法，是私有方法，解释器会改名，改名策略和私有变量相同， 即"_类名__方法名" 。
     方法变量都在类的 __dict__ 中可以找到。
 """
 class Person:
     def __init__(self, name, age=18):
         self.name = name
         self._age = age

     """
         参照保护变量、私有变量，使用单下划线、双下划线命名方法。
     """
     def _getname(self):
         return self.name

     def __getage(self):
         return self._age

 jason = Person('Jason')
 print(jason._getname())  # 没改名
 #print(jason.__getage()) # 无此属性
 print(jason.__dict__)
 print(jason.__class__.__dict__)
 print(jason._Person__getage()) # 改名了

 #以上代码执行结果如下:
 Jason
 {'name': 'Jason', '_age': 18}
 {'__module__': '__main__', '__init__': <function Person.__init__ at 0x10215f950>, '_getname': <function Person._getname at 0x10215fae8>, '_Person__getage': <function Person.__getage at 0x10215fb70>, '__dict__': <attribute '__dict__' of 'Person' objects>, '__weakref__': <attribute '__weakref__' of 'Person' objects>, '__doc__': None}
 18

5>.私有成员的总结

　　在Python中使用 _单下划线 或者 __ 双下划线来标识一个成员被保护或者被私有化隐藏起来。
　
　　但是，不管使用什么样的访问控制，都不能真正的阻止用户修改类的成员。Python中没有绝对的安全的保护成员或者私有成员。 

　　因此，前导的下划线只是一种警告或者提醒，请遵守这个约定。除非真有必要，不要修改或者使用保护成员或者私有成员，更不要修改它们。

三.补丁

　　可以通过修改或者替换类的成员。使用者调用的方式没有改变，但是，类提供的功能可能已经改变了。

　　猴子补丁(Monkey Patch): 
　　　　在运行时，对属性、方法、函数等进行动态替换。 
　　　　其目的往往是为了通过替换、修改来增强、扩展原有代码的能力。 
　　　　黑魔法，慎用。

 #！/usr/bin/env python
 #_*_conding:utf-8_*_
 #@author :yinzhengjie
 #blog:http://www.cnblogs.com/yinzhengjie

 class Person:
     def get_score(self):
         #模拟下面的字典是从数据库拿的某个学生成绩(基本是及格的不多呀)。
         ret = {"English":37,"Chinese":66,"History":52}
         return ret

test2.py

 #！/usr/bin/env python
 #_*_conding:utf-8_*_
 #@author :yinzhengjie
 #blog:http://www.cnblogs.com/yinzhengjie

 def get_score(self):
     return dict(name=self.__class__.__name__,English=98, Chinese=96, History=95)

test3.py

 #！/usr/bin/env python
 #_*_conding:utf-8_*_
 #@author :yinzhengjie
 #blog:http://www.cnblogs.com/yinzhengjie

 from test2 import Person
 from test3 import get_score

 def monkey_patch_for_Person():
     Person.get_score = get_score

 monkey_patch_for_Person()       #打补丁操作

 if __name__ == '__main__':
     print(Person().get_score())

 #以上代码输出结果如下:
 {'name': 'Person', 'English': 98, 'Chinese': 96, 'History': 95}

四.属性装饰器

一般好的设计是：
　　把实例的某些属性保护起来，不让外部直接访问，外部使用getter读取属性和setter方法设置属性。

1>.自定义getter和setter方法

 #！/usr/bin/env python
 #_*_coding:utf-8_*_
 #@author :yinzhengjie
 #blog:https://www.cnblogs.com/yinzhengjie
 #EMAIL:y1053419035@qq.com

 class Person:
     def __init__(self,name,age=18):
         self.name = name
         self.__age = age

     """
         我们自定义age和set_age方法操作属性，的确可以实现私有变量的管理。那有没有简单的方式呢？
     """
     def age(self):
         return self.__age

     def set_age(self,age):
         self.__age = age

 jason = Person("Jason")
 print(jason.age())

 jason.set_age(20)
 print(jason.age())

 #以上代码输出结果如下：
 18
 20

2>.property装饰器

 # ！/usr/bin/env python
 # _*_coding:utf-8_*_
 # @author :yinzhengjie
 # blog:https://www.cnblogs.com/yinzhengjie
 # EMAIL:y1053419035@qq.com

 class Person:
     def __init__(self, name, age=18):
         self.name = name
         self.__age = age

     """
         特别注意：
             使用property装饰器的时候这三个方法同名。
             property装饰器必须在前，setter，deleter装饰器在后。
             property装饰器能通过简单的方式，把对方法的操作变成对属性的访问，并起到了一定隐藏效果。

         property装饰器：
             后面跟的函数名是以后的属性名。它就是getter。这个必须有，有了它至少是只读属性。

         setter装饰器：
             与属性名同名，且接收2个参数，第一个self，第二个是将要赋值的值。有了它，属性可写。

         deleter装饰器：
             可以控制是否删除属性，很少用，咱们了解即可。
     """

     @property
     def age(self):
         return self.__age

     @age.setter
     def age(self, age):
         self.__age = age

     @age.deleter
     def age(self):
         del self.__age
         print("del")

 jason = Person("Jason")
 print(jason.age)

 jason.age += 10
 print(jason.age)

 del jason.age

 # 以上代码输出结果如下：
 18
 28
 del

 #！/usr/bin/env python
 #_*_coding:utf-8_*_
 #@author :yinzhengjie
 #blog:https://www.cnblogs.com/yinzhengjie
 #EMAIL:y1053419035@qq.com

 class Person:
     def __init__(self,name,age=18):
         self.name = name
         self.__age = age

     def getage(self):
         return self.__age

     def setage(self,age):
         self.__age =age

     def delage(self):
         del self.__age
         print("del")

     age = property(getage,setage,delage,"age property")

 jason = Person("Jason")
 print(jason.age)

 jason.age = 20
 print(jason.age)

 del jason.age

 #以上代码输出结果如下：
 18
 20
 del

property的另外一种写法（第二种写法）

 #！/usr/bin/env python
 #_*_coding:utf-8_*_
 #@author :yinzhengjie
 #blog:https://www.cnblogs.com/yinzhengjie
 #EMAIL:y1053419035@qq.com

 class Person:
     def __init__(self,name,age=18):
         self.name = name
         self.__age = age

     age = property(lambda self:self.__age)          #这种写法只能设置只读属性，无法让属性可写。

 jason = Person("Jason")
 print(jason.age)

 #以上代码输出结果如下：
 18

仅设置只读的装饰器

五.对象的销毁

 #！/usr/bin/env python
 #_*_coding:utf-8_*_
 #@author :yinzhengjie
 #blog:https://www.cnblogs.com/yinzhengjie
 #EMAIL:y1053419035@qq.com

 import time

 class Person:
     def __init__(self,name,age=18):
         self.name = name
         self.__age = age

     """
         类中可以定义"__del__"方法，称为析构函数(方法)。
         作用：销毁类的实例的时候调用，以释放占用资源。其中就放些清理资源的代码，比如释放连接。
         注意这个方法不能引起真正销毁，只是对象销毁的时候会自动调用它。

         由于Python实现了引用计数的垃圾回收机制，不能确定对象何时执行垃圾回收。
         我们可以使用del语句删除实例，引用计数减1。当引用计数为0时，会自动调用"__del__"方法。
         由于垃圾回收对象销毁时，才会真正清理对象，还会在回收对象之前自动调用"__del__"方法，除非你明确自己的目的，建议不要手动调用这个方法。
     """
     def __del__(self):
         print("delete {}".format(self.name))

 if __name__ == '__main__':
     jason = Person("Jason")
     jason.__del__()
     jason.__del__()
     jason.__del__()
     jason.__del__()
     print("=========start=========")
     jason2  = jason
     jason3 = jason2
     print(1,"del")
     del  jason
     time.sleep(2)

     print(2,"del")
     del jason2
     time.sleep(2)
     print("*" * 50)

     del jason3      #注释一下看看效果
     time.sleep(3)
     print("=========end========")

 #以上代码执行结果如下:
 delete Jason
 delete Jason
 delete Jason
 delete Jason
 =========start=========
 1 del
 2 del
 **************************************************
 delete Jason
 =========end========

六.方法重载(overload) 

　　其他面向对象的高级语言中，会有重载的概念。

　　所谓重载，就是同一个方法名，但是形式参数个数、类型不一样，就是同一个方法的重载。

　　Python没有重载!

　　Python不需要重载! Python中，方法(函数)定义中，形参非常灵活，不需要指定类型(就算指定了也只是一个说明而非约束)，参数个数也不固定(可变参数)。一个函数的定义可以实现很多种不同形式实参的调用。所以Python不需要方法的重载。

　　或者说Python语法本身就实现了其它语言的重载。