了解 Python 中类方法和静态方法之间的区别可能很棘手。让我们分解一下它们的工作原理、何时使用每个组件，并探索实际示例。

主要区别

首先，让我们看看每个 Secret 的基本语法和行为：

class Example:
    class_variable = "I'm shared across all instances"
    
    def __init__(self, instance_var):
        self.instance_var = instance_var
    
    @classmethod
    def class_method(cls):
        print(f"Class method accessing class variable: {cls.class_variable}")
        return cls("Created via class method")
    
    @staticmethod
    def static_method():
        print("Static method can't access class or instance variables directly")
        return "Static result"
    
    def instance_method(self):
        print(f"Instance method accessing instance var: {self.instance_var}")

# Using the methods
example = Example("instance value")

# Class method can access class state
Example.class_method()  # Outputs: "Class method accessing class variable: I'm shared across all instances"

# Static method is independent
Example.static_method()  # Outputs: "Static method can't access class or instance variables directly"

# Instance method needs an instance
example.instance_method()  # Outputs: "Instance method accessing instance var: instance value"

主要区别：
1. 类方法接收类作为第一个参数 （'cls'）
2. 静态方法不接收任何自动参数
3. 类方法可以访问和修改类状态
4. 静态方法如果不显式传递类或实例状态，就无法访问它们

实际示例：日期解析

下面是一个实际示例，显示了何时使用每种类型：

from datetime import date, datetime

class DateConverter:
    date_format = "%Y-%m-%d"  # Class variable for date format
    
    def __init__(self, date_str):
        self.date = datetime.strptime(date_str, self.date_format).date()
    
    @classmethod
    def from_timestamp(cls, timestamp):
        """
        Creates DateConverter from a timestamp.
        Uses cls to ensure inheritance works properly.
        """
        date_str = datetime.fromtimestamp(timestamp).strftime(cls.date_format)
        return cls(date_str)
    
    @staticmethod
    def is_valid_date_str(date_str):
        """
        Checks if a string is a valid date.
        Doesn't need class or instance state.
        """
        try:
            datetime.strptime(date_str, DateConverter.date_format)
            return True
        except ValueError:
            return False
    
    def __str__(self):
        return self.date.strftime(self.date_format)

# Using the converter
try:
    # Normal initialization
    date1 = DateConverter("2024-03-15")
    print(f"Converted date: {date1}")
    
    # Using class method
    date2 = DateConverter.from_timestamp(1710428400)  # March 15, 2024
    print(f"From timestamp: {date2}")
    
    # Using static method
    valid = DateConverter.is_valid_date_str("2024-03-15")
    print(f"Is valid date? {valid}")
    
    invalid = DateConverter.is_valid_date_str("2024-99-99")
    print(f"Is valid date? {invalid}")
    
except ValueError as e:
    print(f"Error: {e}")

为什么这种设计有意义：
- 类方法 'from_timestamp' 需要访问类的日期格式
- 静态方法 'is_valid_date_str' 执行独立验证
- 类的功能与继承保持一致

Factory Methods：何时使用 Class Methods

类方法非常适合工厂模式：

class User:
    def __init__(self, first_name, last_name, email, role):
        self.first_name = first_name
        self.last_name = last_name
        self.email = email
        self.role = role
    
    @classmethod
    def create_admin(cls, first_name, last_name):
        """Factory method for creating admin users"""
        email = f"{first_name.lower()}.{last_name.lower()}@admin.com"
        return cls(first_name, last_name, email, "admin")
    
    @classmethod
    def create_guest(cls):
        """Factory method for creating guest users"""
        return cls("Guest", "User", "guest@example.com", "guest")
    
    @staticmethod
    def validate_email(email):
        """Email validation doesn't need class state"""
        import re
        pattern = r'^[\w\.-]+@[\w\.-]+\.\w+