面向对象初始二---私有共有/魔术方法

1. 类的私有成员介绍

1.1 对于每一个类的成员而言都有两种形式：

• 公有成员，在任何地方都能访问
• 私有成员，只有在类的内部才能方法

2 私有成员和公有成员：

2.1 静态字段(静态属性)访问限制

• 公有静态字段：类可以访问；类内部可以访问；派生类中可以访问
• 私有静态字段：仅类内部可以访问；

2.2.1 公有静态属性(静态字段)

class C:
    name = "公有静态字段"
    def func(self):
        print C.name
class D(C):
    def show(self):
        print C.name
C.name         # 类访问
obj = C()
obj.func()     # 类内部可以访问
obj_son = D()
obj_son.show() # 派生类中可以访问
公有静态字段

2.2.2 私有静态属性(静态字段)

class C:
    __name = "私有静态字段"
    def func(self):
        print C.__name
class D(C):
    def show(self):
        print C.__name
C.__name       # 不可在外部访问
obj = C()
obj.__name  # 不可在外部访问
obj.func()     # 类内部可以访问
obj_son = D()
obj_son.show() #不可在派生类中可以访问
私有静态字段

2.2  类变量(对象属性)访问限制

• 公有普通字段：对象可以访问；类内部可以访问；派生类中可以访问
• 私有普通字段：仅类内部可以访问；

2.2.1 公有类变量(字段)

class C:
    def __init__(self):
        self.foo = "公有字段"
    def func(self):
        print self.foo 　#　类内部访问
class D(C):
    def show(self):
        print self.foo　＃　派生类中访问
obj = C()
obj.foo     # 通过对象访问
obj.func()  # 类内部访问
obj_son = D();
obj_son.show()  # 派生类中访问

2.2.2 私有对象属性

class C:
    def __init__(self):
        self.__foo = "私有字段"
    def func(self):
        print self.foo 　#　类内部访问
class D(C):
    def show(self):
        print self.foo　＃　派生类中访问
obj = C()
obj.__foo     # 通过对象访问    ==> 错误
obj.func()  # 类内部访问        ==> 正确
obj_son = D();
obj_son.show()  # 派生类中访问  ==> 错误
私有普通字段

2.3 方法:

公有方法:对象可以访问；类内部可以访问；派生类中可以访问
私有方法:仅类内部可以访问；

2.3.1 公有方法

class C:
    def __init__(self):
        pass
    def add(self):
        print('in C')
class D(C):
    def show(self):
        print('in D')
    def func(self):
        self.show()
obj = D()
obj.show()  # 通过对象访问
obj.func()  # 类内部访问
obj.add()  # 派生类中访问

2.3.2 私有方法

class C:
    def __init__(self):
        pass
    def __add(self):
        print('in C')
class D(C):
    def __show(self):
        print('in D')
    def func(self):
        self.__show()
obj = D()
obj.__show()  # 通过不能对象访问
obj.func()  # 类内部可以访问
obj.__add()  # 派生类中不能访问
aob._C.__add() # 特殊情况下访问

3. 私有属性/方法，强制访问

属性：对象._类名.__属性

方法：对象._类名.__方法

案例

aob._C.__add() # 特殊情况下访问

4. 属性property

4.1 什么是特性property

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

例一：BMI指数（bmi是计算而来的，但很明显它听起来像是一个属性而非方法，如果我们将其做成一个属性，更便于理解）
成人的BMI数值：
过轻：低于18.5
正常：18.5-23.9
过重：24-27
肥胖：28-32
非常肥胖, 高于32
　　体质指数（BMI）=体重（kg）÷身高^2（m）
　　EX：70kg÷（1.75×1.75）=22.86

4.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)

4.3 为什么要用property

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

由于新式类中具有三种访问方式，我们可以根据他们几个属性的访问特点，分别将三个方法定义为对同一个属性：获取、修改、删除

class Foo:
    @property
    def AAA(self):
        print('get的时候运行我啊')
    @AAA.setter
    def AAA(self,value):
        print('set的时候运行我啊')
    @AAA.deleter
    def AAA(self):
        print('delete的时候运行我啊')
#只有在属性AAA定义property后才能定义AAA.setter,AAA.deleter
f1=Foo()
f1.AAA
f1.AAA='aaa'
del f1.AAA
或者：
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