星期日, 2015-02-01 18:51 — shiping1

1、类中的静态方法

要在类中使用静态方法，需在静态方法前面加上@staticmethod标记符，以表示下面的成员函数是静态函数。

使用静态方法的好处：其函数不需要self参数，可以通过类调用该方法，不需要定义该类实例（当然通过类实例调用也没有问题）。

2、类方法

类方法可以通过类或它的实例来调用,但该方法的第一个参数cls是定义该方法的类对象而不是实例对象。

3、示例

[python] view plaincopy
#coding:utf-8  
class A:  
    def function(self):  
        print "Call nomal method"  
    @staticmethod #静态方法  
    def Function1():  
        print "Call static method"  
    @classmethod #类方法  
    def Function2(cls):   
        print "Call class method"  
        print "cls.__name__ is ",cls.__name__  
  
if __name__ == '__main__':  
    a = A() #类实例化  
    a.function() #调用类中普通方法  
    A.Function1() #调用类中静态方法  
    A.Function2() #调用类中类方法  

结果：

[python] view plaincopy
Call nomal method  
Call static method  
Call class method  
cls.__name__ is  A  

来自 http://blog.csdn.net/maoersong/article/details/32714781

Python中纠结处之其一—— 静态方法、类方法

　　转身投入Python有一周左右的日子了。这一周不能算是很仔细的去研究它，用比喻的话，还在学习骑车的阶段，未及拆车和造车这样高深。

　　但此时就有了让我产生纠结之处。查阅了一些已对这点做比较的博文，对其有所领悟。其实，问题是先来自于Python具有魅力的Decorator。其内置的三个Decorator让我有些许不解。

@staticmethod

@classmethod

@proptey

　　本身来自于Java的先入为主，让我对类方法和静态方法没了区别的概念。但在前人的博文中找到一个例子，让我略有了些领悟

class A(object):
    def foo(self,x):

        print "executing foo(%s,%s)"%(self,x)

    @classmethod
    def class_foo(cls,x):
　　　　　
        print "executing class_foo(%s,%s)"%(cls,x)

    @staticmethod
    def static_foo(x):

        print "executing static_foo(%s)"%x

a = A()

a.foo(1)

a.class_foo(1)
A.class_foo(1)

a.static_foo(1)
A.static_foo(1)

　　输出的结果为

executing foo(<__main__.A object at 0x004E0730>,1)
executing class_foo(<class '__main__.A'>,1)
executing class_foo(<class '__main__.A'>,1)
executing static_foo(1)
executing static_foo(1)

　　首先，实例方法，很清楚，打印了该实例化的对象的信息（在内存中的地址）

　　然后是类方法，cls这个参数打印出的是类A这个对象（Python中任何都是对象），不管是否是实例化的调用

　　最后是静态方法，与调用也无关，并且这个方法不依赖任何对象。

　　一些粗浅的认识：

实例化以后，类方法和静态方法也可以使用（似乎是废话）
类方法和静态方法不能访问需要实例化的属性（）
实例方法是由一个类实例化后产生的，所以能访问实例化后的对象的属性
因为在Python中，类也是对象，所以，类方法相对静态方法的一大特点是可以访问类具有的属性，但是静态方法不行　！

似乎就是这些领悟，后面遇到问题再来更新吧

来自 http://www.cnblogs.com/artoruis/archive/2011/09/13/2174906.html

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

3 条评论

按票数排序按时间排序

4 个回答

李保银，代码者，熟悉python，对javascript感兴趣…

leunggamciu、赵浩翔、胡阳等人赞同

普通方法，静态方法和类方法

这个答案的原文是Difference between @staticmethod and @classmethod in Python
这里的内容是我通知原作者并得到允许的情况下的翻译稿
这个是我的博客文章的地址pyhton静态方法和类方法
类中最常用的方法是实例方法, 即通过通过实例作为第一个参数的方法。
举个例子，一个基本的实例方法就向下面这个:

 
class Kls(object):
    def __init__(self, data):
        self.data = data
    def printd(self):
        print(self.data)
ik1 = Kls('arun')
ik2 = Kls('seema')
ik1.printd()
ik2.printd()

这会给出如下的输出:
seema

然后看一下代码和示例图片:

1，2参数传递给方法.
3 self参数指向当前实例自身.
4 我们不需要传递实例自身给方法，Python解释器自己会做这些操作的.

如果现在我们想写一些仅仅与类交互而不是和实例交互的方法会怎么样呢? 我们可以在类外面写一个简单的方法来做这些，但是这样做就扩散了类代码的关系到类定义的外面. 如果像下面这样写就会导致以后代码维护的困难:

 
def get_no_of_instances(cls_obj):
    return cls_obj.no_inst
