python面向对象1

1. dir()内置函数
   在标识符/数据 后面输入. ，然后按下TAB键，ipython会提示该对象能够调用的方法
   使用内置函数dir 传入标识符/数据，可以查看对象内的所有属性及方法
   说明：
       __方法名__格式的方法是python提供的内置方法/属性
2. 类的定义和对象的创建
    2.1 在Python 中定义一个只包含方法的类，语法格式：
        class 类名:
           
            def 方法1(self,参数列表):
               pass
               
            def 方法2(self,参数列表):
               pass
        (1)类的方法，第一个参数必须是self
        (2)使用print输出对象，在默认情况下，是能够输出这个
           变量的引用的对象是由那个类创建的，以及在内存中的地址（16进制表示）
        (3)self 参数含义
           在类封装的方法内部，self就表示 当前调用方法的对象自己
           调用方法时，程序员不需要传递self参数
               可以通过self，访问对象方法
               也可以通过self,调用其他的对象方法
        （4）在python中连续定义多个类时，类和类之间需要两行空格
        
    2.2 创建一个类对象，语法：
        对象变量 = 类名()
    2.3 类的初始化方法
        对象包含那些方法，应该封装到类的内部
        当使用 类名()创建对象时，会自动执行以下操作：
            1.为对象在内存中 分配空间---创建对象时，会自动执行以下操作：
            2.为对象的属性 设置初始值---初始化方法（init）
        这个初始化方法，就是__init__方法，__init__是对象的内置方法
           __init__方法是专门用来定义一个类具有那些属性的方法
        在__init__方法内部使用self.属性名 = 属性的初始值，就可以定义属性
        定义属性之后，再创建对象时，使用类名（属性1，属性2，...）调用，都会拥有该属性
    2.4 __del__方法
        当使用类名()创建对象时，为对象 分配完空间后，自动调用__init__方法
        当一个对象被从内存中销毁前，会自动 调用__del__方法
        应用场景：
           __init__改造初始化方法，可以让创建对象更加灵活
           __del__如果希望对象在销毁前，再做一些事情，可以考虑一下__del__方法
    2.5 __str__方法
        在Python中，使用print输出对象变量时，会输出这个变量引用的对象是由那个类创建的对象
            以及在内存中的地址（16进制）
        如果在开发中，希望print输出对象变量时，能够打印自定义的内容，就可以利用__str__
            这个内置方法
        注意：__str__方法必须返回一个字符串
    2.6 私有属性和私有方法
        在定义属性或方法时，在属性名或方法名前面加两个下划线，定义的就是私有属性或方法
        私有属性和私有方法只能在对象内部被使用
        在类外部访问私有属性和方法：
           在名称前面加上，_类名   ._类名__名称
        
3. 身份运算符
       身份运算符用于比较两个对象的内存地址是否一致--是否是对同一个对象的引用
       在python中针对None比较时建议使用is 判断
       运算符：
       is  is是判断两个标识符是不是引用同一个对象 x is y 相当与id(x)==id(y)
       is not is not是判断两个标识符是不是引用不同对象 x is not y 相当与id(x)==id(y)
       is 和 == 区别
       is 用于判断两个变量引用的是否为同一个对象
       == 用于判断引用变量的值是否相等

4. 继承
    4.1 继承的概念，语法和特点
        继承的概念：子类拥有父类的所有属性和方法
        1）继承的语法
            class 类名(父类名):
                pass
            子类继承自父类，可以直接享受父类中已经封装好的方法，不需要再次开发
            子类中应该根据职责，封装子类特有的属性和方法
        2）继承的传递性
             子类拥有父类。以及父类的父类中封装的所有属性和方法
    4.2 方法的重写
            当父类的方法实现不能满足子类需求时，可以对方法进行 重写（override）
        重写父类的方法有两种：
            1.覆盖父类的方法
                 在子类中重新编写一下父类的方法实现
                 就相当于在子类中定义一个和父类同名的方法并且实现
            2.对父类方法进行扩展
                在开发过程中，子类的方法实现中包含了父类的方法实现
                      父类原本封装的方法是 子类方法的一部分
                就可以使用扩展的方法：
                      1在子类中重写父类的方法
                      2在需要的位置使用super().父类方法 来调用父类的执行
                      3代码的其他位置针对子类的需求，编写子类的特有代码
            关于super
                 在python中super 是个特殊的类
                 super（）就是使用super类创建出来的对象
                 最常使用的场景就是在重写父类方法时，调用在父类中封装的方法实现
                 
                调用父类的另外一种方法
                   在python2.x时，如果需要调用父类的方法还可以使用以下方法：
                     父类名.方法（self） # self是必填参数
                   这种方法目前pytho3.x 还支持
                   在种方法不推荐使用，不方便维护。
                提示： 在开发时，父类名和super()两种方法不要混用
                        如果使用当前类名调用方法，会递归调用，出现死循环

