最近学习《Python参考手册》学到Class部分,遇到了类的构造析构部分的问题:
1、什么时候构造?
2、什么时候析构?
3、成员变量如何处理?
4、Python中的共享成员函数如何访问?
------------------------
探索过程:
1、经过查找,Python中没有专用的构造和析构函数,但是一般可以在__init__和__del__分别完成初始化和删除操作,可用这个替代构造和析构。还有一个__new__用来定制类的创建过程,不过需要一定的配置,此处不做讨论。
2、类的成员函数默认都相当于是public的,但是默认开头为__的为私有变量,虽然是私有,但是我们还可以通过一定的手段访问到,即Python不存在真正的私有变量。如:
- __priValue = 0 # 会自动变形为"_类名__priValue"的成员变量
3、由于Python的特殊性,全局成员变量是共享的,所以类的实例不会为它专门分配内容空间,类似于static,具体使用参看下面的例子。
测试1:
- # encoding:utf8
- class NewClass(object):
- num_count = 0 # 所有的实例都共享此变量,即不单独为每个实例分配
- def __init__(self,name):
- self.name = name
- NewClass.num_count += 1
- print name,NewClass.num_count
- def __del__(self):
- NewClass.num_count -= 1
- print "Del",self.name,NewClass.num_count
- def test():
- print "aa"
- aa = NewClass("Hello")
- bb = NewClass("World")
- cc = NewClass("aaaa")
- print "Over"
调试运行:
- Hello 1
- World 2
- aaaa 3
- Over
- DeException l Hello 2
- AttributeError: "'NoneType' object has no attribute 'num_count'" in <bound method NewClass.__del__ of <__main__.NewClass object at 0x01AF18D0>> ignored
- Exception AttributeError: "'NoneType' object has no attribute 'num_count'" in <bound method NewClass.__del__ of <__main__.NewClass object at 0x01AF1970>> ignored
我们发现,num_count 是全局的,当每创建一个实例,__init__()被调用,num_count 的值增一,当程序结束后,所有的实例会被析构,即调用__del__() 但是此时引发了异常。查看异常为 “NoneType” 即 析构时NewClass 已经被垃圾回收,所以会产生这样的异常。
但是,疑问来了?为什么会这样?按照C/C++等语言的经验,不应该这样啊!经过查找资料,发现:
Python的垃圾回收过程与常用语言的不一样,Python按照字典顺序进行垃圾回收,而不是按照创建顺序进行。所以当系统进行回收资源时,会按照类名A-Za-z的顺序,依次进行,我们无法掌控这里的流程。
明白这些,我们做如下尝试:
- # encoding:utf8
- class NewClass(object):
- num_count = 0 # 所有的实例都共享此变量,即不单独为每个实例分配
- def __init__(self,name):
- self.name = name
- NewClass.num_count += 1
- print name,NewClass.num_count
- def __del__(self):
- NewClass.num_count -= 1
- print "Del",self.name,NewClass.num_count
- def test():
- print "aa"
- aa = NewClass("Hello")
- bb = NewClass("World")
- cc = NewClass("aaaa")
- del aa
- del bb
- del cc
- print "Over"
调试输出:
- Hello 1
- World 2
- aaaa 3
- Del Hello 2
- Del World 1
- Del aaaa 0
- Over
OK,一切按照我们预料的顺序发生。
但是,我们总不能每次都手动回收吧?这么做Python自己的垃圾回收还有什么意义?
SO,继续查找,我们还可以通过self.__class__访问到类本身,然后再访问自身的共享成员变量,即 self.__class__.num_count , 将类中的NewClass.num_count替换为self.__class__.num_count 编译运行,如下:
- # encoding:utf8
- class NewClass(object):
- num_count = 0 # 所有的实例都共享此变量,即不单独为每个实例分配
- def __init__(self,name):
- self.name = name
- self.__class__.num_count += 1
- print name,NewClass.num_count
- def __del__(self):
- self.__class__.num_count -= 1
- print "Del",self.name,self.__class__.num_count
- def test():
- print "aa"
- aa = NewClass("Hello")
- bb = NewClass("World")
- cc = NewClass("aaaa")
- print "Over"
结果:
- Hello 1
- World 2
- aaaa 3
- Over
- Del Hello 2
- Del World 1
- Del aaaa 0
Perfect!我们完美地处理了这个问题!
PS:
书上又提到了一些问题,在这里作补充(仅作为参考):
__new__()是唯一在实例创建之前执行的方法,一般用在定义元类时使用。
del xxx 不会主动调用__del__方法,只有引用计数==0时,__del__()才会被执行,并且定义了__del_()的实例无法被Python的循环垃圾收集器收集,所以尽量不要自定义__del__()。一般情况下,__del__() 不会破坏垃圾处理器。
实验中发现垃圾回收自动调用了__del__, 这与书上所说又不符,不知是什么原因,需要继续学习。
----------------后记------------------
由于事后看各位的评论,觉得自己还是没完全掌握,故有了此次修改。 2015年6月29日12:47:57
- # encoding:utf8
- class NewClass():
- # 为了方便,这里进行先行声明,但是实际应用中一般没必要
- #
- # 共有,私有变量,通过两个下划线区分
- var_public = 0 # 类型上的共有变量
- __var_private = 0 # 类型上的私有, 通过_NewClass__var_private 还可以访问
- # python 中的特殊:类变量和成员变量,无法通过语法区分,只有使用时区分
- var_test_class = 0 # 用于类变量, 类和它的实例都可以访问,类似c++ static, 但又不一样.
- # 当一个类的对象被构造时,会将当前类变量拷贝一份给这个对象,当前类变量的值是多少,这个对象拷贝得到的类变量的值就是多少;
- # 通过对象来修改类变量,并不会影响其他对象的类变量的值,因为大家都有各自的副本,更不会影响类本身所拥有的那个类变量的值;
- # 只有类自己才能改变类本身拥有的类变量的值。
- var_test_self = 0 # 用于成员变量, 只有类的实例可以访问, 类似c++ 中一般成员变量
- def __init__(self,name):
- self.name = name
- self.var_test_self += 1
- NewClass.var_test_class += 1
- pass
- def __del__(self):
- self.var_test_self -= 1
- NewClass.var_test_class -= 1
- pass
- # 一般成员函数
- def func0(self):
- pass
- # 静态成员函数,参数可以为空
- @staticmethod
- def func1():
- pass
- # 类函数,参数为一个类
- @classmethod
- def func2(cls):
- pass
- if __name__ == '__main__':
- a1 = NewClass("Hello")
- print "a1:", a1.var_test_self, a1.var_test_class, NewClass.var_test_class, NewClass.var_test_self
- a2 = NewClass("World")
- print "a2:", a2.var_test_self, a2.var_test_class, NewClass.var_test_class, NewClass.var_test_self
- a3 = NewClass("nihao")
- print "a3:", a3.var_test_self, a3.var_test_class, NewClass.var_test_class, NewClass.var_test_self
- # change class var
- a3.var_test_self += 1
- a3.var_test_class += 10
- NewClass.var_test_class += 100 # ?? no error
- NewClass.var_test_self += 1000 # ?? no error
- print "a3:", a3.var_test_self, a3.var_test_class, NewClass.var_test_class, NewClass.var_test_self
- a4 = NewClass("vartest")
- print "a4",a4.var_test_self, a4.var_test_class, a4.__class__.var_test_class, NewClass.var_test_class, NewClass.var_test_self # a4.__class__ 等价于 NewClass
- '''''
- a1: 1 1 1 0
- a2: 1 2 2 0
- a3: 1 3 3 0
- a3: 2 13 103 1000
- a4 1001 104 104 104 1000
- Exception AttributeError: "'NoneType' object has no attribute 'var_test_class'" in <bound method NewClass.__del__ of <__main__.NewClass instance at 0x01A214B8>> ignored
- Exception AttributeError: "'NoneType' object has no attribute 'var_test_class'" in <bound method NewClass.__del__ of <__main__.NewClass instance at 0x01A21508>> ignored
- Exception AttributeError: "'NoneType' object has no attribute 'var_test_class'" in <bound method NewClass.__del__ of <__main__.NewClass instance at 0x01A214E0>> ignored
- Exception AttributeError: "'NoneType' object has no attribute 'var_test_class'" in <bound method NewClass.__del__ of <__main__.NewClass instance at 0x01A21530>> ignored
- '''
- # 说明,类和它的实例 访问成员函数完全是分开的,只有在构造时才有联系
- a5 = NewClass("test") # # Exception AttributeError: "'NoneType' object has no attribute 'var_test_class'" in <bound method NewClass.__del__ of <__main__.NewClass instance at 0x01A014B8>>
- a5.func0()
- a5.func1()
- a5.func2()
- NewClass.func0() #TypeError: unbound method func0() must be called with NewClass instance as first argument (got nothing instead)
- NewClass.func1()
- NewClass.func2()
- # classmethod 与 staticmethod 差异主要在继承等场景时需要明确区分,同时类函数会额外获取自身的类对象,而不是实例对象