当前位置：&>&&>&&>&
python实例方法、静态方法、类方法、类变量与实例变量
发布时间：编辑：
本文介绍了python中实例方法、静态方法、类方法、类变量和实例变量的相关内容，包括大量的python实例代码，有需要的朋友参考下。
注：使用的是Python2.7。
一、实例方法
实例方法就是类的实例能够使用的方法。
复制代码 代码示例:
class Foo:
&&& def __init__(self, name):
&&&&&&& self.name = name
&&& def hi(self):
&&&&&&& print self.name
if __name__ == '__main__':
&&& foo01 = Foo('letian')
&&& foo01.hi()
&&& print type(Foo)
&&& print type(foo01)
&&& print id(foo01)
&&& print id(Foo)
运行结果：
&type 'classobj'&
&type 'instance'&
可以看到，Foo的type为classobj（类对象，中定义的类本身也是对象），foo01的type为instance（实例）。而hi()是实例方法，所以foo01.hi()会输出'letian'。实例方法的第一个参数默认为self，代指实例。self不是一个关键字，而是约定的写法。init()是生成实例时默认调用的实例方法。将Foo的定义改为以下形式：
复制代码 代码示例:
class Foo:
&&& def __init__(this, name):
&&&&&&& this.name = name
&&& def hi(here):
&&&&&&& print here.name
运行依然正确。 内置函数id用来查看对象的标识符，下面是其doc内容：
复制代码 代码示例:
&&& print id.__doc__
id(object) -& integer
Return the identity of an object.& This is guaranteed to be unique among
simultaneously existing objects.& (Hint: it's the object's memory address.)
二、静态方法
静态方法是一种普通函数，就位于类定义的命名空间中，它不会对任何实例类型进行操作。使用装饰器@staticmethod定义静态方法。类对象和实例都可以调用静态方法：
复制代码 代码示例:
class Foo:
&&& def __init__(self, name):
&&&&&&& self.name = name
&&& def hi(self):
&&&&&&& print self.name
&&& @staticmethod
&&& def add(a, b):
&&&&&&& print a + b
if __name__ == '__main__':
&&& foo01 = Foo('letian')
&&& foo01.hi()
&&& foo01.add(1,2)
&&& Foo.add(1, 2)
运行结果：
注意，很多编程语言不允许实例调用静态方法。
三、类方法
类方法是将类本身作为对象进行操作的方法。类方法使用@classmethod装饰器定义，其第一个参数是类，约定写为cls。类对象和实例都可以调用类方法：
复制代码 代码示例:
class Foo:
&&& name = 'letian '
&&& @classmethod
&&& def hi(cls, x):
&&&&&&& print cls.name * x
if __name__ == '__main__':
&&& foo01 = Foo()
&&& foo01.hi(2)
&&& Foo.hi(3)
运行结果：
letian letian
letian letian letian
注意，很多其他的编程语言不允许实例调用类方法。
super用来执行父类中的函数，例如：
复制代码 代码示例:
class Foo(object):
&&& def hi(self):
&&&&&&& print 'hi,Foo'
class Foo2(Foo):
&&& def hi(self):
&&&&&&& super(Foo2, self).hi()
if __name__ == '__main__':
&&& foo2 = Foo2()
&&& foo2.hi()
运行结果：
注意，Foo类必须继承某个类（并且这个继承链开始于object类），否则会报错。
如果改成下面的形式：
复制代码 代码示例:
class Foo:
&&& def hi(self):
&&&&&&& print 'hi,Foo'
class Foo2(Foo):
&&& def hi(self):
&&&&&&& super(Foo2, self).hi()
if __name__ == '__main__':
&&& foo2 = Foo2()
&&& foo2.hi()
运行时报错：
TypeError: must be type, not classobj
关于super，具体请见http://docs.python.org/2/library/functions.html?highlight=super#super以及super.doc。
五、类变量和实例变量
类变量定义在类的定义之后，实例变量则是以为self.开头。
复制代码 代码示例:
class Foo(object):
&&& val = 0
&&& def __init__(self):
&&&&&&& self.val = 1
if __name__ == '__main__':
&&& foo = Foo()
&&& print foo.val
&&& print Foo.val
运行结果为：
实例也能够访问类变量，如下：
复制代码 代码示例:
class Foo(object):
&&& val = 0
&&& def __init__(self):
&&&&&&& pass
if __name__ == '__main__':
&&& foo = Foo()
&&& print foo.val
&&& print Foo.val
运行结果：
另外，可以通过以下方式访问类变量：
复制代码 代码示例:
class Foo(object):
&&& val = 3
&&& def __init__(self):
&&&&&&& print self.__class__.val
if __name__ == '__main__':
&&& foo = Foo()
运行结果：
还可以这样：
复制代码 代码示例:
class Foo(object):
&&& val = 3
&&& def __init__(self):
&&&&&&& pass
&&& @classmethod
&&& def echo(cls):
&&&&&&& print cls.val
if __name__ == '__main__':
&&& Foo.echo()
运行结果：
六、如何调用父类的
子类（派生类）并不会自动调用父类（基类）的init方法，例如：
复制代码 代码示例:
class Foo(object):
&&& def __init__(self):
&&&&&&& self.val = 1
class Foo2(Foo):
&&& def __init__(self):
&&&&&&& print self.val
if __name__ == '__main__':
&&& foo2 = Foo2()
运行时报错。
调用父类的init方法有两种，第一种：
复制代码 代码示例:
class Foo(object):
&&& def __init__(self):
&&&&&&& self.val = 1
class Foo2(Foo):
&&& def __init__(self):
&&&&&&& Foo.__init__(self)
&&&&&&& print self.val
if __name__ == '__main__':
&&& foo2 = Foo2()
复制代码 代码示例:
class Foo(object):
&&& def __init__(self):
&&&&&&& self.val = 1
class Foo2(Foo):
&&& def __init__(self):
&&&&&&& super(Foo2,self).__init__()
&&&&&&& print self.val
if __name__ == '__main__':
&&& foo2 = Foo2()
这两种方法的运行结果均为：
不过这两种方法是有区别的。
与 python实例方法、静态方法、类方法、类变量与实例变量 有关的文章
本文标题：
本页链接：
12345678910
12345678910类和实例 - 廖雪峰的官方网站
面向对象最重要的概念就是类（Class）和实例（Instance），必须牢记类是抽象的模板，比如Student类，而实例是根据类创建出来的一个个具体的“对象”，每个对象都拥有相同的方法，但各自的数据可能不同。
仍以Student类为例，在Python中，定义类是通过class关键字：
class Student(object):
class后面紧接着是类名，即Student，类名通常是大写开头的单词，紧接着是(object)，表示该类是从哪个类继承下来的，继承的概念我们后面再讲，通常，如果没有合适的继承类，就使用object类，这是所有类最终都会继承的类。
定义好了Student类，就可以根据Student类创建出Student的实例，创建实例是通过类名+()实现的：
&&& bart = Student()
&__main__.Student object at 0x10a67a590&
&&& Student
&class '__main__.Student'&
可以看到，变量bart指向的就是一个Student的object，后面的0x10a67a590是内存地址，每个object的地址都不一样，而Student本身则是一个类。
可以自由地给一个实例变量绑定属性，比如，给实例bart绑定一个name属性：
&&& bart.name = 'Bart Simpson'
&&& bart.name
'Bart Simpson'
由于类可以起到模板的作用，因此，可以在创建实例的时候，把一些我们认为必须绑定的属性强制填写进去。通过定义一个特殊的__init__方法，在创建实例的时候，就把name，score等属性绑上去：
class Student(object):
def __init__(self, name, score):
self.name = name
self.score = score
注意到__init__方法的第一个参数永远是self，表示创建的实例本身，因此，在__init__方法内部，就可以把各种属性绑定到self，因为self就指向创建的实例本身。
有了__init__方法，在创建实例的时候，就不能传入空的参数了，必须传入与__init__方法匹配的参数，但self不需要传，Python解释器自己会把实例变量传进去：
&&& bart = Student('Bart Simpson', 59)
&&& bart.name
'Bart Simpson'
&&& bart.score
和普通的函数相比，在类中定义的函数只有一点不同，就是第一个参数永远是实例变量self，并且，调用时，不用传递该参数。除此之外，类的方法和普通函数没有什么区别，所以，你仍然可以用默认参数、可变参数和关键字参数。
面向对象编程的一个重要特点就是数据封装。在上面的Student类中，每个实例就拥有各自的name和score这些数据。我们可以通过函数来访问这些数据，比如打印一个学生的成绩：
&&& def print_score(std):
print '%s: %s' % (std.name, std.score)
&&& print_score(bart)
Bart Simpson: 59
但是，既然Student实例本身就拥有这些数据，要访问这些数据，就没有必要从外面的函数去访问，可以直接在Student类的内部定义访问数据的函数，这样，就把“数据”给封装起来了。这些封装数据的函数是和Student类本身是关联起来的，我们称之为类的方法：
class Student(object):
def __init__(self, name, score):
self.name = name
self.score = score
def print_score(self):
print '%s: %s' % (self.name, self.score)
要定义一个方法，除了第一个参数是self外，其他和普通函数一样。要调用一个方法，只需要在实例变量上直接调用，除了self不用传递，其他参数正常传入：
&&& bart.print_score()
Bart Simpson: 59
这样一来，我们从外部看Student类，就只需要知道，创建实例需要给出name和score，而如何打印，都是在Student类的内部定义的，这些数据和逻辑被“封装”起来了，调用很容易，但却不用知道内部实现的细节。
封装的另一个好处是可以给Student类增加新的方法，比如get_grade：
class Student(object):
def get_grade(self):
if self.score &= 90:
return 'A'
elif self.score &= 60:
return 'B'
return 'C'
同样的，get_grade方法可以直接在实例变量上调用，不需要知道内部实现细节：
&&& bart.get_grade()
'C'
类是创建实例的模板，而实例则是一个一个具体的对象，各个实例拥有的数据都互相独立，互不影响；
方法就是与实例绑定的函数，和普通函数不同，方法可以直接访问实例的数据；
通过在实例上调用方法，我们就直接操作了对象内部的数据，但无需知道方法内部的实现细节。
和静态语言不同，Python允许对实例变量绑定任何数据，也就是说，对于两个实例变量，虽然它们都是同一个类的不同实例，但拥有的变量名称都可能不同：
&&& bart = Student('Bart Simpson', 59)
&&& lisa = Student('Lisa Simpson', 87)
&&& bart.age = 8
&&& bart.age
&&& lisa.age
Traceback (most recent call last):
File &&stdin&&, line 1, in &module&
AttributeError: 'Student' object has no attribute 'age'
Make a Comment
Sign In to Make a Comment
You can sign in directly without register:
You need authorize to allow connect to your social passport for the first time.
WARNING: You are using an old browser that does not support HTML5.
Please choose a modern browser ( /
/ ) to get a good experience.收藏，1.8k 浏览
问题对人有帮助，内容完整，我也想知道答案
问题没有实际价值，缺少关键内容，没有改进余地
有这么一个场景：
在main模块的Main类中读取本地的一个配置文件，并储存到变量中。
而这个项目中的许多模块都需要依赖于这个配置变量，总不能每次用到都去读取硬盘中的配置文件吧？难道把这个变量在所有用到的类的构造函数中一直往下传？
所以。。Python中如何实现模块间共享的静态变量呢？
抱歉忘记说了，该配置文件是一个希望能够提供给用户进行配置的json文件。
答案对人有帮助，有参考价值
答案没帮助，是错误的答案，答非所问
python里可以把模块看成一个单例的对象，模块级别定义的变量都可以直接模块名.变量名这样子访问。
根据你的需求只需要定义一个settings.py 在需要的地方import settings 就好了
同步到新浪微博
不要错过该问题的后续解决方案
如果你没找到答案，记得登录关注哦，大家会尽全力帮你解决的 ^___^
分享到微博？
关闭理由：
删除理由：
忽略理由：
推广（招聘、广告、SEO 等）方面的内容
与已有问题重复（请编辑该提问指向已有相同问题）
答非所问，不符合答题要求
宜作评论而非答案
带有人身攻击、辱骂、仇恨等违反条款的内容
无法获得确切结果的问题
非开发直接相关的问题
非技术提问的讨论型问题
其他原因（请补充说明）
举报理由：
推广（招聘、广告、SEO 等）方面的内容
带有人身攻击、辱骂、仇恨等违反条款的内容
与已有问题重复（请编辑该提问指向已有相同问题）
内容质量差，或不适合在本网站出现
答非所问，不符合答题要求
其他原因（请补充说明）
补充说明：页面导航：
→ 正文内容 Python使用函数默认值实现函数静态变量
Python使用函数默认值实现函数静态变量的方法
这篇文章主要介绍了Python使用函数默认值实现函数静态变量的方法,是很实用的功能,需要的朋友可以参考下
本文实例展示了Python使用函数默认值实现函数静态变量的方法，具体方法如下：
一、Python函数默认值
Python函数默认值的使用可以在函数调用时写代码提供方便，很多时候我们只要使用默认值就可以了。 所以函数默认值在python中用到的很多，尤其是在类中间，类的初始化函数中一帮都会用到默认值。 使用类时能够方便的创建类，而不需要传递一堆参数。
只要在函数参数名后面加上 ”=defalut_value”，函数默认值就定义好了。有一个地方需要注意的是，有默认值的参数必须在函数参数列表的最后，不允许将没有默认值的参数放在有默认值的参数后，因为如果你那样定义的话，解释器将不知道如何去传递参数。
先来看一段示例代码：
def ask_ok(prompt, retries=4, complaint='Yes or no, please!'):
while True:
ok = raw_input(prompt)
if ok in ('y', 'ye', 'yes'): return True
if ok in ('n', 'no', 'nop', 'nope'): return False
retries = retries - 1
if retries & 0: raise IOError, 'refusenik user'
print complaint
你调用上面的函数时，可以修改重试次数和输出的提示语言，如果你比较懒得话，那么什么都不用改。
二、python使用函数默认值来实现函数静态变量的功能
Python中是不支持静态变量的，但是我们可以通过函数的默认值来实现静态变量的功能。
当函数的默认值是内容是可变的类时，类的内容可变，而类的名字没变。（相当于开辟的内存区域没有变，而其中内容可以变化）。
这是因为python中函数的默认值只会被执行一次，(和静态变量一样，静态变量初始化也是被执行一次。）这就是他们的共同点。
再来看下面的程序片段：
def f(a, L=[]):
L.append(a)
print f(1)
print f(2)
print f(3)
print f(4,['x'])
print f(5)
其输出结果是：
[1, 2, 3, 5]
前面的好理解，为什么最后 “print f(5)”的输出是 “[1, 2, 3, 5]”呢？
这是因为 “print f(4,['x'])”时，默认变量并没有被改变，因为默认变量的初始化只是被执行了一次(第一次使用默认值调用)，初始化执行开辟的内存区（我们可以称之为默认变量）没有被改变，所以最后的输出结果是“[1, 2, 3, 5]”。
相信本文所述实例对大家Python程序设计有一定的帮助作用。
您可能感兴趣的文章:
上一篇：下一篇：
最 近 更 新
热 点 排 行
12345678910页面导航：
→ 正文内容 python类的静态变量
python实现类的静态变量用法实例
这篇文章主要介绍了python实现类的静态变量用法,实例分析了Python中基于数组实现静态队列的相关使用技巧,需要的朋友可以参考下
本文实例讲述了python类的静态变量用法。分享给大家供大家参考。具体分析如下：
这里使用静态变量目的是在类中实现一个静态的队列，这里用数组实现，任何时候插入到队列中的数据不会和类的实例有直接关系。
__author__ = 'Administrator'
class CaptchaImage:
def queue(self,arr=list()):
return arr
def InsertCode(self,code):
self.queue().append(code)
if __name__=='__main__':
c = CaptchaImage()
c.InsertCode(1)
b=CaptchaImage()
b.InsertCode(2)
print(b.queue())
print(c.queue())
代码执行输出结果为：
希望本文所述对大家的Python程序设计有所帮助。
您可能感兴趣的文章:
上一篇：下一篇：
最 近 更 新
热 点 排 行
12345678910}