一、封装的意义

封装不是单纯意义的隐藏

1.封装数据

主要原因是：保护私隐，明确区分内外。将数据隐藏起来这不是目的。隐藏起来然后对外提供操作该数据的接口，然后我们可以在接口附加上对该数据操作的限制，以此完成对数据属性操作的严格控制。

class Teacher:

def __init__(self, name, age):

self.__name = name

self.__age = age

def tell_info(self):

print('Name:%s Age:%d' % (self.__name, self.__age))

def set_info(self, name, age):

if not isinstance(name, str):

raise TypeError("名字必须是字符串")

if not isinstance(age, int):

raise TypeError("年龄必须是整数")

self.__name = name

self.__age = age

teacher = Teacher('A', 30)

teacher.tell_info()

teacher.set_info('A', 29)

teacher.tell_info()

2.封装方法

目的是隔离复杂度

在编程语言里，对外提供的接口(接口可理解为了一个入口)，可以是函数，称为接口函数，这与接口的概念还不一样，接口代表一组接口函数的集合体。

class ATM:

def __card(self):

print('插卡')

def __auth(self):

print('用户认证')

def __input(self):

print('输入取款金额')

def __print_bill(self):

print('打印账单')

def __take_money(self):

print('取款')

def withdraw(self):

self.__card()

self.__auth()

self.__input()

self.__print_bill()

self.__take_money()

a = ATM()

a.withdraw()

二、封装例子

1.私有变量

在python中用双下划线开头的方式将属性隐藏起来(设置成私有的)

__名字，这种语法，只在定义的时候才会有变形的效果，如果类或者对象已经产生了，就不会有变形效果

class A:

__x = 1 # 在属性前面加两个下划线，表示对该属性进行隐藏，设置成私有，在内部都会变成成：_类名.__x

def __test(self): # 这里在内部会变形：_A__test，调用的时候a._A__test()

print('from A')

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()

print(a._A__x)

a._A__test() # 不建议在外部直接通过这种方式调用隐藏方法

2.私有方法

# 正常情况

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() # b.test ---> B ---> A ---> b.fa() ---> b 是 B 的对象，在 B 里找 fa

from B

# 知识点：在继承中，父类如果不想让子类覆盖自己的方法，可以将方法定义为私有的

# __名字，在定义节点就已经变形了，变成 _类名__属性

class A:

def __fa(self): # 在定义时就变形为_A__fa

print('from A')

def test(self):

self.__fa() # 只会与自己所在的类为准，即调用_A__fa

class B(A):

def __fa(self): # 变形：_B__fa

print('from B')

b = B()

b.test() # b.test ---> B没有 ---> 找A的test ---> b.fa() ---> b._A__fa 找的A的 __fa

from A

这种自动变形的特点：

1.类中定义的__x只能在内部使用，如self.__x，引用的就是变形的结果。

2.这种变形其实正是针对外部的变形，在外部是无法通过__x这个名字访问到的。

3.在子类定义的__x不会覆盖在父类定义的__x，因为子类中变形成了：_子类名__x,而父类中变形成了：_父类名__x，即双下滑线开头的属性在继承给子类时，子类是无法覆盖的。

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

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

2.变形的过程只在类的定义是发生一次,在定义后的赋值操作，不会变形

三、封装特性

1.什么是特性property

property是一种特殊的属性，访问它时会执行一段功能(函数)然后返回值

2.为什么要用property

将一个类的函数定义成特性以后，对象再去使用的时候obj. name,根本无法察觉自己的name是执行了一个函数然后计算出来的，这种特性的使用方式遵循了统一访问的原则

# 圆周率的例子

import math

class Circle: # 圆周率

def __init__(self, radius): # 圆的半径

self.radius = radius

@property # area=property(area)

def area(self):

return math.pi * self.radius**2 # 计算圆的面积

@property

def perimeter(self):

return 2*math.pi*self.radius # 计算周长

c = Circle(7)

print(c.area) # 伪装成数据属性，如果不加 property 的话，调用的时候变成 c.area()，一个函数属性

'''

property 简单来说就把类里的函数属性伪装成一个数据属性，使用者用起来感觉不到自己用的其实一个函数

#注意：此时的特性arear和perimeter不能被赋值，因为实质上是一个函数属性

c.area=3 #为特性area赋值

抛出异常:

AttributeError: can't set attribute

'''

class People:

def __init__(self, name, SEX):

self.name = name

# self.__sex = SEX # 性别隐藏起来不让人知道

self.sex = SEX # # p2.sex=male 一初始化或赋值操作就找 sex.setter

@property # 负责查询

def sex(self): # 通过接口可以查看隐藏的性别

return self.__sex # p2.__sex = male

@sex.setter # 定义修改性别的接口

def sex(self, value):

sexes = ['male', 'female']

if not isinstance(value, str): # 在设定值之前进行类型检查，增加限制的扩展性

raise TypeError('性别必须是字符串类型')

if value not in sexes:

raise TypeError('性别只能是 male 或者 female')

self.__sex = value # p2.__sex = male

@sex.deleter

def sex(self): # 删除属性接口

del self.__sex # del p2.__sex

p2 = People('alex', 'male') # 触发 init 执行，这里有个赋值操作 p2.sex='male'

print(p2.sex)

# p2.sex ='female3'

# print(p2.sex)

del p2.sex # 删掉 __sex 数据属性

# print(p2.sex) # 再去 property 找的话找不到了

被 property 装饰的属性会优先于对象的属性被使用，被找到；而被 property装饰的属性，如 sex ，分成三种

property 查询

sex.setter 赋值，修改

sex.deleter 删除

如果对象要修改数据属性的时候，在没有 property 的情况下，可以随便改，但是加了之后，就可以有一个扩展性，限制对象只能改什么。