python 的方法和函数，基本上函数等同于方法。

python 的类方法分三种：

  1. 实例方法，属于具体实例对象
  2. 类方法，该类对象，及该类实例对象可调用的，使用 @classmethod 装饰器
  3. 静态方法，直接调用，使用 @staticmethod 装饰器

参考：[Python]实例方法、类方法、静态方法

类与实例

类是模板，可用于定义具体对象的属性；
实例，使用个类的具体对象，具备自己特定的属性值。

实例方法、类方法、静态方法

my_method.py 文件

  1. # coding=utf-8
  3. class My_class(object):
  4.     """测试python 的 实例方法、类方法、静态方法"""
  6.     def instance_method(self, age=None):
  7.         """
  8.         实例方法
  9.         第一个参数是实例对象，一般使用 self 代替
  10.         调用的时候需要实例化一个对象，然后使用
  11.         """
  12.         # pass
  13.         print("我是实例方法", id(self))
  15.     @classmethod
  16.     def class_method(cls, age=None):
  17.         """
  18.         类方法
  19.         第一个参数是类对象，使用 cls 代替
  20.         调用的时候可以使用类对象，也可以是类对象的实例
  21.         :param age:
  22.         :return:
  23.         """
  24.         # pass
  25.         print("我是类方法", id(cls))
  27.     @staticmethod
  28.     def static_method(age=None):
  29.         """
  30.         静态方法
  31.         可以没有参数
  32.         调用可以是类对象，也可以是类对象的实例
  33.         :param age:
  34.         :return:
  35.         """
  36.         # pass
  37.         print("我是静态方法", id(My_class))
  40. def main():
  41.     # 类对象直接调用方法
  42.     My_class.class_method(20)
  43.     My_class.instance_method(21)
  44.     My_class.static_method(22)
  45.     print("==" * 30)
  46.     # 实例化对象
  47.     my_class = My_class()
  48.     # 实例化对象，调用方法
  49.     my_class.class_method()
  50.     my_class.instance_method()
  51.     my_class.static_method()
  54. if __name__ == "__main__":
  55.     print("---" * 20)
  56.     # pass
  57.     main()
  60. class My_Class_2(object):
  61.     """第二测试方法的类"""
  63.     def instance_method(self, age=None):
  64.         print("instance_method")
  66.     @classmethod
  67.     def class_method(cls, age=None):
  68.         print("class_method")
  70.     @staticmethod
  71.     def static_method(age=None):
  72.         print("static_method")
  74. class My_Class_3(object):
  75.     """第二测试方法的类"""
  77.     def instance_method(self, age=None):
  78.         print("3 instance_method")
  80.     @classmethod
  81.     def class_method(cls, age=None):
  82.         print("3 class_method")
  84.     @staticmethod
  85.     def static_method(age=None):
  86.         print("3 static_method")
  88. class My_Class_4(object):
  89.     """测试python 的 实例方法、类方法、静态方法"""
  91.     def instance_method(self, age=None):
  92.         """
  93.         实例方法
  94.         第一个参数是实例对象，一般使用 self 代替
  95.         调用的时候需要实例化一个对象，然后使用
  96.         """
  97.         # pass
  98.         print("C4 我是实例方法", id(self))
  100.     @classmethod
  101.     def class_method(cls, age=None):
  102.         """
  103.         类方法
  104.         第一个参数是类对象，使用 cls 代替
  105.         调用的时候可以使用类对象，也可以是类对象的实例
  106.         :param age:
  107.         :return:
  108.         """
  109.         # pass
  110.         print("4 我是类方法", id(cls))
  112.     @staticmethod
  113.     def static_method(age=None):
  114.         """
  115.         静态方法
  116.         可以没有参数
  117.         调用可以是类对象，也可以是类对象的实例
  118.         :param age:
  119.         :return:
  120.         """
  121.         # pass
  122.         print("4 我是静态方法", id(My_class))

test_method.py 文件

  1. # coding=utf-8
  2. import time
  4. import my_method
  6. if __name__ == "__main__":
  7.     # my_method.main()
  9.     print("=="*30)
  10.     print("=="*30)
  11.     # 类对象直接调用方法
  12.     my_method.My_class.class_method(20)
  13.     my_method.My_class.instance_method(21)
  14.     my_method.My_class.static_method(22)
  15.     print("==" * 30)
  16.     # # 实例化对象
  17.     my_class = my_method.My_class()
  18.     # 实例化对象，调用方法
  19.     my_class.class_method()
  20.     my_class.instance_method()
  21.     my_class.static_method()
  23.     print("--"*30)
  24.     print("--"*30)
  25.     my_method.My_Class_2.static_method()
  26.     my_method.My_Class_2.class_method()
  27.     # my_method.My_Class_2.instance_method()
  28.     # my_method.My_Class_2
  29.     print("--"*30)
  30.     print("--"*30)
  31.     my_method.My_Class_3.static_method()
  32.     my_method.My_Class_3.class_method()
  33.     # my_method.My_Class_3.instance_method()
  34.     # my_method.My_Class_3
  35.     print("--" * 30)
  36.     print("--" * 30)
  37.     my_method.My_Class_4.static_method()
  38.     my_method.My_Class_4.class_method()
  39.     # my_method.My_Class_4.instance_method()
  40.     # my_method.My_Class_4
  42.     time.sleep(1)
  43.     my_method.My_class.instance_method()

运行 tet_method.py 结果：

  1. D:\devTools\Python\Miniconda3\envs\python38\python.exe D:/OtherProjects/action/practice-demo-python/py_38/drf_demo/drf_demo/test_method.py
  2. ============================================================
  3. ============================================================
  4. 我是类方法 2140269657328
  5. 我是实例方法 140708077379968
  6. 我是静态方法 2140269657328
  7. ============================================================
  8. 我是类方法 2140269657328
  9. 我是实例方法 2140301132080
  10. 我是静态方法 2140269657328
  11. ------------------------------------------------------------
  12. ------------------------------------------------------------
  13. static_method
  14. class_method
  15. ------------------------------------------------------------
  16. ------------------------------------------------------------
  17. 3 static_method
  18. 3 class_method
  19. ------------------------------------------------------------
  20. ------------------------------------------------------------
  21. 4 我是静态方法 2140269657328
  22. 4 我是类方法 2140269652608
  23. Traceback (most recent call last):
  24.   File "D:/OtherProjects/action/practice-demo-python/py_38/drf_demo/drf_demo/test_method.py", line 43, in <module>
  25.     my_method.My_class.instance_method()
  26. TypeError: instance_method() missing 1 required positional argument: 'self'
  28. Process finished with exit code 1
  1. 令人困惑的是，前面的 my_method.My_class.instance_method() 方法可以，后面的就不可以，不应该是都不可以吗？

小结

  1. 定义形式上：

a. 类方法和静态方法都是通过装饰器实现的，实例方法不是;
b. 实例方法需要传入self参数，类方法需要传入cls参数，而静态方法不需要传self或者cls参数。
2. 调用方式上：
实例方法只能通过实例对象调用；类方法和静态方法可以通过类对象或者实例对象调用，如果是使用实例对象调用的类方法或静态方法，最终都会转而通过类对象调用。
3. 应用场景：
a. 实例方法使用最多，可以直接处理实例对象的逻辑；类方法不需要创建实例对象，直接处理类对象的逻辑；静态方法将与类对象相关的某些逻辑抽离出来，不仅可以用于测试，还能便于代码后期维护。
b. 实例方法和类方法，能够改变实例对象或类对象的状态，而静态方法不能。