Python：实例方法、静态方法和类方法

• 什么是实例方法
  — 只有实例化对象之后才可以使用的方法，称为 类方法；
  — 一般在类中定义的方法，都是 类方法；
  — 该方法的第一个形参接收的一定是对象本身，即 self；
• 示例：

>>> class Animal():
...     def eat(self):
...         print("animal eat")
...
...
>>> cat = Animal()
>>> cat.eat()
animal eat

— 如上所示，eat() 方法就是实例方法，只有在 cat 对 Animal 类进行实例化之后，eat() 方法才能够被调用；

• 什么是静态方法
  — 类对象或实例对象都可以调用的方法，称为静态方法；
  — 静态方法使用装饰器 @staticmethod进行装饰；
  — 静态方法的参数随意，没有 self 和 cls 参数；
  — 静态方只能能使用 类 属性，不能调用 实例 的任何属性和方法；
• 静态方法调用
  — 类对象或实例对象都可以调用；
• 示例：

>>> class Animal():
...     color = "blue"                        # 创建 Animal 类属性 color，并赋值 "blue"    
...     def __init__(self, language):
...         self.language = language
...     @staticmethod
...     def drink(sth):                                               # 静态方法 drink 操作 sth，sth 与 Animal 类没有任何关系
...         print("animal drink {}".format(sth))
...     @staticmethod
...     def has_color():
...         print("animal has {} color".format(Animal.color))         # 静态方法 has_color 调用 Animal 类属性 color
...     @staticmethod
...     def speak():                                                           
...         print("animal speak {}".format(Animal().language))        # 静态方法 speak 调用实例属性 Animal().language
...
>>>
>>> cat = Animal(language="miaomiao")
>>> cat.drink("water")                 # 成功调用 静态方法 drink 操作对象 "water"
animal drink water
>>> cat.has_color()                    # 成功调用 Animal 类属性 color，但是这种操作很鸡肋，因为不可能所有实例的 color 都是 "blue"
animal has blue color
>>> cat.speak()                        # 调用实例属性 Animal().language 失败，这种操作不符合规范
Traceback (most recent call last):
  File "", line 1, in 
  File "", line 13, in speak
TypeError: __init__() missing 1 required positional argument: 'language'

• 静态方法使用场景
  — 静态方法参数不涉及类内部的变量；
  — 静态方法参数与类没有任何关系；
  — 静态方法不关心类中的属性和方法的变化；
  — 可以将静态方法当成一个普通的函数使用；

• 什么是类方法
  — 类方法 使用装饰器@classmethod 进行装饰；
  — 它的第一个参数不是 self，而是 cls，它表示这个类本身；
  — 类方法的第一个参数约定名为 cls；
• 类方法的调用
  — 和实例方法调用一样，先实例化再调用；

>>> class Animal():
...     def __init__(self, language):               # 初始化参数为 language
...         self.language = language
...     @classmethod                                
...     def speak(cls, language):                   # 创建类方法 speak，其返回的是重新被 cls 即类本身处理过的 cls(language)
...         return cls(language)
...     def __str__(self):                          # 这个__str__是魔法方法，其返回的字符串结果是类默认属性，如果去掉这段代码会报错
...         return "animal speak " + self.language
...
>>> cat = Animal(language="miaomiao")               # 实例化一个 cat，并赋予 language 参数 "miaomiao"
>>>
>>> cat_word = cat.speak(language="wangwang gaga")  # cat 调用了类方法 speak()，并重新赋予 language 参数 "wangwang gaga"
>>> print(cat_word)                                  
animal speak wangwang gaga                          # 打印 cat_word，看看小猫说了什么，神奇的一幕出现了，小猫 wangwang gaga 乱叫

— 在上面的代码中我们发现，尽管我们已经给 cat 实例的 language 参数赋值 “miaomiao”，但是由于 speak() 作为静态方法通过 cls(laguage) 对类进行了二次处理，导致 cat.speak(language=”wangwang gaga”) 的打印结果是 animal speak wangwang gaga，我们得到一个 汪汪嘎嘎 乱叫的 猫。

• 类方法的应用场景
  — 类方法的一个应用场景，是上面代码中展示的，改变 实例化类 的 __ init __ 初始参数；
  — 类方法的另一个价值是：“类方法让类模板具有记忆力”，具体来说，在普通情况下不使用类方法对类进行实例化，类本身是不具有记忆性的，只是当一个静态模板被套用多次而已。如果我们想让类在每一次实例化之后，都能记载一些记忆，那么就需要用到类方法；
  — 下面的示例展示 类方法如何让类模板具有记忆力：

>>> class Count():                           # 创建一个计数器 Cout 类
...     current_count = 10000                # 类变量 current_count 代表类当前的 【数值】，初始值为 10000
...     def __init__(self, num):             # num 参数记录的是当前的 【次数】
...         self.num = num
...         self.current_count = self.count()         
...     @classmethod
...     def count(cls):                      # 此处定义静态方法 count
...         cls.current_count += 1           # 每次调用当前数值都会 +1
...         return cls.current_count
...     def __str__(self):                   # 这个__str__是魔法方法，其返回的字符串结果是类默认属性，如果去掉这段代码会报错
...         return f"第 {self.num} 次计数：当前数值为 {self.current_count}"
...
>>>
>>> num = 0
>>> while num