类方法和实例方法区别_Python中的静态方法、类方法以及对象方法（实例方法）...

自己喜欢，

就好。

通过一个例子来区分三者的区别和使用场景：

定义一个Date类来输出日期：

class Date:

    # 构造函数
    def __init__(self, year, month, day):
        self.year = year
        self.month = month
        self.day = day

再在类中重新定义它的__str__方法，这样在打印的时候就可以直接打印出日期：

class Date:

    # 构造函数
    def __init__(self, year, month, day):
        self.year = year
        self.month = month
        self.day = day

    def __str__(self):
        return "{year}/{month}/{day}".format(year = self.year, month = self.month,day = self.day)

运行一下：

class Date:

    # 构造函数
    def __init__(self, year, month, day):
        self.year = year
        self.month = month
        self.day = day

    def __str__(self):
        return "{year}/{month}/{day}".format(year = self.year, month = self.month,day = self.day)

if __name__ == "__main__":
    new_day = Date(2018,12,30)
    print(new_day)

运行结果：

在上面的代码中__init__和__str__都是实例方法也就是对象方法。
再定义一个实例方法：

class Date:

    # 构造函数
    def __init__(self, year, month, day):
        self.year = year
        self.month = month
        self.day = day

    def tomorrow(self):
        self.day += 1

    def __str__(self):
        return "{year}/{month}/{day}".format(year = self.year, month = self.month,day = self.day)

if __name__ == "__main__":
    new_day = Date(2018,12,30)
    new_day.tomorrow()
    print(new_day)

运行结果：

在上面的代码中，传递给Date的值是2018、12、30三个数字，如果希望传递进来的是一个日期的字符串，如“2018-12-30”。
首先想到的方法就是split分割字符串，然后把对应的值赋给变量。
先在类外实现这个功能：

date_str = "2018-12-30"

    year, month, day = tuple(date_str.split("-"))
    print(year, month, day)
    print(type(year))

运行结果：

image.png

这时候year、month、day的值的类型都是字符串，所以赋值的时候要进行类型转换：

date_str = "2018-12-30"

    year, month, day = tuple(date_str.split("-"))
    print(year, month, day)
    print(type(year))
    new_day = Date(int(year), int(month), int(day))
    print(new_day)

运行结果：

image.png

也就是说，每一次实例化的时候，都要运行上面的分割字符串，并把值赋给对应的变量这段代码，所以就可以在类中定义一个静态方法，也就是在def的上一行加上@staticmethod这句

class Date:

    # 构造函数
    def __init__(self, year, month, day):
        self.year = year
        self.month = month
        self.day = day

    def tomorrow(self):
        self.day += 1

    @staticmethod
    def parse_from_string(data_str):
        year, month, day = tuple(date_str.split("-"))
        return Date(int(year), int(month), int(day))

    def __str__(self):
        return "{year}/{month}/{day}".format(year = self.year, month = self.month,day = self.day)

这个静态方法接收不需要self，也不需要接收class对象，与普通的函数用法相同。

  new_day = Date.parse_from_string(date_str)

    print(new_day)

运行一下：

image.png

这个静态方法实现起来更简单，也更易懂，缺点是，硬编码。(return硬编码，把Date直接返回了，也就是如果一旦改变了类名，这个位置也必须要修改)，要想解决这个问题可以使用类方法。

class Date:

    # 构造函数
    def __init__(self, year, month, day):
        self.year = year
        self.month = month
        self.day = day

    def tomorrow(self):
        self.day += 1

    @staticmethod
    def parse_from_string(data_str):
        year, month, day = tuple(date_str.split("-"))
        return Date(int(year), int(month), int(day))

    @classmethod
    def from_string(cls,date_str):
        year, month, day = tuple(date_str.split("-"))
        return cls(int(year), int(month), int(day))

    def __str__(self):
        return "{year}/{month}/{day}".format(year = self.year, month = self.month,day = self.day)

类方法和实例方法的区别是：
类方法首先传递进来的是类，也就是cls，它是class的简写，cls改成self也是不会有问题的。

既然这样类方法就完全可以取代静态方法了吗。

如果想要判断传递进来的字符串是否是合法的时间，那么就没有必要把类传递到方法中，这时候使用静态方法更方便一些。

class Date:

    # 构造函数
    def __init__(self, year, month, day):
        self.year = year
        self.month = month
        self.day = day

    def tomorrow(self):
        self.day += 1

    @staticmethod
    def parse_from_string(data_str):
        year, month, day = tuple(date_str.split("-"))
        return Date(int(year), int(month), int(day))

    @staticmethod
    def valid_str(data_str):
        year, month, day = tuple(date_str.split("-"))
        if int(year) > 0 and int(month) > 0 and int(month) < 13 and int(day) > 0 and int(day) < 32:
            return True
        else:
            return False

    @classmethod
    def from_string(cls,date_str):
        year, month, day = tuple(date_str.split("-"))
        return cls(int(year), int(month), int(day))

    def __str__(self):
        return "{year}/{month}/{day}".format(year = self.year, month = self.month,day = self.day)

这里只是简单实现了一下判断，实际在判断字符串是否是合法的时间比这要复杂得多。

       new_day = Date.from_string(date_str)

    print(new_day)
    print(new_day.valid_str(date_str))

运行一下：

作者：李白开水
来源：简书