类方法和静态方法

类方法和静态方法

一、类方法

• 类方法定义：

  • 类方法：是由类来调用的方法，不是普通的构造方法，类方法约定俗称第一个参数是cls
    表示的是class，python把class的命名空间(内存地址)传递给类方法

       class A(object):
          def func(self):
              print(self)
    
      a1 = A()
      a1.func()
    
    
      # 方法打印self，结果是本类在电脑中的内存地址，这种是普通的构造方法
    
      class B(object):
          @classmethod
          # 添加类方法的装饰器
          def func(cls):
              # 参数固定是cls，表示的是class
              print(cls)
    
    
      b1 = B()
      b1.func()
      B.func()
      '''
      类方法：由类来调用的方法，不是由实例对象调用的方法。类方法需要在构造方法
      上添加@classmethod装饰器，并且类方法的第一个参数约定俗成为cls。实际上是
      python把类的命名空间(内存地址)传递给类方法
      '''      

  • 把普通的构造方法转变成类方法需要在构造方法上添加@classmethod装饰器

  • 类方法不需要对象参与，当需要对类中的静态方法改变的时候需要用到类方法，用cls调用，不用类名

    Note
    需要注意的是，普通方法是不推荐直接用类名直接调用类中的方法的，正常情况下都是实例化对象调用，但是如果使用了类方法装饰器
    把普通的方法转变成类方法后，则可以直接使用类名.方法名来调用。参数cls等同与本类，可以直接使用cls调用方法和静态字段，可
    以在类方法中修改静态字段，但是调用的类中的方法只能输出到对应的内存地址，不能获取到返回值。

      '''实例一'''   
      class B(object):
          name = 'alex'
          __age = 100
          count = 1
          @classmethod
          # 添加类方法的装饰器
          def func(cls):
              # 参数固定是cls，表示的是class  
              cls.__age = cls.__age + 20                              
              return '%s的年龄为%s,第%s次返回' % (cls.name, cls.__age, cls.count + 1)
              # 这里可以直接使用cls来调用类中的变量、属性和方法
  
         b1 = B()
         b1.func()
         print(B.func()) 
  
         '''实例二'''
         class Person(object):
         __age = 100
         country = '中国'
         province = '北京'
  
         def __init__(self, name, height, weight):
             self.name = name
             self.height = height
             self.__weight = weight
  
         @property
         def bmi(self):
             bmi = self.__weight / self.height ** 2
             return bmi
  
         @bmi.setter
         def bmi(self, h1):
             self.height = h1
  
         # bmi = self.__weight / self.__height ** 2
         # return bmi
  
         @bmi.deleter
         def bmi(self):
             del self.height
             del self.__weight
  
         def get_name(self):
             return self.name
  
         @classmethod
         def message(cls, province):
             cls.province = province
             return cls.__age, cls.province, cls.country, cls.bmi, cls.get_name
         # 类方法中的第一个参数是cls，后边是其他的参数，和普通的方法用法基本一致。
         # 类方法只能通过cls来调用和修改类中的静态字段，不能调用属性，也可以调用类中的方法
         # 但是/输出的结果是方法的内存地址，如果是伪造属性，输出的是属性的内存地址
  
         p1 = Person('刘洋', 1.7, 95)
         print(p1.bmi)
         p1.height = 2.23
         print(p1.bmi)
         print(Person.message('河南'))

• 类的静态方法可以被继承，可以直接使用子类调用父类中的静态方法

   class A(object):
      __country = '中国'
      province = '北京'
  
      def __init__(self, name, age, gender):
          self.name = name
          self.__age = age
          self.gender = gender
  
      @classmethod
      def func(cls):
          # cls:哪个类调用就显示哪个类的类空间
          return cls.__country, cls, cls.province
  
      class B(A):
          province = '河南'
  
  
      print(B.func())
      # B类继承自A类，那么B类也就继承类A类中的类方法，类方法中的cls此时表示的就是B类，输出B类的内存地址
      # 子类不能继承父类的私有方法、私有属性和私有类变量，其他的都可以继承

• 实现子类调用父类方法从而调用子类中的静态字段的方式
  • 方式一：通过类方法，传递cls来实现调用

  • 方法二：通过普通方法，子类中没有，父类中有，通过self来调用

     class A(object):
        __country = '中国'
        province = '北京'
    
        def __init__(self, name, age, gender):
            self.name = name
            self.__age = age
            self.gender = gender 
    
        # 方式一
        @classmethod
        def func(cls, province):
            # cls:哪个类调用就显示哪个类的类空间
            cls.province = province
            # 类方法可以访问并修改类中的静态字段
            return cls.__country, cls, cls.province
    
        # 方式二 
        def func1(self):
            print(self.province)
            self.province = '广东'
            print(self.province)
            # 普通方法也可以通过父类调用子类中的字段
            # 普通方法只能查询类中的静态字段
    
    
    class B(A):
        province = '河南'
    
    
    print(B.func('上海'))
    # B类继承自A类，那么B类也就继承类A类中的类方法，类方法中的cls此时表示的就是B类，输出B类的内存地址
    # 子类不能继承父类的私有方法、私有属性和私有类变量，其他的都可以继承
    b1 = B('里流', 12, '男')
    b1.func1()
    print(B.province)  
    
    '''
    结果是：上海、广东、上海
    '''
    

    Note
    需要注意的是：类方法和普通方法都可以实现父类方法调用子类静态字段的目的，但是区别在于：
    类方法中可以直接修改子类中的静态字段值，而普通方法不能修改静态字段值。

二、静态方法

• 静态方法存在于类中，需要用到@staticmethod装饰器
• 静态方法可以不传递任何的参数，也可以传递参数
• 静态方法等同于在类中创建了一个单独的函数
• 静态方法的好处
  • 代码块，清晰明了
  • 增加代码的复用性

  
      class C:
        __age = 100
  
        @staticmethod
        def login(username, password):
            if username == '李镇' and password == '12345':
                print('登陆成功')
            else:
                print('登陆失败')
  
      c1 = C()
      c1.login('李镇', '123456') 
  
     # 输出结果：登陆失败