大纲分析 # 面向对象 # 类 ：一类具有相同属性和方法的事物     #类的定义：class     #类中可以定义的方法种类：         #普通方法 self                   对象         #类方法   cls   @classmethod     类/对象         #静态方法       @staticmethod    类/对象         #属性方法 self  @property        对象         #私有方法 self  __方法名         self/cls     #类中可以定义的属性: 静态属性        类 # 对象     #实例化 ： 类名()             #创造对象             #初始化对象  __init__             #返回一个对象     #对象的属性：             # 普通属性            对象             # 私有属性  __属性名  self     #属性的操作             #增 对象名.新属性名 = 值             #删 del 对象名.属性名             #改 对象名.属性名 = 新值             #查 对象名.属性名 #组合 ： 一个类的对象作为另一个类对象的属性；什么有什么 #继承 ： 解决代码的复用，提取公共代码到父类；什么是什么     # 单继承和多继承     # 子类继承了父类除了私有的之外的所有属性和方法     # 子类执行方法的查找顺序：         # 经典类中：先找自己，自己没有找父类，遵循深度优先         # 新式类中：先找自己，自己没有找父类，遵循广度优先     # 子类执行父类的方法：         #1.指名道姓 指到谁就是谁  父类名.父类中的方法名(self)         #2.super 只能在新式类中使用，且找的顺序是mro顺序 super(子类名，子类对象名).方法名()     # *** 抽象类和接口类         #@abstractmethod #多态     # python 天生多态     #崇尚鸭子类型 ： 不需要通过继承关系就实现对相似的功能

