python 实例方法 类方法 静态方法

1、 Python中的7种可调用对象

Python中有七种可调用对象，可调用对象可使用内置函数callable来检测

1. 用户自定义的函数：使用def语句或者lambda表达式创建的函数。
2. 内置函数：使用C语言实现的函数，如len、sum或者time.strftime
3. 内置方法：使用C语言实现的方法，如dict.get()
4. 类方法：在类的定义体中定义的函数
5. 类：在调用类时会运行类的__new__方法创建一个实例，然后运行__init__方法，初始化实例，最后把实例返回给调用方。Python中没有new运算符，所以调用类相当于调用函数。
6. 类的实例：如果类定义了__call__方法，那么它的实例可以作为函数进行调用。并且__call__方法可以进行自定义重写。
7. 生成器函数：使用yield关键字的函数或方法。调用生成器函数返回的是生成器对象。

2、python 类方法 静态方法

属性：

　　公有属性  （属于类，每个类一份）

　　普通属性  （属于对象，每个对象一份）

　　私有属性  （属于对象，跟普通属性相似，只是不能通过对象直接访问） 

方法：（按作用）

　　构造方法：__init__()

　　析构函数：__del__()

python中的方法：

        类方法也可以进行细致的划分，具体可分为类方法、实例方法和静态方法。采用 @classmethod 修饰的方法为类方法；采用 @staticmethod 修饰的方法为静态方法；不用任何修改的方法为实例方法。

其中 @classmethod 和 @staticmethod 都是函数装饰器

      接下来介绍这 3 种类方法。

　　实例方法（普通方法）：默认有个self参数，且只能被对象调用。

　　静态方法: 用 @staticmethod 装饰的不带 self 参数的方法叫做静态方法，类的静态方法可以没有参数，可以直接使用类名调用，不需要创建对象，不会隐式传递self，也不能访问类属性。

　　类方法：用 @classmethod 装饰的带 self 参数的方法叫做类方法，默认有个 cls 参数，可以被类和对象调用，类方法中的self是类本身，调用方法时传的值也必须是类的公有属性，就是说类方法只能操作类本身的公有字段

　　实例方法中的特殊方法：

        1、私有方法（方法前面加两个下划线）

        2、属性方法：property属性函数(@property修饰)，它是实例方法中的特殊方法。

类实例方法

通常情况下，在类中定义的方法默认都是实例方法，类的构造方法理论上也属于实例方法，只不过它比较特殊。
比如，下面的类中就用到了实例方法：

class Test(object):
#类构造方法，也属于实例方法
    def __init__(self):
        self.name = "name"
        self.add = ""
    # 下面定义了一个say实例方法
    def call(self):
        print("call 实例方法")

实例方法最大的特点就是，它最少也要包含一个 self 参数，用于绑定调用此方法的实例对象（Python 会自动完成绑定）。实例方法通常会用类对象直接调用，例如：

test = Test()
test.call()

运行结果：

call 实例方法

实例方法的调用方式其实有 2 种，既可以采用类对象调用，也可以直接通过类名调用。

采用类对象调用即像上面那样，不需要管self参数，它会自动绑定到类对象上，Python 也支持使用类名调用实例方法，但此方式需要手动给 self 参数传值。例如：

#类名调用实例方法，需手动给 self 参数传值
test = Test()
Test.call(test) #，可以看到，通过手动将 test 这个类对象传给了 self 参数，使得程序得以正确执行。实际上，这里调用实例方法的形式完全是等价于 test.call()。

运行结果为：

正在调用 call() 实例方法

上面是给call()方法传入了一个类，如果call方法中没有操作类的成员变量则传参时可以传入任意参数都不会报错，但如果操作了成员变量，则传入的参数一定要是个类对象，因为这样才会有有效的的数据成员

class Test(object):
#类构造方法，也属于实例方法
    def __init__(self):
        self.name = "name"
        self.add = ""
    # 下面定义了一个say实例方法
    def call(self):
        print("call 实例方法")
    
    def printName(self):
        print('name:',self.name)
    
