Python面向对象之实例方法、类方法和静态方法

class demo:
    """展示三种方法"""

    # 实例方法——第一个参数是self（实例）
    def instance_method(self):
        return f"我是实例方法，self={self}"

    # 类方法——第一个参数是cls（类本身）
    @classmethod
    def class_method(cls):
        return f"我是类方法，cls={cls.__name__}"

    # 静态方法——没有特殊的第一个参数
    @staticmethod
    def static_method():
        return "我是静态方法，没有特殊参数"

d = demo()
print(d.instance_method())   # 通过实例调用
print(demo.class_method())   # 通过类调用（推荐）
print(demo.static_method())  # 通过类调用（推荐）

class bankaccount:
    """银行账户——实例方法操作实例数据"""
    bank_name = "第一银行"  # 类属性

    def __init__(self, owner, balance=0):
        self.owner = owner      # 实例属性
        self.balance = balance  # 实例属性
        self.transactions = []  # 实例属性

    # 这些是实例方法——它们需要访问或修改实例的数据
    def deposit(self, amount):
        """存款——需要修改self.balance"""
        self.balance += amount
        self.transactions.append(f"+{amount}")
        return self.balance

    def withdraw(self, amount):
        """取款——需要访问self.balance"""
        if amount > self.balance:
            raise valueerror("余额不足")
        self.balance -= amount
        self.transactions.append(f"-{amount}")
        return self.balance

    def get_statement(self):
        """获取对账单——需要self的所有数据"""
        return (f"账户持有人: {self.owner}\n"
                f"余额: ¥{self.balance}\n"
                f"交易记录: {', '.join(self.transactions)}")

# 💡 实例方法的使用场景：
# - 需要读写self.xxx（实例属性）
# - 这是最常见的方法类型

class user:
    """用户类——类方法提供替代构造器"""
    _total_users = 0

    def __init__(self, username, email, role="user"):
        self.username = username
        self.email = email
        self.role = role
        user._total_users += 1

    # 类方法——第一个参数是cls（类本身）
    @classmethod
    def create_admin(cls, username, email):
        """创建管理员——替代构造器"""
        return cls(username, email, role="admin")

    @classmethod
    def from_dict(cls, data):
        """从字典创建用户——另一个替代构造器"""
        return cls(data["username"], data["email"], data.get("role", "user"))

    @classmethod
    def from_csv(cls, csv_line):
        """从csv行创建用户"""
        parts = csv_line.strip().split(",")
        return cls(parts[0], parts[1], parts[2] if len(parts) > 2 else "user")

    @classmethod
    def get_total_users(cls):
        """获取用户总数——访问类属性"""
        return cls._total_users

# 使用类方法——多种创建方式
admin = user.create_admin("admin1", "admin@test.com")
user1 = user.from_dict({"username": "zhangsan", "email": "zs@test.com"})
user2 = user.from_csv("lisi,lisi@test.com,vip")

print(admin.role)       # admin
print(user1.username)   # zhangsan
print(user2.role)       # vip
print(user.get_total_users())  # 3

# 💡 类方法的使用场景：
# - 替代构造器（提供多种创建实例的方式）
# - 访问/修改类属性
# - 工厂方法模式

import re

class validator:
    """验证器——静态方法组织工具函数"""

    @staticmethod
    def is_valid_email(email):
        """验证邮箱格式"""
        pattern = r'^[a-za-z0-9._%+-]+@[a-za-z0-9.-]+\.[a-za-z]{2,}$'
        return bool(re.match(pattern, email))

    @staticmethod
    def is_valid_phone(phone):
        """验证手机号"""
        pattern = r'^1[3-9]\d{9}$'
        return bool(re.match(pattern, phone))

    @staticmethod
    def is_strong_password(password):
        """验证密码强度"""
        return (len(password) >= 8
                and any(c.isalpha() for c in password)
                and any(c.isdigit() for c in password))

    @staticmethod
    def clamp(value, min_val, max_val):
        """数值范围限制"""
        return max(min_val, min(value, max_val))

# 使用静态方法——不需要创建实例
print(validator.is_valid_email("test@example.com"))  # true
print(validator.clamp(150, 0, 100))                   # 100

# 💡 静态方法的使用场景：
# - 与类功能相关的工具函数
# - 不需要访问self或cls
# - 放在类中是为了组织代码（命名空间）

# ⌨️ 决策树

class example:
    class_attr = "共享数据"

    def __init__(self):
        self.instance_attr = "私有数据"

    # 问题1：需要访问实例数据(self.xxx)吗？
    # → 是：用实例方法
    def needs_instance_data(self):
        return self.instance_attr  # 访问self

    # 问题2：需要访问类数据(cls.xxx)或创建实例吗？
    # → 是：用类方法
    @classmethod
    def needs_class_data(cls):
        return cls.class_attr  # 访问cls

    # 问题3：功能和类相关但不需要访问self或cls？
    # → 用静态方法
    @staticmethod
    def utility_function(x, y):
        return x + y  # 纯工具函数

    # 问题4：功能和类完全无关？
    # → 不要放在类里——写成模块级函数

from datetime import datetime

class user:
    """用户类——展示三种方法的完整使用"""
    _users = []  # 类属性：所有用户
    _next_id = 1

    def __init__(self, name, email, role="user"):
        self.id = user._next_id
        user._next_id += 1
        self.name = name
        self.email = email
        self.role = role
        self.created_at = datetime.now()
        self._active = true
        user._users.append(self)

    # === 实例方法——操作单个用户 ===
    def deactivate(self):
        self._active = false

    def reactivate(self):
        self._active = true

    def is_active(self):
        return self._active

    def to_dict(self):
        return {
            "id": self.id, "name": self.name,
            "email": self.email, "role": self.role,
            "active": self._active,
            "created_at": self.created_at.isoformat(),
        }

    # === 类方法——管理所有用户 ===
    @classmethod
    def find_by_email(cls, email):
        for user in cls._users:
            if user.email == email:
                return user
        return none

    @classmethod
    def get_active_users(cls):
        return [u for u in cls._users if u.is_active()]

    @classmethod
    def get_by_role(cls, role):
        return [u for u in cls._users if u.role == role]

    # === 静态方法——验证工具 ===
    @staticmethod
    def validate_email(email):
        import re
        return bool(re.match(r'^[\w.-]+@[\w.-]+\.\w{2,}$', email))

    @staticmethod
    def validate_name(name):
        return len(name.strip()) >= 2

# 使用
u1 = user("张三", "zs@test.com")
u2 = user("李四", "ls@test.com", role="admin")
u3 = user("王五", "ww@test.com", role="moderator")
u3.deactivate()

print(f"活跃用户: {len(user.get_active_users())}")   # 2
print(f"管理员: {[u.name for u in user.get_by_role('admin')]}")  # ['李四']
print(user.validate_email("invalid"))  # false