Python 类中的三种方法及使用技巧

目的

最近我在当前项目中使用了类方法，并且我研究了‘实例’、‘类’、‘静态’方法之间的区别。因此，我决定分享这些知识。

这三种方法之间有什么区别？

实例方法：这种方法是最基本的，属于类实例。它将 self 作为第一个参数，通过它可以访问实例变量和其他实例方法。实例方法用于定义依赖于特定实例的行为。

class InstanceEx:  
    def __init__(self, instance_var):  
        self.instance_var = instance_var  
  
    def instance_method(self, number):  
        print(f'Instance variable: {self.instance_var}')  
  
instance_ex = InstanceEx(10)  
instance_ex.instance_method(0) # instance var: 10

类方法: 类方法属于类本身。它使用 @classmethod 装饰器定义，并将类对象（通常命名为 cls）作为第一个参数。即使没有类的实例，也可以调用类方法，并且对于访问类级别的数据非常有用。

class ClsEx:  
    class_var = 0  
  
    @classmethod  
      def class_method(cls):  
        print(f'Class variable: {cls.class_var}')  
        cls.class_var += 1  
  
ClsEx.class_method() # class var: 0  
ClsEx.class_method() # class var: 1

静态方法: 静态方法不依赖于实例变量或类变量。它使用 @staticmethod 装饰器定义，并且不接受 self 或 cls 作为参数。当方法与类的实现细节密切相关但不依赖于类或其实例的状态时，静态方法非常有用。

class StaticEx:  
    @staticmethod  
    def static_method():  
        print('Static methods do not access class variables or instance variables.')  
  
StaticEx.static_method() # Static methods do not access class variables or instance variables.

上面的例子似乎表明这三者的用法完全不同，但你几乎可以用实例方法和类方法实现相同的操作。

class InstanceEx:  
    def __init__(self, instance_var):  
        self.instance_var = instance_var  
  
    def instance_method(self, number):  
        print(f'Instance variable: {self.instance_var}')  
        self.instance_var += number  
  
instance_ex = InstanceEx(0)  
instance_ex.instance_method(10) # instance var: 10  
instance_ex.instance_method(20) # instance var: 20  
instance_ex.instance_method(0) # instance var: 30

class ClsEx:  
    class_var = 0  
  
    @classmethod  
    def class_method(cls, number):  
        print(f'Class variable: {cls.class_var}')  
        cls.class_var += number  
  
ClsEx.class_method(10) # class var: 10  
ClsEx.class_method(20) # class var: 20  
ClsEx.class_method(0) # class var: 30

在上面的例子中，由于使用同一个实例，实例方法允许对实例变量求和。

但是，像上面那样使用静态方法是不允许的，因为静态方法不允许访问类变量。

class StaticEx:  
    static_var = 0  
      
    @staticmethod  
    def static_method(number):  
        print(f'Static method: {static_var}')  
        static_var += number  
  
StaticEx.static_method(10)  
StaticEx.static_method(20)  
StaticEx.static_method(0)  
# UnboundLocalError: local variable 'static_var' referenced before assignment

这三种方法的用例是什么？

基本上，实例方法用于一些不应混合的数据，比如用户数据。

class UserInstance:  
    def __init__(self, name, age):  
        self.name = name  
        self.age = age  
  
    def display_info(self):  
        print(f'Name: {self.name}, Age: {self.age}')  
  
user1 = UserInstance("Alice", 30)  
user2 = UserInstance("Bob", 32)  
  
user1.display_info()  # Name: Alice, Age: 30  
user2.display_info()  # Name: Bob, Age: 32

下面的例子看起来没问题，但是 类_变量_名 和 类_变量_年龄 不是独立的，所以在每次插入姓名和年龄时会被覆盖。因此，如果你想要独立的变量或状态，最好使用实例方法。

class UserCls:  
    class_var_name = ''  
    class_var_age = ''  
    
    @classmethod  
      def display_info(cls, name, age):  
        cls.class_var_name = name  
        cls.class_var_age = age  
        print(f'Name: {cls.class_var_name}, Age: {cls.class_var_age}')  
  
UserCls.display_info("Alice", 30) # Name: Alice, Age: 30  
UserCls.display_info("Bob", 32) # Name: Bob, Age: 32/

另一方面，如果你想要共享相同的数据，最好使用类方法。下面的例子是浅色和深色模式。

首先，我将分享一个实例方法的例子，每个用户设置不同。

class ConfigInstance:  
    def __init__(self, name):  
        self.name = name  
        self.preferences = {}  
  
    def update_preference(self, key, value):  
        self.preferences[key] = value  
  
userInstance1 = ConfigInstance('Alice')  
userInstance2 = ConfigInstance('Bob')  
  
userInstance1.update_preference("theme", "dark")  
userInstance2.update_preference("theme", "light")  
  
print(userInstance1.preferences)  # {'theme': 'dark'}  
print(userInstance2.preferences)  # {'theme': 'light'}

其次，我将分享一个类方法的例子，不同用户共享相同的设置。

因此，在你的应用程序规范中，你可以选择实例方法或类方法。

class ConfigCls:  
    settings = {"theme": "dark"}  
  
    @classmethod  
    def update_setting(cls, key, value):  
        cls.settings[key] = value  
  
ConfigCls.update_setting("theme", "dark")  
print(ConfigCls.settings)  # {'theme': 'dark'}  
  
config1 = ConfigCls()  
config2 = ConfigCls()  
  
print(config1.settings)  # {'theme': 'dark'}  
print(config2.settings)  # {'theme': 'dark'}

最后，我将分享一个静态方法的例子，其中包含独立的设置。

静态方法类似于类中类似方法的修正。

此外，静态方法意味着这些方法是独立的，不与任何类或实例相关。

class Utility:  
    @staticmethod  
    def calculate_percentage(value, total):  
        return (value / total) * 100  
  
percentage = Utility.calculate_percentage(50, 200)  
print(f"Percentage: {percentage}%")  # Percentage: 25.0%

结论

在 Python 中，‘实例’、‘类’、‘静态’方法非常有用，但对于初学者来说很难区分。我希望这篇文章对你有所帮助。