类方法与静态方法

类内部定义的一般的方法需要由实例调用

class A:
    a = 10
    b = 20
    def __init__(self, a, b):
        self.a = a
        self.b = b

    def sum(self):
        return self.a + self.b

# sum方法只能实例来调用
a = A(1, 2)
# 访问的a、b为实例属性
a.sum()

# 由类来调用，必须传入实例
A.sum(a)

如果使用类本身调用A.sum(1,2)就会报错：TypeError: sum() missing 1 required positional argument: 'self',这是因为普通的方法的第一个参数self是实例自身.

类方法

类方法可以通过类自身进行调用，不需要通过实例

类方法通过@classmethod修饰器实现

# 类方法 @classmethod修饰器装饰
# 第一个参数是类自身
class A:
    a = 10
    b = 20
    
    def __init__(self, a, b):
        self.a = a
        self.b = b

    @classmethod
    def sum(self):
        print(self)
        return self.a + self.b

在上面这段代码中：@classmethod是一个修饰器，将sum方法修饰为类方法

现在sum的第一个参数self传入的是类A自身, 而不是它的实例

# 类方法也可以被实例调用 
# 第一个参数依然是类自身
a = A(1, 2)
a.sum()
# 30

# 通过类直接调用
A.sum()

类方法应用场合

适合用于无需读取实例属性的场合

# 比如一个数据库类
# 从数据库中读取一条记录，或者创建db实例都可以通过类方法，而不是实例完成

class MysqlDriver:
    pass
mysql_driver = MysqlDriver()

class UserModel:
    __tablename__ = "users"
    __db__ = mysql_driver

    @classmethod
    def get_user_by_uid(cls, uid):
        print(cls.__db__)
        print(f"selelct * from {cls.__tablename__} where uid={uid}")
        # return cls.__db__.execute(f"selelct * from {cls.__tablename__} where uid={uid}")

# 直接通过类调用
user_obj = UserModel.get_user_by_uid(uid=100)

类的静态方法

类的静态方法既不传入实例，也不传入类自身，与普通的函数一样，通常可以将一组函数封装在一个类中，方便管理

类的静态方法使用@staticmethod装饰器

# 类的静态方法

class A:
    @staticmethod
    def sum(a, b):
        print(a + b)

    @staticmethod
    def sub(a, b):
        print(a - b)

A.sum(1, 4)
# 输出 5
a = A()
a.sum(1, 4)
# 输出 5

静态方法应用场合

# 通常可以将一组类似功能的函数封装在一个类里，方便维护管理使用
# 比如通常对用户的输入参数或者输出结果需要进行各种验证或者转换
# 就可以将这些验证函数、转换函数封装成一个工具类

class ConvertUtils:
    @staticmethod
    def upstring(value):
        return value.upper()

    @staticmethod
    def lowerstring(value):
        return value.lower()

# 使用工具类函数
print(ConvertUtils.upstring("Python-XP.com"))
print(ConvertUtils.lowerstring("Python-XP.com"))