# 在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的形式访问到
        print(self.__N)
#A._A__是可以访问到的
# 这种，在外部是无法通过__x这个名字访问到的
a = A()
a.bar()
# print(a.__N)
print(a._A__N)
print(a.__dict__)

a.__Y = 1
print(a.__dict__)

# 在继承中父类如果不想让子类覆盖自己的方法，可以将方法定义
# 为私有的
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()

# 将fa定义成私有的即__fa
class A:
    def __fa(self):
        print('from A')
    def test(self):
        self.__fa()
        print(self.__fa)
class B(A):
    def __fa(self):
        print('from B')
b = B()
b.test()
# 我们可以来看一下执行过程，执行test-此时self为b对象-寻找__fa方法（前面我们说过，__fa会变成_A.__fa)-
# 首先咋B类中找，没有找到，-然后在父类A中寻找-执行

# 封装的真谛在于明确地区分内外，封装的属性可以直接在内部使用，而不能在外部直接使用，然而定义
# 属性的目的终归是要用，外部想要用类隐藏的属性，需要我们为其开辟接口，
# 1，封装数据,将数据隐藏起来不是目的，隐藏起来然后提供操作该数据的接口，然后我们可以在
#   接口上附加对返数据操作的限制，以此完成对数据属性的严格控制
#       类比于电脑上的各种配件，就是被封装的数据，我们可以通过操作来改变电脑硬件的配置，
#       例如我们要加一块内存条，只需要知道接口，频率等参数，而不用知道内存条是什么材质的，
#       也不用知道内存条内部颗粒的构成
class Teacher:
    def __init__(self,name,age):
        self.__name = name
        self.__age = age
        self.set_info(name,age)
    def tell_info(self):
        print('name:%s,age:%s' %(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
t = Teacher('wang',21)
t.tell_info()
t.set_info('cong',21)
t.tell_info()
# 2，封装方法：目的是隔离复杂度
#   就像我们玩电脑一样，我们不需要知道电脑的工作原理，只需要知道他是怎么用的就可以了