class Kls(object):
    no_inst = 0
    def __init__(self):
        Kls.no_inst = Kls.no_inst + 1
ik1 = Kls()
ik2 = Kls()
print(get_no_of_instances(Kls))

输出:
2
@classmethod
我们要写一个只在类中运行而不在实例中运行的方法. 如果我们想让方法不在实例中运行，可以这么做:

 
def iget_no_of_instance(ins_obj):
    return ins_obj.__class__.no_inst
class Kls(object):
    no_inst = 0
    def __init__(self):
    Kls.no_inst = Kls.no_inst + 1
ik1 = Kls()
ik2 = Kls()
print iget_no_of_instance(ik1)

输出
2
在Python2.2以后可以使用@classmethod装饰器来创建类方法.

 
class Kls(object):
    no_inst = 0
    def __init__(self):
        Kls.no_inst = Kls.no_inst + 1
    @classmethod
    def get_no_of_instance(cls_obj):
        return cls_obj.no_inst
ik1 = Kls()
ik2 = Kls()
print ik1.get_no_of_instance()
print Kls.get_no_of_instance()

输出:
2
2
这样的好处是: 不管这个方式是从实例调用还是从类调用，它都用第一个参数把类传递过来.
@staticmethod
经常有一些跟类有关系的功能但在运行时又不需要实例和类参与的情况下需要用到静态方法. 比如更改环境变量或者修改其他类的属性等能用到静态方法. 这种情况可以直接用函数解决, 但这样同样会扩散类内部的代码，造成维护困难.
比如这样:

 
IND = 'ON'
def checkind():
    return (IND == 'ON')
class Kls(object):
     def __init__(self,data):
        self.data = data
def do_reset(self):
    if checkind():
        print('Reset done for:', self.data)
def set_db(self):
    if checkind():
        self.db = 'new db connection'
        print('DB connection made for:',self.data)
ik1 = Kls(12)
ik1.do_reset()
ik1.set_db()

输出:
Reset done for: 12
DB connection made for: 12
如果使用@staticmethod就能把相关的代码放到对应的位置了.

 
IND = 'ON'
class Kls(object):
    def __init__(self, data):
        self.data = data
    @staticmethod
    def checkind():
        return (IND == 'ON')
    def do_reset(self):
        if self.checkind():
            print('Reset done for:', self.data)
    def set_db(self):
        if self.checkind():
            self.db = 'New db connection'
        print('DB connection made for: ', self.data)
ik1 = Kls(12)
ik1.do_reset()
ik1.set_db()

输出:
Reset done for: 12
DB connection made for: 12
下面这个更全面的代码和图示来展示这两种方法的不同
@staticmethod 和 @classmethod的不同

 
class Kls(object):
    def __init__(self, data):
        self.data = data
    def printd(self):
        print(self.data)
    @staticmethod
    def smethod(*arg):
        print('Static:', arg)
    @classmethod
    def cmethod(*arg):
        print('Class:', arg)
 
>>> ik = Kls(23)
>>> ik.printd()
23
>>> ik.smethod()
Static: ()
>>> ik.cmethod()
Class: (<class '__main__.Kls'>,)
>>> Kls.printd()
TypeError: unbound method printd() must be called with Kls instance as first argument (got nothing instead)
>>> Kls.smethod()
Static: ()
>>> Kls.cmethod()
Class: (<class '__main__.Kls'>,)

下面这个图解释了以上代码是怎么运行的:

来自 http://www.zhihu.com/question/20021164

<译文>Python中静态方法和类方法的区别是什么

半尾 2010年06月05日星期六 18:32 | 4212次浏览 | 1条评论

不错的问题，不错的答案，尝试翻译一下，目标还是把静态方法、类方法看得更清楚。

我的困惑： http://www.zeuux.com/group/python/bbs/content/1651/

stackoverflow的问答： http://stackoverflow.com/questions/1669445/what-is-the-difference-between-a-static-method-and-class-method-in-python

有时候真的感觉看英文的文档反而好点，更容易理解。好处如下：

1.英文文档比较原生态，比很多翻译的文章、书籍要强。

2.词汇更贴切，容易理解。

3.专注于当前的内容，不像中文的书籍那样动不动浮躁的往下边的内容瞅了，做不到一目十行反而更加专注。

4.存在阅读速度问题，但是专注阅读反而速度能够提高。

5.书籍质量方面普遍比国内的作者出于赢利要求的质量高。

6.外国作者多注重浅显易懂。并且毕竟有人文、科技、工业化的积淀。

发现这个Stackoverflow不错，它的介绍：

Stack Overflow is a collaboratively edited question and answer site for programmers – regardless of platform or language. It's 100% free, no registration required.

