一、类方法

  • 类方法定义：

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

    a1 = A() a1.func()

方法打印self，结果是本类在电脑中的内存地址，这种是普通的构造方法

class B(object): @classmethod

  1.   # 添加类方法的装饰器
  2.   def func(cls):
  3.       # 参数固定是cls，表示的是class
  4.       print(cls)

b1 = B() b1.func() B.func() ‘’’ 类方法：由类来调用的方法，不是由实例对象调用的方法。类方法需要在构造方法 上添加@classmethod装饰器，并且类方法的第一个参数约定俗成为cls。实际上是 python把类的命名空间(内存地址)传递给类方法 ‘’’

  2.    - 把普通的构造方法转变成类方法需要在构造方法上添加@classmethod装饰器
  3.    - 类方法不需要对象参与，当需要对类中的静态方法改变的时候需要用到类方法，用cls调用，不用类名
  4. > **Note**
  5. > 需要注意的是，普通方法是不推荐直接用类名直接调用类中的方法的，正常情况下都是实例化对象调用，但是如果使用了类方法装饰器
  6. > 把普通的方法转变成类方法后，则可以直接使用类名.方法名来调用。参数cls等同与本类，可以直接使用cls调用方法和静态字段，可
  7. > 以在类方法中修改静态字段，但是调用的类中的方法只能输出到对应的内存地址，不能获取到返回值。
  9. ```python
  10.     '''实例一'''   
  11.     class B(object):
  12.         name = 'alex'
  13.         __age = 100
  14.         count = 1
  15.         @classmethod
  16.         # 添加类方法的装饰器
  17.         def func(cls):
  18.             # 参数固定是cls，表示的是class  
  19.             cls.__age = cls.__age + 20                              
  20.             return '%s的年龄为%s,第%s次返回' % (cls.name, cls.__age, cls.count + 1)
  21.             # 这里可以直接使用cls来调用类中的变量、属性和方法
  23.        b1 = B()
  24.        b1.func()
  25.        print(B.func()) 
  27.        '''实例二'''
  28.        class Person(object):
  29.        __age = 100
  30.        country = '中国'
  31.        province = '北京'
  33.        def __init__(self, name, height, weight):
  34.            self.name = name
  35.            self.height = height
  36.            self.__weight = weight
  38.        @property
  39.        def bmi(self):
  40.            bmi = self.__weight / self.height ** 2
  41.            return bmi
  43.        @bmi.setter
  44.        def bmi(self, h1):
  45.            self.height = h1
  47.        # bmi = self.__weight / self.__height ** 2
  48.        # return bmi
  50.        @bmi.deleter
  51.        def bmi(self):
  52.            del self.height
  53.            del self.__weight
  55.        def get_name(self):
  56.            return self.name
  58.        @classmethod
  59.        def message(cls, province):
  60.            cls.province = province
  61.            return cls.__age, cls.province, cls.country, cls.bmi, cls.get_name
  62.        # 类方法中的第一个参数是cls，后边是其他的参数，和普通的方法用法基本一致。
  63.        # 类方法只能通过cls来调用和修改类中的静态字段，不能调用属性，也可以调用类中的方法
  64.        # 但是/输出的结果是方法的内存地址，如果是伪造属性，输出的是属性的内存地址
  66.        p1 = Person('刘洋', 1.7, 95)
  67.        print(p1.bmi)
  68.        p1.height = 2.23
  69.        print(p1.bmi)
  70.        print(Person.message('河南'))
  2. - <font color='red'>类的静态方法可以被继承，可以直接使用子类调用父类中的静态方法</font>
  4.     ```python 
  5.      class A(object):
  6.         __country = '中国'
  7.         province = '北京'
  9.         def __init__(self, name, age, gender):
  10.             self.name = name
  11.             self.__age = age
  12.             self.gender = gender
  14.         @classmethod
  15.         def func(cls):
  16.             # cls:哪个类调用就显示哪个类的类空间
  17.             return cls.__country, cls, cls.province
  19.         class B(A):
  20.             province = '河南'
  23.         print(B.func())
  24.         # B类继承自A类，那么B类也就继承类A类中的类方法，类方法中的cls此时表示的就是B类，输出B类的内存地址
  25.         # 子类不能继承父类的私有方法、私有属性和私有类变量，其他的都可以继承

  • 实现子类调用父类方法从而调用子类中的静态字段的方式

    • 方式一：通过类方法，传递cls来实现调用

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

      ```python class A(object):

      1.   __country = '中国'
      2.   province = '北京'
      4.   def __init__(self, name, age, gender):
      5.       self.name = name
      6.       self.__age = age
      7.       self.gender = gender 
      9.   # 方式一
      10.   @classmethod
      11.   def func(cls, province):
      12.       # cls:哪个类调用就显示哪个类的类空间
      13.       cls.province = province
      14.       # 类方法可以访问并修改类中的静态字段
      15.       return cls.__country, cls, cls.province
      17.   # 方式二 
      18.   def func1(self):
      19.       print(self.province)
      20.       self.province = '广东'
      21.       print(self.province)
      22.       # 普通方法也可以通过父类调用子类中的字段
      23.       # 普通方法只能查询类中的静态字段
  1.     class B(A):
  2.         province = '河南'
  5.     print(B.func('上海'))
  6.     # B类继承自A类，那么B类也就继承类A类中的类方法，类方法中的cls此时表示的就是B类，输出B类的内存地址
  7.     # 子类不能继承父类的私有方法、私有属性和私有类变量，其他的都可以继承
  8.     b1 = B('里流', 12, '男')
  9.     b1.func1()
  10.     print(B.province)  
  12.     '''
  13.     结果是：上海、广东、上海
  14.     '''
  16.     ```  
  17.   > **Note**
  18.   需要注意的是：类方法和普通方法都可以实现父类方法调用子类静态字段的目的，但是区别在于：
  19.   <font color='red'>类方法中可以直接修改子类中的静态字段值，而普通方法不能修改静态字段值</font>。

二、静态方法

  • 静态方法存在于类中，需要用到@staticmethod装饰器
  • 静态方法可以不传递任何的参数，也可以传递参数
  • 静态方法等同于在类中创建了一个单独的函数

  • 静态方法的好处

    • 代码块，清晰明了

    • 增加代码的复用性

      2.   class C:
      3.     __age = 100
      5.     @staticmethod
      6.     def login(username, password):
      7.         if username == '李镇' and password == '12345':
      8.             print('登陆成功')
      9.         else:
      10.             print('登陆失败')
      12.   c1 = C()
      13.   c1.login('李镇', '123456') 
      15.  # 输出结果：登陆失败

      ```