python类方法静态方法

A. python中的面向对象（进阶）

一、实例方法,类方法,静态方法

我们首先写一个类，里面包含这三种方法。

可以看到，我们用到了两个装饰器。

我们用类和实例分别调用下类方法

我们用类和实例分别调用下静态方法

静态方法其实就是把一个普通的函数写在类里，与直接在外层写一个函数是一样的，本质上是一个函数。

为了方便理解，我们分别打印下这些方法的类型

通过type()查看对象是方法还是函数

此外，还可以通过inspect模块判断某个对象是否是某种类型，返回布尔值。

用法

小Tips：概念理解

直接def定义的，我们叫做函数

把函数放到类里，我们叫做方法

方法可以通过装饰器staticmethod转为（放在方法里的）函数

继承

一个类继承另一个类时，会自动获得另一个类的所有属性和方法，被继承的类称之为父类，新类称为子类。子类拥有父类所有的属性和方法，并且可以定义自己的属性和方法

我们以上边的Rectangle类为父类来试一下

1）完全继承

可以看到，子类完全继承父类后，可以直接调用父类的所有方法。

2）部分继承

部分继承：继承父类后，修改父类的同名方法

我们试一下，Square继承Rectangle后，修改__init__()方法

3）拓展父类的方法

在保留父类中某个方法的代码同时，对方法进行拓展

可以在方法中加入"super().方法名"来实现

4）@property

B. python类方法和静态方法有什么用

主要特点就是需要绑定到一个对象上，python解析器会自动把实例自身传递给方法，如14行所示，而直接使用InstanceMethod.f1()调用方法是不行的。

class InstanceMethod(object):
def __init__(self, a):
self.a = a
def f1(self):
print 'This is {0}.'.format(self)
def f2(self, a):
print 'Value:{0}'.format(a)
if __name__ == '__main__':
# im = InstanceMethod()
im = InstanceMethod('233')
im.f1()
# im.f2()
im.f2(233)

C. python 静态方法可以访问类方法吗

Python的静态方法和类成员方法都可以被类或实例访问，两者概念不容易理清，但还是有区别的：
1）静态方法无需传入self参数，类成员方法需传入代表本类的cls参数；
2）从第1条，静态方法是无法访问实例变量的，而类成员方法也同样无法访问实例变量，但可以访问类变量；
3）静态方法有点像函数工具库的作用，而类成员方法则更接近类似Java面向对象概念中的静态方法。

实现静态方法和类方法的两种方式
一、在Python 2.3及之前，用staticmethod和classmethod类型对象包装实现
例子如下（注意print里的说明）：
class MyClass:
val1 = 'Value 1'
def __init__(self):
self.val2 = 'Value 2'
def staticmd():
print '静态方法，无法访问val1和val2'
smd = staticmethod(staticmd)

def classmd(cls):
print '类方法，类：' + str(cls) + '，val1：' + cls.val1 + '，无法访问val2的值'
cmd = classmethod(classmd)

执行：
>>> mc = MyClass()
>>> mc.smd()
>>> mc.cmd()
>>> MyClass.smd()
>>> MyClass.cmd()

二、在Python 2.4及之后，用装饰器（decorators）实现
装饰器使用@操作符，例子如下：
class MyClass:
val1 = 'Value 1'
def __init__(self):
self.val2 = 'Value 2'

@staticmethod
def staticmd():
print '静态方法，无法访问val1和val2'

@classmethod
def classmd(cls):
print '类方法，类：' + str(cls) + '，val1：' + cls.val1 + '，无法访问val2的值'

D. Python 中的 classmethod 和 staticmethod 有什么具体用途

classmethod：类方法
staticmethod：静态方法

在python中，静态方法和类方法都是可以通过类对象和类对象实例访问。但是区别是：

@classmethod 是一个函数修饰符，它表示接下来的是一个类方法，而对于平常我们见到的则叫做实例方法。类方法的第一个参数cls，而实例方法的第一个参数是self，表示该类的一个实例。

普通对象方法至少需要一个self参数，代表类对象实例

类方法有类变量cls传入，从而可以用cls做一些相关的处理。并且有子类继承时，调用该类方法时，传入的类变量cls是子类，而非父类。对于类方法，可以通过类来调用，就像C.f()，有点类似C＋＋中的静态方法, 也可以通过类的一个实例来调用，就像C().f()，这里C()，写成这样之后它就是类的一个实例了。

静态方法则没有，它基本上跟一个全局函数相同，一般来说用的很少

Example 1:

>>>classa():
@staticmethod
defstaticm():
print'static'
defnormalm(self):
print'nomarl',self
@classmethod
defclassm(cls):
print'class',cls


>>>a1=a()
>>>a1.normalm()
nomarl<__main__.ainstanceat0x84dddec>
>>>a1.staticm()
static
>>>a1.classm()
class__main__.a
>>>type(a)
<type'classobj'>
>>>type(a1)
<type'instance'>

Example 2:

classA(object):
@classmethod
defcm(cls):
print'类方法cm(cls)调用者：',cls.__name__
@staticmethod
defsm():
print'静态方法sm()被调用'
classB(A):
pass
A.cm()
B.cm()
A.sm()
B.sm()
输出：
类方法cm(cls)调用者：A
类方法cm(cls)调用者：B
静态方法sm()被调用
静态方法sm()被调用

@classmethod与@staticmethod的应用实例

#!/usr/bin/envpython
#-*-coding:utf-8-*-
classTClassStatic(object):
obj_num=0
def__init__(self,data):
self.data=data
TClassStatic.obj_num+=1
defprintself(self):
print("self.data:",self.data)
@staticmethod
defsmethod():
print("thenumberofobjis:",TClassStatic.obj_num)
@classmethod
defcmethod(cls):
print("cmethod:",cls.obj_num)
cls.smethod()
defmain():
objA=TClassStatic(10)
objB=TClassStatic(12)
objB.printself()
objA.smethod()
objB.cmethod()
print("------------------------------")
TClassStatic.smethod()
TClassStatic.cmethod()
if__name__=="__main__":
main()

输出结果如下：

('self.data:',12)
('thenumberofobjis:',2)
('cmethod:',2)
('thenumberofobjis:',2)
------------------------------
('thenumberofobjis:',2)
('cmethod:',2)
('thenumberofobjis:',2)

E. python类方法和静态方法的区别

类方法，可以调用类属性。。。用于操作一些类中的公有属性。。。比如这个士兵类，每个士兵都拥有一把相同的枪（gun），都有相同的最大血量(maxhp)，如果在创建对象的时候，一个一个的赋值，就会显得比较多余。。。因此，把这两个属性提出来，作为一个公有属性。。即每个士兵对象，都拥有一把95式步枪，都拥有30的最大血量。。之后声明一个类方法（public），之后可以在类方法中，针对这两个公有的属性进行操作。。。

静态方法，其实更像一个与类几乎无关的函数。。不能操作类中的任何属性。。所以它并不是用来操作类与对象本身的。。。但它又可以被对象调用。。。。比如游戏中，与士兵对话，士兵说话的内容一般存在数据库中。。而当主角与士兵对话，针对数据库查询，并输出到UI界面的相关工作，就可以放在这个函数里。。这样会让代码结构更清晰。。。当然，如果不嫌乱，写在类方法中，也是可以的。。。有人觉得PYTHON的静态方法是鸡肋。。它也确实不是必须的，但有时候却可以让代码结构更清晰。。。比如你有几十种不同的士兵类，你要找到对应每一个类的数据操作相关的函数，就会显得很困难。。。适当使用静态方法，就显得一目了然