Stack Overflow是一个面向各种语言和平台的程序员的问答协助社区网站。100%免费，并且不需要注册。

问题：What is the difference between a static method and class method in Python?

Python中静态方法和类方法的区别是什么？

问题原文：

Python has two decorators @staticmethod and @classmethod. Could someone one explain the difference between the two or point me to a source where it is documented? When should the staticmethod decorator be used over the classmethod decorator?

问题译文：

Python有两种装饰器静态方法装饰器@staticmethod 和类方法装饰器@classmethod。谁能解释一下两者的区别或者给我指点点文档资料？什么时候该用静态方法装饰器或者类方法装饰器？

Answers：

1.Maybe a bit of example code will help: Notice the difference in the call signatures of foo, class_foo and static_foo:

可能一点例子代码会有帮助：注意调用函数foo、class_foo、static_foo的写法上的区别

class A ( object ):
  def foo ( self , x ):
  print "executing foo(%s,%s)" %( self , x )

  @classmethod
  def class_foo ( cls , x ):
  print "executing class_foo(%s,%s)" %( cls , x )

  @staticmethod
  def static_foo ( x ):
  print "executing static_foo(%s)" % x


a = A ()

Below is the usual way an object instance calls a method. The object instance, a, is implicitly passed as the first argument.

下面是对象实例调用方法的通常做法。对象实例A，隐式传递给方法的第一个参数。（译者加：也就是将实例a对象传递给foo方法的self参数）。

a . foo ( 1 )
# executing foo(<__main__.A object at 0xb7dbef0c>,1)

With classmethods, the class of the object instance is implicitly passed as the first argument instead of self.

类方法的方式，类的对象实例作为隐式的参数传递给第一个参数而不是self。（译者加：也就是将类A传递给对象实例的class_foo方法的cls参数）

a . class_foo ( 1 )
# executing class_foo(<class '__main__.A'>,1)

You can even call class_foo using the class. In fact, if you define something to be a classmethod, it is probably because you intend to call it from the class rather than from a class instance. A.foo(1) would have raised a TypeError.

你甚至可以通过类调用class_foo方法。其实，如果你定义类方法内容，可能你就是想通过类调用它而不是通过对象实例。A.foo(1)会引发类型错误异常（TypeError）。

A . class_foo ( 1 )
# executing class_foo(<class '__main__.A'>,1)

With staticmethods, neither self (the object instance) nor cls (the class) is implicitly passed as the first argument.

而静态方法，既不需要self（对象实例）也不需要cls（类）作为隐藏参数被传递。

a . static_foo ( 1 )
# executing static_foo(1)

foo is just a function, but when you call a.foo you don't just get the function, you get a "curried" version of the function with the object instance "a" bound as the first argument to the function. foo expects 2 arguments, while a.foo only expects 1 argument.

"a" is bound to foo. That is what is meant by the term "bound" below:

foo只是个函数，但是当你调用a.foo时你不是简单的调用函数，实际上你调用了一个加工过的函数版本：绑定对象实例a作为第一个参数的函数。foo需要2个参数，而a.foo只需要一个函数（译者加：对象实例a自动传递给了第一个参数self嘛）

a绑定到了foo。这就是为什么下面的终端输出"bound"的原因。

print ( a . foo )
# <bound method A.foo of <__main__.A object at 0xb7d52f0c>>

With a.class_foo , "a" is not bound to foo, rather the class A is bound to foo.

而a.class_foo，对象实例a是没有绑定到foo的，而是类A绑定到foo。

print ( a . class_foo )
# <bound method type.class_foo of <class '__main__.A'>>

Here, with a staticmethod, even though it is a method, a.static_foo just returns a good 'ole function with no arguments bound. static_foo expects 1 argument, and a.static_foo expects 1 argument too.

这里，静态方法，虽然是一个方法，但是a.static_foo只是一个没有绑定任何参数的完好的函数。static_foo需要1个参数，同样a.static_foo也只需要一个参数。

print ( a . static_foo )
# <function static_foo at 0xb7d479cc>

————————————————————————————

来自 http://www.zeuux.com/blog/content/3030/

普通分类:

python

You are here

Python中类方法和静态方法

1、类中的静态方法

2、类方法

3、示例

Python中纠结处之其一—— 静态方法、类方法

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

4 个回答

李保银，代码者，熟悉python，对javascript感兴趣…

<译文>Python中静态方法和类方法的区别是什么

友情链接

搜索表单

用户登录

You are here

Python中类方法和静态方法

1、类中的静态方法

2、类方法

3、示例

Python中纠结处之其一—— 静态方法、类方法

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

4 个回答

李保银，代码者，熟悉python，对javascript感兴趣…

<译文>Python中静态方法和类方法的区别是什么

友情链接