Python基础-面向对象

类的创建, 实例化, 初始化

• 什么是类

  类就是拥有相同功能或者相同属性的对象集合

• 类的创建

  • object是所有类的基类

    class GoGamer(object):
        subject = 'go'
    
    print(GoGamer)
    

• 类的实例化

  实例就是抽象概念的具象化

  kejie = GoGamer()
  print(kejie)
  

• 类的初始化

  类创建一个新实例的时候会默认调用__init__这样一个特殊方法

  class GoGamer(object):
      subject = 'go'
      def __init__(self, obj):
          self.p = obj
  
  kejie = GoGamer("金勺子")
  print(f"柯洁含着{kejie.p}出生")
  

  • 关于self

    指代还未实例化的实例

面向对象

• 面向过程

  • 程序=数据结构+算法
  • 强调的是一个实现的细节

• 面向对象

  完成对越来越庞大项目代码以及对外公开接口的归类和重用, 是一种更高级的抽象.

  • 通过什么手段来完成上述目的?

    • 继承

      class ChineseGoGamer(GoGamer):
          nation = 'cn'
      
      class KoreaGoGamer(GoGamer):
          nation = 'kr'
      

      • 处理多继承冲突

        • 查看MRO(mehotd resolution order)

          class A:
              def __init__(self):
                  print("init A")
          
          class B:
              def __init__(self):
                  print("init B")
          
          
          class C(A, B):
              pass
          
          print(C.__mro__)
          

        • 指定类方法的调用顺序

          class C(A, B):
              def __init__(self):
                  super(A, self).__init__()
          

        • super函数源码

          def super(cls, inst):
          	mro = inst.__class__.mro()
          	return mro[mro.index(cls) + 1]
          
          def super(类, 实例):
          	# 获取当前实例的方法解析顺序
          	mro = 实例.类.mro()
          	return mro[mro.index(类) + 1]
          

    • 多态

      方式为覆盖和重载

      • 覆盖(子类和父类之间的, 是垂直的关系)

        子类可以继承父类的所有属性和方法, 但是同时子类也可以重写父类的属性和方法, 达到自定义的目的.

        class A:
            def __init__(self):
                print("init A")
        
        class B:
            def __init__(self):
                print("init B")
        
        
        class C(A, B):
            def __init__(self):
                print("init C")
        

      • 重载(类中的方法和方法之间的, 是水平关系)

        Python中式没有重载, 但是可以用装饰器来实现该功能.

    • 封装

      把客观事物封装成抽象的类, 隐藏实现细节, 使得代码模块化.

      类属性和实例属性

• 类属性

  • 通过类对象可以直接访问的属性

  • 抽象概念的固有属性, 要考虑当前抽象概念的普适性

    # 贴标签不是一个特别好的抽象, 原因他没有一个普适性
    class Developer:
        programing_language = None
        busy = True
    

    • 私有属性

      不希望外部更改, 只作用于类内部

      • 通过__变量名来声明私有属性

        class Lottery:
            __items = ["mac", "ipad", "iphone"]
        

      • 通过类._类名__变量名来访问私有属性

        print(Lottery._Lottery__items)
        

• 实例属性

  • 绑定在实例上的属性, 只能通过该实例进行访问

  • 实例的自有属性

    class Developer:
        programing_language = None
        busy = True
        __case = "doing something"
    
    d_python = Developer()
    d_python.programing_language = "python"
    d_java = Developer()
    d_java.programing_language = "java"
    
    print(d_java.programing_language)
    print(d_python.programing_language)
    

    • 私有属性
      • 通过self.__变量名来声明私有属性
      • 通过实例._类名__变量名来访问私有属性

类方法, 静态方法, 实例方法

• 类方法

  • 仅供类调用的方法

  • 通过classmethod装饰器来声明一个类方法

  • 自定义类创建

    class Developer:
        programing_language = None
        busy = True
        __case = "doing something"
        def __init__(self, hairs):
            self.__hairs = hairs
    
        @classmethod
        def __new__(cls, *args, **kwargs):
            print("init class")
            return super().__new__(cls)
    
        @classmethod
        def get_case(cls):
            return cls.__case
    

• 静态方法

  • 类可以直接调用的方法

  • 通过staticmethod装饰器装饰

  • 对一类抽象行为的归类

    class MyMath:
    
        @staticmethod
        def add(a, b):
            return a + b
    

• 实例方法

  • 仅供实例调用的方法

接口, 协议和抽象基类

• 接口

  对象公开方法的子集, 让对象在系统中扮演特定的角色.

  list实现了增删改查的接口, 只要有一个接口没有实现那就不属于list
  tuple只提供了查的接口
  

• 协议

  非正式的接口, 协议与继承没有关系, 一个类可能会实现多个接口, 从而让实例扮演多个角色

  list扮演者列表的角色, 但同时也是一个序列, 序列并不是一个实体类.
  

  • 协议的应用

    class MyDict(dict):
        def __iadd__(self, other):
            self.update(other)
            return self
    
        def __str__(self):
            return f"My Dict {self.items()}"
    

• 抽象基类

  把客观事物封装成抽象的元类, 区分概念和实现.

  • 只要有@abc.abstractmethod装饰器的类就是抽象基类

    import abc
    class Mixin:
        def sign(self):
            pass
    
        def rank(self):
            pass
    
    class Gamer:
        @abc.abstractmethod
        def sign(self):
            pass
    
    
    class GoGamer(Mixin, Gamer):
        pass
    
    class Swimmer(Mixin, Gamer):
        pass