python面向对象-封装

# 在python中采取__（双下划线）开头的方式将属性隐藏起来：
#其实这是一种变形操作
#类中所有双下划线开头的名称如：__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.这种机制并没有真正从外部限制我们直接访问属性，知道了类型和属性名，我们就可以通过_类名__属性名，就可以访问了
class S:
    __x=1
a=S()
print(a._S__x)   #我们只要知道了类名和属性名，依然可以直接访问类里面的属性。
# 2.变形过程只在类的定义过程发生，在定义的赋值操作不会发生变形
S.__b=2
print(S.__dict__)
print(S.__b)   # 定义之后的赋值操作不会发生变形
# 3.在继承中，父类如果不想让子类覆盖自己的方法，可以将方法定义为私有。
class cc:
    def foo(self):
        print('from cc foo')
    def func(self):
        print('from cc func')
        self.foo()

class gg(cc):
    def foo(self):
        print('from gg foo')
# 
a=gg()
a.foo()  # 会先从a里面找foo，没有的化从gg里面找foo，最后才会在cc里面找foo
# >>>from gg foo
# a.func()   #先从a里面找func，没有再进gg里找func，没有再进cc里找func，找到之后func下面有个self.foo()，self是调用者本身就是
            # 相当于 a.foo()， 然后就从新进入a里找foo，再进入gg里找foo，找到了 就不会再进cc里找foo。这就是覆盖
# >>>from cc func
# >>>from gg foo
# 如何做才能不让父类被子类覆盖：
class cc:
    def __foo(self):        #相当于 _cc__foo
        print('from cc foo')
    def func(self):
        print('from cc func')
        self.__foo()       # 相当于 self._cc__foo

class gg(cc):
    def __foo(self):       #相当于 _gg__foo
        print('from gg foo')

# c=gg()
# c.func()
# >>>from cc func
# >>>from cc foo
# 这时候的路径就是：从c里找func，没找到进gg里找func，没找到进cc里找func，找到后执行func，func内又有self.__foo()
#此时的sele.__foo() 相当于 self._cc__foo, 相当于c._cc__foo, 所