5.     父类的私有属性和方法
    1.子类对象 不能在自己方法内部，直接访问父类的私有属性或私有方法
    2.子类对象 可以通过父类的公有方法 间接访问到私有属性或私有方法    
        私有属性，方法是对象的隐私，不对外公开，外界以及子类都不能直接访问

6. 多继承
   子类可以拥有多个父类，并且拥有所有父类的属性和方法
   语法：
       class 子类名(父类名1,父类名2,...)
           pass       
   注意：
       如果父类之间存在同名的属性或方法时，应该尽量避免使用多继承（容易混淆继承于那个类）
       python中的__MRO---方法搜索顺序
           python中针对类提供了一个内置属性__mro__，可以查看方法搜索顺序
           MRO 主要用于在多继承时判断 方法，属性的调用路径
           print(C.__mro__)
           (<class '__main__.C'>, <class '__main__.A'>, <class '__main__.B'>, <class 'object'>)
           按照__mro__的输出结果从左到右的顺序查找，找到就调用对应类的方法或属性，如果都没有找到程序报错
7. 新式类和旧式（经典）类        
   object 是python为所有对象提供的基类，提供一些内置属性和方法，可以使用dir函数查看
   新式类：以object 为基类，推荐使用
   经典类：不以object为基类的类，不推荐使用
   在python3.X中定义类时，如果没有指定父类，会默认使用object作为该类的基类---默认为新式类
   在python2.x中定义类是，如果没有指定父类，不会以object为基类
      新式类和经典类在多继承时---会影响到方法的搜索顺序
   为了保证代码的兼容性，今后在定义类时，如果没有父类，统一继承object
   class 类名(object)
       pass
      
9. 多态
   面向对象三大特性：封装，继承，多态。
   多态：不同的子类对象调用相同父类方法，差生不同的执行结果。
          多态可以增加代码的灵活度。
          以继承 和 重写父类方法为前提。
          是调用方法的技巧，不会影响到类的内部设计。

10. 类属性和类方法
    通常创建出来的对象 叫类的实例，创建对象的动作叫做实例化，
            对象的属性叫做实例属性（__init__定义的），对象的调用的方法叫做实例方法（实例方法(self)）。
    1. 类是一个特殊的对象
       在python 中一切皆对象
       
       在程序运行时，类同样会被加载到内存中。
       在python中，类是一个特殊的对象----类对象
       在程序运行时，类对象 在内存中只有一份，使用一个类可以创建出 很多个对象实例
       除了封装 实例的属性和方法外，类对象还拥有自己的属性和方法，即类属性和类方法。
       该类的所有对象共享类属性和类方法。
       
    2. 类属性
        就是在__init(self): 外应定义的变量
        类属性 就是给类对象 中定义的 属性
        通常记录 与这个类相关 的特性
        类属性 不会用于记录 具体对象的特性
        通过 类名.类属性 访问类属性
        2.1 属性的获取机制
            在python 中属性的获取是，向上查找的机制
            先去对象内部（查找对象属性），如果没有找到就会向上寻找类属性
            因此，要访问类属性有两种方式：
               类名.类属性
               对象.类属性（不推荐使用，不容易分清时类属性，还是对象属性）
            注意：
                如果使用 对象.类属性 = 值 赋值语句，只会给对象添加一个属性，而不
                会影响到类属性的值
    3. 类方法
        类方法 就是针对类对象 定义的方法
            在类方法中可以直接访问类属性 或者 其他的类方法
        语法：
            @classmethod
            def 类方法名(cls)
                pass
        类方法需要用@classmethod 来标识，告诉编译器这是个类方法
        类方法的第一个参数应该是 cls
            由那一个类调用的方法，方法内的cls就是哪一个类的引用
            这个参数和 实例方法的第一个参数self 类似
            提示：使用其他名称也可以，习惯使用cls
        通过 类名.类方法 调用方法时，不需要传递cls 参数
        在类方法内部：
             可以使用cls. 访问类属性
             也可以使用cls. 调用其他的类方法
    4. 静态方法
        在开发中，如果需要在类中封装一个方法，这个方法：
            即不需要 访问 实例属性 或者调用 实例方法
            也不需要 访问 类属性 或者调用 类方法
        这时候，可以把这个方法封装成一个 静态方法
        语法：
            @staticmethod
            def 静态方法名():
                pass
        静态方法 需要用 @staticmethod 来修饰，告诉解释器这时一个静态方法
        通过 类名. 调用 静态方法名
    
     实例方法 --方法内部需要访问实例属性
                也可以通过 类名. 访问类属性
     类方法   --方法内部只需要访问类属性
     静态方法  --方法内部不需要访问实例属性，也不需要访问类属性

    源代码： https://download.csdn.net/download/b903299114/10470026