test = Test()
Test.call("any") #不会报错

Test.printName("any") #报错

输出：

call 实例方法
Traceback (most recent call last):....

可以看到，"any" 这个字符串传给了 call() 方法的 self 参数。无论是call() 方法中使用 self 参数调用其它类方法，还是使用 self 参数定义新的实例变量，胡乱的给 self 参数传参都将会导致程序运行崩溃。

总的来说，Python 中允许使用类名直接调用实例方法，但必须手动为该方法的第一个 self 参数传递参数，这种调用方法的方式被称为“非绑定方法”。

类方法

使用装饰器@classmethod。

类方法和实例方法相似，它最少也要包含一个参数，只不过类方法中通常将其命名为 cls，Python 会自动将类本身绑定给 cls 参数（注意，绑定的不是类对象）。也就是说，我们在调用类方法时，无需显式为 cls 参数传参。

和 self 一样，cls 参数的命名也不是规定的（可以随意命名），只是 Python 程序员约定俗称的习惯而已。

和实例方法最大的不同在于，类方法需要使用＠classmethod修饰符进行修饰，类方法不能直接操作实例属性，必须通过类实例才能操作。

class Test(object):
    #类构造方法，也属于实例方法
    def __init__(self):
        self.property = "property"
    #下面定义了一个类方法
    @classmethod
    def printProperty(cls):
        print("print property:",cls)

注意，如果没有 ＠classmethod，则 Python 解释器会将 printProperty() 方法认定为实例方法，而不是类方法。

类方法推荐使用类名直接调用，当然也可以使用实例对象来调用（不推荐）。例如，在上面 Test 类的基础上，在该类外部添加如下代码：

    #使用类名直接调用类方法
    Test.printProperty()
    #使用类对象调用类方法
    test = Test()
    test.printProperty()

 原则上，类方法是将类本身作为对象进行操作的方法。假设有个方法，且这个方法在逻辑上采用类本身作为对象来调用更合理，那么这个方法就可以定义为类方法。另外，如果需要继承，也可以定义为类方法。

如下场景：（转自：https://www.cnblogs.com/geogre123/p/10142510.html）

假设我有一个学生类和一个班级类，想要实现的功能为：
    执行班级人数增加的操作、获得班级的总人数；
    学生类继承自班级类，每实例化一个学生，班级人数都能增加；
    最后，我想定义一些学生，获得班级中的总人数。

 思考：这个问题用类方法做比较合适，为什么？因为我实例化的是学生，但是如果我从学生这一个实例中获得班级总人数，在逻辑上显然是不合理的。同时，如果想要获得班级总人数，如果生成一个班级的实例也是没有必要的。

 实现：

class ClassTest(object):
    __num = 0

    @classmethod
    def addNum(cls):
        cls.__num += 1

    @classmethod
    def getNum(cls):
        return cls.__num

    # 这里我用到魔术函数__new__，主要是为了在创建实例的时候调用人数累加的函数。
    def __new__(self):
        ClassTest.addNum()
        return super(ClassTest, self).__new__(self)


class Student(ClassTest):
    def __init__(self):
        self.name = ''

a = Student()
b = Student()
print(ClassTest.getNum())

 静态方法

使用装饰器@staticmethod。

静态方法是类中的函数，不需要实例。静态方法主要是用来存放逻辑性的代码，逻辑上属于类，但是和类本身没有关系，也就是说在静态方法中，不会涉及到类中的属性和方法的操作。可以理解为，静态方法是个独立的、单纯的函数，它仅仅托管于某个类的名称空间中，便于使用和维护。

静态方法和函数唯一的区别是，静态方法定义在类这个空间（类命名空间）中，而函数则定义在程序所在的空间（全局命名空间）中。
静态方法没有类似 self、cls 这样的特殊参数，因此 Python 解释器不会对它包含的参数做任何类或对象的绑定。也正因为如此，类的静态方法中无法调用任何类属性和类方法。
静态方法需要使用＠staticmethod修饰，静态方法的调用，既可以使用类名，也可以使用类对象。