# 封装 # 【封装原则】 # 1. 将不需要对外提供的内容都隐藏起来； # 2. 把属性都隐藏，提供公共方法对其访问。 # 私有变量和私有方法 # 在python中用双下划线开头的方式将属性隐藏起来（设置成私有的） # 针对变量属性x （静态或者动态 ）   __x 相当于 _类名__x # 封装 :把一些属性和方法放到类里 这本身就是一种封装     # 封装 ： 把属性和方法藏在类里 我只能在类内部调用，不能再外部使用 #1 私有属性之一  私有的对象属性 # class Room: #     def __init__(self,name,price,length,width): #         self.name = name #         self.price = price #         self.__length =length  #私有的对象属性 #         self.__width = width # #     def area(self): #         return self.__length*self.__width # # house = Room('小超超',1000000,2,1) # print(house.area()) # 私有属性能不能继承  不能继承 因为上级的 _A__func   这一级 是 _B__FUNC # 定义一个私有变量\属性\方法 ： __名字 #在类的内部可以直接用 : __名字 #在类的外部不能直接使用，如果一定要用，在私有方法之前加上：_类名,变成 _类名__名字 #在类外的名字 通过__dict__就可以查看不建议 # class A: #     def func(self):      # fun() #         print('__a_func') # # class B(A): #     def __init__(self): #         self.func()        # func() #         print(11) # b = B() # __a_func # 11 # 这样的情况 self.func() 变成  b.func()  被A  func（b）调用  继承了A 先打印 后打印11 # class A: #     def __func(self): #_A__func() #         print('__a_func') # # class B(A): #     def __init__(self): #         self.__func()        # _B__func() #     def __func(self): #         print(11) # b = B() # # 11 # 因为父级A 是 _A__func()  ，子集B  是_B__func()  函数名不一样所以不能继承A父类的 # 但是下边的函数名是一样的。 # 此时  b._B__func() # -------------- # property # @property 把一个方法 伪装成一个属性  直接用就行了 在方法上加上@property #1.属性的值 是这个方法的返回值 #2.这个方法不能有参数了 只能有self # 公有的 #私有的 + property # class Person: #     def __init__(self,name,height,weight): #         self.name = name #         self.height = height #         self.__weight = weight # #     @property #     def bmi(self): #         return self.__weight / (self.height ** 2) # # li = Person('李岩',1.75,65) # print(li.bmi) # # # 圆形类 ： 面积 周长 # from math import pi # class Circle: #     def __init__(self,r): #         self.r = r #     @property #     def area(self): #         return self.r*self.r*pi # #     @property #     def perimeter(self): #         return self.r*pi*2 # c1 = Circle(5) # print(c1.area) # print(c1.perimeter) # #圆形类 ： 面积 周长  property 的应用 # from math import pi # class Circle: #     def __init__(self,r): #         self.r = r #     @property #     def area(self): #         return self.r*self.r*pi # #     @property #     def perimeter(self): #         return self.r*pi*2 # c1 = Circle(5) # print(c1.area) # print(c1.perimeter) # 很重要的实例 # 1简单的打折 # class Goods: #   discount = 0.8 #   def __init__(self,name,price): #     self.name = name #     self.__price = price #   @property #   def price(self): #      return  self.__price*Goods.discount # app = Goods('苹果',10) # print(app.price) # #   #如没有哪个伪装属性@propetry  必须打印app.price() # app.price = 6   不能改变 因为里面是私有的 # print(app.price) # 2题目组合propety 组合setter,修改改变价格为6元 # 注意事项  修改的价格时候搭配 方法上面@property # 下边的同一个属性上面@属性.setter () 前提必须有prooety # 注意这个属性必须前后是一种 # class Goods: #     __dicount = 0.8 #     def __init__(self,name,price): #         self.name = name #         self.__price = price #     @property #     def price(self): #         return  self.__price*Goods.__dicount #     @price.setter     #装饰器 #     def price(self,new_price): #         if type(new_price) is int: # 这个或者时float #             self.__price = new_price # app = Goods('苹果',10) # app.price = 6    #  setter # print(app.price)   #  property # 注意装饰器的调用没有返回值的话 直接调用就空 # 封装 # __私有+property #让对象的属性变得更安全了 #获取到的对象的值可以进行一些加工 #修改对象的值的同时可以进行一些验证 # 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() # print(f1.AAA)      #property    为什么是None 在打印这个属性 只是调用没有返回 # f1.AAA='aaa'  #setter # del f1.AAA    #deleter # 删除名字 先@property  后 @deleter  里面删除 外边在删除 # class Goods: #     __discount = 0.8   #静态属性 #     def __init__(self,name,price): #         self.__name = name #         self.__price = price  #原价 #     @property #     def name(self): #         return self.__name # #     @name.setter #     def name(self,new_name): #         self.__name = new_name # #     @name.deleter #     def name(self): #         del self.__name #     @property #     def price(self):   #折后价 #         return self.__price * Goods.__discount # #     @price.setter #     def price(self,new_price):   #修改原价 #         if type(new_price) is int: #             self.__price = new_price # apple = Goods('苹果',10) # apple.price = '10'   #settrt # print(apple.price)   #property # del __self.name # print(apple.name) # --------- #私有的 #私有的静态属性、方法、对象属性 #使用__名字的方式调用，保证在类内部可以调用，外部不行 #私有的 不能被继承 # 当有一个名字，不想被外部使用也不想被子类继承，只想在内部使用的时候就定义私有的 #私有的 #私有的静态属性、方法、对象属性 #使用__名字的方式调用，保证在类内部可以调用，外部不行 #私有的 不能被继承 # 当有一个名字，不想被外部使用也不想被子类继承，只想在内部使用的时候就定义私有的 # class D: #     def __init__(self): #         print('d') # class C(D): #     def __init__(self): #         print('c') #         super().__init__() # class B(D): #     def __init__(self): #         print('b') #         super().__init__() # class A(B,C): #     def __init__(self): #         print('a') #         super().__init__() # #mro # a = A() # print(A.mro()) # from  math import pi # class Circle: #     def __init__(self,circle_r): #         self.circle_r = circle_r #     def perimetre(self): #         return  2*pi*self.circle_r #     def area(self): #         return  pi*self.circle_r**2 # class Rings: #     def __init__(self,d_R,d_r): #         self.d_R = Circle(d_R) #         self.d_r = Circle(d_r) # #        # Circle()这个是圆的对象  左边的是属性   Rings这个类 以Circle这个类的对象为属性 叫组合 #     @property #     def ring_perimetre(self): #         return   self.d_R.perimetre()+self.d_r.perimetre() #     @property #     def ring_area(self): #         return  self.d_R.area()-self.d_r.area() # ring = Rings(10,5) # print(ring.ring_perimetre) # print(ring.ring_area) # # 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() # print(A._A__foo())??????????????? # A._A__N  # 外边访问内部 是可以访问到的，即这种操作并不是严格意义上的限制外部访问，仅仅只是一种语法意义上的变形 # print(A._A__N )  #外边访问内部 语法没问题 但是不能这么用 # 1. # 类中定义的__x只能在内部使用，如self.__x，引用的就是变形的结果。 # 2. # 这种变形其实正是针对外部的变形，在外部是无法通过__x这个名字访问到的。 # 3. # 在子类定义的__x不会覆盖在父类定义的__x，因为子类中变形成了：_子类名__x, 而父类中变形成了：_父类名__x，即双下滑线开头的属性在继承给子类时，子类是无法覆盖的。 # property属性  @property 在方法的前面 上面加上这个  底下的方法就变成属性了 #  打印的时候就是直接打印方法 而不需要方法加上括号了 # 复制代码 # 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) # 什么是特性property # # property是一种特殊的属性，访问它时会执行一段功能（函数）然后返回值 #------------------- #接口定义：是规范子类的一个模板，只要接口类定义的，就应该在子类中实现。 # 接口类 不能被继承 就是父类就不能被继承， # 自己理解 接口类 模板 是针对 子类的方法不一样的而抛出异常， # 让其继承父类的方法，需要定义一个函数和一个新的父类 # # 第一种比较low的那种 # class Payment:   #定义一个父类  为解决 子类的方法不统一 #     def pay(self,money):   raise  NotImplementedError  #主动刨出异常 # # class Apple_pay(Payment): #     def pay(self,money): #         print('请使用苹果支付了%s元'% money) # # class Ali_pay(Payment): #     def pay(self, money): #         print('请使用支付宝支付了%s元' % money) # # class Wechat_pay(Payment): #     def fukuan(self, money): #         print('请使用苹果支付了%s元' % money) # def pay (obj,money):    #定义的函数和父类的方法必须一致才会检测通过的， #     return  obj.pay(money) # ap = Apple_pay() # al =Ali_pay() # we = Wechat_pay() # pay(ap,100) # pay(we,200) # 接口2 固定用法 自动检测异常的 如果子类不能继承父类就异常  接口类不能被继承 # 如果有两个@abstractclassmethods 两个都会检测 必须符合两个才不会抛出异常 # from abc import ABCMeta,abstractmethod # 父类（metaclass=ABCMeta） # 在父类方法上面装饰  @abstractmethod # from abc import ABCMeta,abstractmethod # class Payment(metaclass=ABCMeta): #定义一个父类  为解决 子类的方法不统一  metaclass元类 #     @abstractmethod #     def pay(self,money):pass #     @abstractmethod #     def ger(self,money):pass # class Apple_pay(Payment): #     def pay(self,money): #         print('请使用苹果支付了%s元'% money) # # class Ali_pay(Payment): #     def pay(self, money): #         print('请使用支付宝支付了%s元' % money) # # class Wechat_pay(Payment): #     def fukuan(self, money): #         print('请使用苹果支付了%s元' % money) # def pay (obj,money):    #定义的函数和父类的方法必须一致才会检测通过的， #     return  obj.pay(money) # ap = Apple_pay() # # al =Ali_pay() # # we = Wechat_pay() # pay(ap,100) # pay(we,200) # wechat 因为和父类方法不一样 所以就异常 # 题目三  如果父类有两个方法  那字类也必须继承父类两个方法  否则报错  。 # 接口类： # 是规范子类的一个模板，只要接口类中定义的，就应该在子类中实现 # 接口类不能被实例化,它只能被继承 # 支持多继承 # —————————————————————————— # 定义一个类 #类里面的方法 #并没有用到self # 类方法  改变一个静态的属性 # class Goods: #     __discount = 0.8 #     @classmethod #     def change_discount(cls,new_discount): #         cls.__discount = new_discount #     @classmethod #     def get_discount(cls): #         return  cls.__discount # Goods.change_discount(0.75) # print(Goods.get_discount()) #类方法     #调用：不需要实例化 直接用类名调用就好     #定义：不用接受self参数，默认传cls，cls就代表当前方法所在的类 #什么时候用类方法？     #需要使用静态变量 且 不需要和对象相关的任何操作的时候 #静态方法 #如果这个方法 既不需要操作静态变量            # 也不需要使用对象相关的操作， # 就使用静态方法 # class A: #     @staticmethod #     def func(name):  #静态方法 #         print(123) # A.func('alex') #面向对象编程：专门为面向对象编程提供的一个方法——staticmethod #它完全可以当做普通函数去用，只不过这个函数要通过类名.函数名调用 #其他 传参 返回值 完全没有区别 #类里面，一共可以定义这三种方法： #普通方法 self #类方法 cls #静态方法 #绑定方法 和 非绑定方法 # class A: #     @staticmethod #     def func1(name):  #静态方法 #         print(123) # #     @classmethod #     def func2(cls):  # 静态方法 #         print(123) # #     def func3(self):pass # a = A() # print(a.func1)  #静态方法 # print(a.func2)  #类方法 ： 绑定到A类的func # print(a.func3)  #普通方法：绑定到A类对象的func #静态方法和类方法 都是直接可以使用类名调用 #普通方法：对象调用