面向对象程序设计最主要的有三个特征：封装、继承、多态
本节内容主要讲解面向对象的第一个特征：封装
1 封装的意义
在我们程序开发过程中，定义好类型之后就可以通过类型来创建对象
如：我们定义一个中华人民共和国公民的类型
# 创建一个人的类型
class Person(object):
def __init__(name, age):
self.name = name
self.age = age
此时如果我们创建好对象之后，对对象的数据进行如下修改，大家是否认为合适呢？
# 创建一个人的对象
xiaoMing = Person("小明", 18)
# 修改属性
xiaoMing.age = 1000
我们会发现，上面的代码在运行时是正确的，也就是可以修改age属性为1000
此时我们需要明确一个概念：代码运行正确，但是不代表符合业务逻辑，这样的代码我们一般会说代码处理不合法！
2. 实现封装的过程
对于上面这样的问题，我们应该怎么处理呢
常规的方案就是：
- 定义一种这样的属性，属性只有在当前类的内部可以访问
- 类的外部不能访问这个属性，只能通过类提供的方法来进行属性的取值和赋值
- 在取值或者赋值的方法中，就可以添加一定的限制处理的代码了
python中，提供了这样的一种特殊的变量，变量名称使用两个下划线开头，这样的变量智能在类的内部访问，类的外部是访问不了的，我们称之为私有属性
# 定义类型
class Person(object):
def __init__(self, name, age):
self.__name = name;
self.age = age
# 创建对象
xiaoMing = Person("小明明", 18)
# 访问属性
print(xiaoMing.age)
~ 18，可以访问，age只是一个普通的成员属性
print(xiaoMing.__name)
~ 出现错误，AttributeError: 'Person' object has no attribute '__name'
这样我们就限制了变量的访问范围。
但是变量定义出来就是为了被访问和操作的，如果上述代码中的__name一旦限制了不让访问，就木有存在的价值了。所以，我们通过自定义的方法给__name属性添加访问控制
# 创建一个人的类型
class Person(object):
# 对象的初始化方法
def __init__(self, name):
# 初始化私有成员变量__name
self.__name = name
# 定义获取__name的函数
def get_name(self):
return self.__name
# 定义设置__name的函数
def set_name(self, name):
self.__name = name
# 根据类型创建对象
xiaoMing = Person("小明");
# 访问数据
xiaoMing.set_name("小明明");
print(xiaoMing.get_name())
# 执行结果：小明明
OK，通过以上对属性进行私有化（属性名称双下划线开头），给属性提供set/get的访问方法完成封装过程，此时就可以对本文开头的年龄设置问题进行一定的逻辑限制了
# 定义一个人的类型
class Person(object):
# 初始化变量
def __init__(self, name, age):
self.__name = name
if(age >= 0 and age <= 100):
self.__age = age
else:
age = 18
# 定义访问属性的get方法
def get_name(self):
return self.__name
def get_age(self):
return self.__age
# 定义访问属性的get方法
def set_name(self, name):
self.__name = name;
def set_age(self, age):
if(age >= 0 and age <= 100):
self.__age = age
else:
print("您设置的年龄不合法，还原默认值")
# 创建对象
p = Person("张小凡", 19)
p.set_age(1000)
print(p.get_age())
# 执行结果
~ 您设置的年龄不合法，还原默认值
~ 19
以上执行的结果，才是我们想要的结果
什么是封装
封装，就是将对象敏感的数据封装在类的内部，不让外界直接访问，但是提供了让外界可以间接访问的set/get方法，我们可以在set/get方法中添加数据的访问限制逻辑，完善我们的代码，提高程序的健壮性
3. 封装的高级使用方式
我们从上面的代码中已经看到了，可以通过函数操作的形式来进行属性的处理
但是某些情况下，函数操作的形式并不是特别美妙，我们突发奇想~想再提供了set/get访问方法的情况下，对属性的操作还能像以前那样直接赋值或者取值进行操作
# 封装以后通过函数操作的方式
p.set_name("tom")
print(p.get_name())
# 封装以前通过属性直接操作的方式
p.name = "tom"
print(p.name)
将类中的set/get方法操作的形式，转换成属性直接操作的形式，python中是可以的
首先：给get方法上添加@property注解，（关于注解的东东，之前的函数装饰器章节中已经有使用，可以参考一下操作原理），就可以让get方法当成属性进行直接取值操作了
其次，@property同时它会自动生成一个@get方法名称.setter注解，将@get方法名称.setter注解写在set方法上，就可以让set方法进行直接赋值操作了，代码如下：
class Person(object):
def __init__(self, name):
self.__name = name;
@property
def get_name(self):
return self.__name
@get_name.setter
def set_name(self, name):
self.__name = name
# 创建对象
p = Person("tom")
print(p.get_name)
p.set_name = "jerry"
print(p.get_name)
# 执行结果
~ tom
~ jerry
上述代码我们可以看出来，set/get方法已经可以当成普通的属性取值赋值的方式进行快捷的操作了，我们继续改造一下上述代码，让set/get更加符合属性取值赋值的方式
class Person(object):
def __init__(self, name):
self.__name = name;
@property
def name(self):
return self.__name
@name.setter
def name(self, name):
self.__name = name
# 创建对象
p = Person("tom")
print(p.name)
p.name= "jerry"
print(p.name)
# 执行结果
~ tom
~ jerry
此时，你还能在不看原来类型定义中的get/set，区分出来name是否是Person类型的属性还是方法呢？
封装的注解方式，在一定程度上，能隐藏我们方法在底层的实现，让调用者的操作变得简单。但是同时也降低了代码的可读性，后续的操作中，我们还是遵循原来封装的操作方案将类的属性私有化，提供set/get方法进行属性的操作。