例如：

class Test(object):
    #类构造方法，也属于实例方法
    def __init__(self):
        self.name = "name"
        self.add = ""
    # 下面定义了一个say实例方法
    def call(self):
        print("call 实例方法")

    @staticmethod
    def printName():
        #print('name:',self.name) #错误
        print('static method')
    
test = Test()

test.printName()
Test.printName() 

运行结果为：

static method
static method

又如，我想定义一个关于时间操作的类，其中有一个获取当前时间的函数。

import time

class TimeTest(object):
    def __init__(self, hour, minute, second):
        self.hour = hour
        self.minute = minute
        self.second = second

    @staticmethod
    def showTime():
        return time.strftime("%H:%M:%S", time.localtime())


print(TimeTest.showTime())
t = TimeTest(2, 10, 10)
nowTime = t.showTime()
print(nowTime)

如上，使用了静态方法（函数），然而方法体中并没使用（也不能使用）类或实例的属性（或方法）。若要获得当前时间的字符串时，并不一定需要实例化对象，此时对于静态方法而言，所在类更像是一种名称空间。

其实，我们也可以在类外面写一个同样的函数来做这些事，但是这样做就打乱了逻辑关系，也会导致以后代码维护困难。

@property方法 （转自：https://zhuanlan.zhihu.com/p/64487092）

python的@property是python的一种装饰器，是用来修饰方法的。

作用：我们可以使用@property装饰器来创建只读属性，@property装饰器会将方法转换为相同名称的只读属性,可以与所定义的属性配合使用，这样可以防止属性被修改。

使用场景：

1.修饰方法，是方法可以像属性一样访问。

class DataSet(object):
  @property
  def method_with_property(self): ##含有@property
      return 15
  def method_without_property(self): ##不含@property
      return 15

l = DataSet()
print(l.method_with_property) # 加了@property后，可以用调用属性的形式来调用方法,后面不需要加（）。
print(l.method_without_property())  #没有加@property , 必须使用正常的调用方法的形式，即在后面加()

两个都输出为15。

class DataSet(object):
  @property
  def method_with_property(self): ##含有@property
      return 15
l = DataSet()
print(l.method_with_property（）) # 加了@property后，可以用调用属性的形式来调用方法,后面不需要加（）。

如果使用property进行修饰后，又在调用的时候，方法后面添加了()， 那么就会显示错误信息：TypeError: 'int' object is not callable，也就是说添加@property 后，这个方法就变成了一个属性，如果后面加入了()，那么就是当作函数来调用，而它却不是callable（可调用）的。

class DataSet(object):
  def method_without_property(self): ##不含@property
      return 15
l = DataSet()
print(l.method_without_property） #没有加@property , 必须使用正常的调用方法的形式，即在后面加()

没有使用property修饰，它是一种方法，如果把括号去掉，不会报错输出的就会是方法存放的地址。

2.与所定义的属性配合使用，这样可以防止属性被修改。

​ 由于python进行属性的定义时，没办法设置私有属性，因此要通过@property的方法来进行设置。这样可以隐藏属性名，让用户进行使用的时候无法随意修改。

class DataSet(object):
    def __init__(self):
        self._images = 1
        self._labels = 2 #定义属性的名称
    @property
    def images(self): #方法加入@property后，这个方法相当于一个属性，这个属性可以让用户进行使用，而且用户有没办法随意修改。
        return self._images 
    @property
    def labels(self):
        return self._labels
l = DataSet()
#用户进行属性调用的时候，直接调用images即可，而不用知道属性名_images，因此用户无法更改属性，从而保护了类的属性。
print(l.images) # 加了@property后，可以用调用属性的形式来调用方法,后面不需要加（）。

总结

实例方法（普通方法）——————————————————————随着实例属性的改变而改变

类方法（无论是类调用还是实例调用）———————————————都是类属性的值，不随实例属性的变化而变化

静态方法————————————————————————————不可以访问类属性，故直接输出传入方法的值