#内置函数
#@property(伪装)：将一个本意是属性的方法在调用时伪装成直接调用属性（方法名）的样子来调用此函数。
# class A:
# def __init__(self,r):
# self.r = r
# def area(self):
# return self.r**2
# print(A(5).area())#变成
# class A:
# def __init__(self,r):
# self.r = r
# @property
# def area(self):
# return self.r**2
# print(A(5).area)
#@被伪装后的方法名.setter : 可以限制给对象的属性赋值的数据类型。或是把伪装后的函数名变成可修改的，变的
# 更像对象的属性。
# class A:
# def __init__(self):
# self.__name = 'zhangsan'
# @property
# def name(self):
# return self.__name #把私有对象属性返回给调用者。
# @name.setter #name为被伪装之后
# def name(self,new): #必须同名函数。
# self.__name = new #改值或其他操作。
# b = A()
# print(b.name) #伪装后的调用。
# b.name = 'abc' #调用setter下面的函数，传入new
# print(b.name)
#@方法名.deleter
#所有借用操作系统的资源，在删除一个伪装或方法属性的变量前，一定要归还资源（f.close()）
# class Open:
# def __init__(self,path):
# self.f = open(path,'w')
# @property
# def write_in(self): #1
# self.f.write('xieru')
# @write_in.deleter #2
# def write_in(self): #3 1/2/3的名字必须一样。
# print('执行了删除函数')
# self.f.close() #先关闭文件（还回去）
# del self.f #再删除文件句柄
# b = Open('file.txt')
# b.write_in
# del b.write_in #触发了 @f.deleter
#@classmethod
#用类调用。 当类中的方法用不上self这个参数时，将self变成cls(类)，在外面直接用 类.方法名 调用即可。
# class A:
# @classmethod
# def func(cls):
# print('这个函数不需要self')
# A.func()
#@staticmethod
#用类调用。当类中的方法即用不上cls也用不上self时。相当于把一个外埠的函数放入类中使用。
# class A:
# @staticmethod
# def login(name):
# if name == 'alex':
# print('通过')
# A.login('alex')
内置函数
#封装
#私有静态属性：__静态属性 = 'aaa' #只能在类内部使用，外面无法获取。
# class A:
# __name = 'wangxiaoer' # 等同于 _A__name = 'wangxiaoer'
# print(__name) #内部使用
# print(__name) #无法获取
#私有对象属性。
# class A:
# def __init__(self,length):
# self.__length = length #只在类内部用来计算或其它操作，一般用来外部不需要获取这个属性值的情况
# def cal(self):
# return self.__length*2
# print(A(5).cal())
#私有方法： def __name(self): #1、某些方法不想让在外部被调用。比如：密码加密。
# 2、某些方法不需要在外部调用，没有用，没有意义。比如各个数据类型的内部操作方法。
# class A:
# def __getpwd(self):
# print('我是私有方法')
# def login(self): #login是可以在外面被调用的，在外面调用登陆方法
# self.__getpwd() #然后执行登陆函数中的getpwd方法。（属于在内部执行）
# A().login()
# A().__getpwd() #出错
#私有方法面试题
# class Role:
# def __init__(self): #子类中没有找到__init__方法，往父类中找。
# self.__func() #第三步，找到后往下执行。寻找__func方法，实则是查找_A__func方法
# def __func(self): #第五步，应该执行此函数（_A__func）
# print('我是父类中的方法')
# class Person(Role): #第二步，找到对应类，并找__init__方法。
# def __func(self): #第四步，先在自己类中找__func,发现是_B__func方法，不符合。
# print('我是子类中的方法')
# Person() #第一步：实例化一个对象
封装
#钻石继承（广度优先）
# A
# B(A) C(A)
# D(B,C) 查找顺序：D--->B-->C-->A
# class A:
# def func(self):
# print('in A') #4.A
# class B(A):
# def func(self):
# print('in B') #2.B
# super().func()
# class C(A): #3.C
# def func(self):
# print('in C')
# super().func()
# class D(B,C): #广度优先原则，B找完再找C，不直接找A
# def func(self):
# print('in D') #1.D
# super().func()
# D().func()
#第二种：（类似深度优先）
# E F
# B(E) C(F)
# D(B,C) #查找顺序：D-->B-->E-->C-->F (类似深度优先，以路径最短为主。)
# class E:pass
# def func(self):
# print('in E')
# class F:
# def func(self):
# print('in F')
# class B(E):pass
# # def func(self):
# # print('in B') #首先路线为D-->B-->E
# # super().func()
# class C(F):
# def func(self):
# print('in C') #如果B和E中都没有，则路线为D-->C-->F
# super().func()
# class D(B,C):
# def func(self):
# print('in D')
# super().func()
# D().func()
#第三种
# A
# E(A) F(A)
# B(E) C(F)
# D(B,C) 查找顺序：D-->B-->E-->C-->F-->A (找到E的时候不直接找A,因为还有另一条路线可以找到A）
#查看查找顺序的方法：类名.mro()
# print(D.mro())
#super()查找顺序与mro一致
#新式类：基于object的类，遵循广度优先原则。
#经典类：不基于object的类，遵循深度优先原则。
#py2中需要定义父类为object之后才能变成新式类。py3中默认最高层都是基于object的，所以全部都是新式类。