本文深入解析Python中的类定义、成员变量、方法及继承等核心概念，包括实例方法、静态方法、类方法的区别与应用。
Python 的 Class 比较特别，和我们习惯的静态语言类型定义有很大区别。
1. 使用一个名为 __init__ 的方法来完成初始化。
2. 使用一个名为 __del__ 的方法来完成类似析购操作。
3. 所有的实例方法都拥有一个 self 参数来传递当前实例，类似于 this。
4. 可以使用 __class__ 来访问类型成员
def __init__(self):
print "initialize
." def Foo(self):
print id(self)
>>>>>> a = MyClass()
initialize
. >>>>>> a.Foo()
14412576
>>>>>> id(a)
14412576
Class 有一些特殊的属性，便于我们获得一些额外的信息。
"""This is MyClass's Docoment"""
def __init__(self):
self.i = 1234
>>>>>> MyClass.__doc__ # 类型帮助信息
"This is MyClass's Docoment""This is MyClass's Docoment"
>>>>>> MyClass.__name__ # 类型名称
'MyClass'
>>>>>> MyClass.__module__ # 类型所在模块
'__main__'
>>>>>> MyClass.__bases__ # 类型所继承的基类(Python 支持多继承)
(<type 'object'>,)
>>>>>> MyClass.__dict__ # 类型字典，存储所有类型成员信息
<dictproxy object at 0x00DC1AD0>
>>>>>> #以下是实例拥有的属性
>>>>>> MyClass().__class__ # 实例的类型
<class '__main__.MyClass'>
>>>>>> MyClass().__module__ # 实例类型所在模块
'__main__'
>>>>>> MyClass().__dict__ # 对象字典，存储所有实例成员信息
{'i': 1234}
>>>>>>
继承
Python 支持多继承，但有几点需要注意：
1. 基类 __init__ / __del__ 需显示调用。
2. 继承方法的调用和基类声明顺序有关。
def __init__(self):
print "Base1"
def test(self):
print "Base1 test
" >>>>>> class Base2:
def __init__(self):
print "Base2"
def test(self):
print "Base2 test
" >>>>>> class MyClass(Base2,Base1):
def __init__(self):
Base1.__init__(self)
Base2.__init__(self)
print "MyClass"
>>>>>> a = MyClass()
Base1
Base2
MyClass
>>>>>> a.test()
Base2 test
>>>>>> # 下面把 Base1 放在前面
>>>>>> class MyClass(Base1,Base2):
def __init__(self):
Base1.__init__(self)
Base2.__init__(self)
print "MyClass"
>>>>>> a = MyClass()
Base1
Base2
MyClass
>>>>>> a.test()
Base1 test
>>>>>>
成员
Python Class 同样包含类型和实例两种成员。
i = 123 # 类成员
def __init__(self):
self.i = 100 # 实例成员
>>>>>> print Class1.i
123
>>>>>> print Class1().i
100
>>>>>>
有几个很 "特殊" 的 "规则" 需要注意。
(1) 我们可以通过实例引用访问类型成员。因此下面的例子中 self.i 实际指向 Class1.i，直到我们为实例新增了一个成员 i。
>>>>>> class Class1:
i = 123
def __init__(self):
print self.i
print hex(id(self.i))
>>>>>> hex(id(Class1.i)) # 显示 Class1.i 的地址
'0xab5860'
>>>>>> a = Class1() # 创建 Class1 实例，我们会发现 self.i 实际指向 Class1.i
123
0xab5860
>>>>>> Class1.__dict__ # 显示 Class1 成员
{'i': 123, '__module__': '__main__', '__doc__': None, '__init__': <function __init__ at 0x012911B0>}
>>>>>> a.__dict__ # 显示实例成员
{}
>>>>>> a.i = 100 # 为实例新增加一个成员i
>>>>>> hex(id(a.i)) # 显示新成员i的地址
'0xab5974'
>>>>>> a.__dict__ # 显示实例成员
{'i': 100}
>>>>>>
(2) 调用类型内部方法，需要省略 self 参数。
def __init__(self):
self.__test("Hello Python")
def __test(self, s):
print s
>>>>>> Class1()
Hello Python
<__main__.Class1 instance at 0x00DC3800>
>>>>>>
我们可以在成员名称前添加 "__" 使其成为私有成员。
__i = 123
def __init__(self):
self.__x = 0
def __test(self):
print id(self)
>>>>>> Class1.i
Traceback (most recent call last):
File "", line 1, in <module>
Class1.i
AttributeError: class Class1 has no attribute 'i'
>>>>>> Class1().__x
Traceback (most recent call last):
File "", line 1, in <module>
Class1().__x
AttributeError: Class1 instance has no attribute '__x'
>>>>>> Class1().__test()
Traceback (most recent call last):
File "", line 1, in <module>
Class1().__test()
AttributeError: Class1 instance has no attribute '__test'
>>>>>>
事实上这只是一种规则，并不是编译器上的限制。我们依然可以用特殊的语法来访问私有成员。
123
>>>>>> a = Class1()
>>>>>> a._Class1__x
0
>>>>>> a._Class1__test()
14432256
>>>>>>
除了静态(类型)字段，我们还可以定义静态方法。
@staticmethod
def test():
print "In Static method
" >>>>>> Class1.test()
In Static method
>>>>>>
从设计的角度，或许更希望用属性(property)来代替字段(field)。
def __init__(self):
self.__i = 1234
def getI(self): return self.__i
def setI(self, value): self.__i = value
def delI(self): del self.__i
I = property(getI, setI, delI, "Property I")
>>>>>> a = Class1()
>>>>>> a.I
1234
>>>>>> a.I = 1000
>>>>>> a.I
1000
如果只是 readonly property，还可以用另外一种方式。
def __init__(self):
self.__i = 1234
@property
def I(self):
return self.__i
>>>>>> a = Class1()
>>>>>> a.I
1234
用 __getitem__ 和 __setitem__ 可以实现 C# 索引器的功能。
def __init__(self):
self.__x = ["a", "b", "c"]
def __getitem__(self, key):
return self.__x[key]
def __setitem__(self, key, value):
self.__x[key] = value
>>>>>> a = Class1()
>>>>>> a[1]
'b'
>>>>>> a[1] = "xxx"
>>>>>> a[1]
'xxx'
>>>>>>
#coding:utf-8 class class_name(object): class_var = 'I am a class variable' #类变量 def __init__(self): self.instance_var = 'I am a instance varibale' #成员变量（实例变量） def instance_method(self, formal_parameter): local_var_in_function = formal_parameter #实例方法局部变量 self.local_var_also_in_function = formal_parameter #实例方法局部变量 def ordinary_function(formal_parameter): print "I am an ordinary function, I can't vist class var and intance var" print self.instance_var #报错，因此普通函数无法访问成员函数 print clacc_var#报错，因此普通函数无法访问类变量 @classmethod def class_method(cls, formal_parameter): #类方法 print 'I am class method, I can visit class var and instance var' print 'I am class method, I am modifying the instance var' cls.instance_var = formal_parameter print cls.instance_var print 'I am class method, I am modifying the class var' class_var = formal_parameter print class_var @staticmethod def static_method(formal_parameter): print 'I am static method, I am the Adopted son(干儿子) for this class!!' print "I can't modify anything in the class " #print class_var #print self.instance_var print 'Get a class instance' class_instance = class_name() print '\r' print "My name is class_instance, I can call class_method, " \ "statics_method, instance_method and instance_method, but I can't call ordinary_function" print "I can show you:" print '\r' class_instance.class_method('class method is calling!!') print '\r' class_instance.static_method('static method in calling!!') print '\r' class_instance.instance_method('instance method is calling!!') print '\r' print 'class var is calling!!' print class_instance.class_var print '\r' print 'instance var is calling!!' print class_instance.instance_var print '\r' print 'Get a class!!' print '\r' print 'My name is class_name, I can call class_method, statics_method, instance_method, instance_method, and ordinary_function' print "I can show you:" print '\r' class_name.class_method('class method is calling!!') print '\r' class_name.static_method('static method in calling!!') print '\r' #class_name.instance_method("instance method can't be calling!!") print '\r' print 'class var is calling!!' print class_name.class_var print '\r' print 'instance var is calling!!' print class_name.instance_var print 'END!!' Result:
Get a class instance
My name is class_instance, I can call class_method, statics_method, instance_method and instance_method, but I can't call ordinary_function
I can show you:
I am class method, I can visit class var and instance var
I am class method, I am modifying the instance var
class method is calling!!
I am class method, I am modifying the class var
class method is calling!!
I am static method, I am the Adopted son(干儿子) for this class!!
I can't modify anything in the class
class var is calling!!
I am a class variable
instance var is calling!!
I am a instance varibale
Get a class!!
My name is class_name, I can call class_method, statics_method, instance_method, instance_method, and ordinary_function
I can show you:
I am class method, I can visit class var and instance var
I am class method, I am modifying the instance var
class method is calling!!
I am class method, I am modifying the class var
class method is calling!!
I am static method, I am the Adopted son(干儿子) for this class!!
I can't modify anything in the class
class var is calling!!
I am a class variable
instance var is calling!!
class method is calling!!
END!!
类变量：
类定义内部定义的变量（愚见，可以认为类内部没有self开头定义的变量，可以认为是类变量）
e.g. class_name中的class_var = 'I am a class variable' #类变量
成员变量：
类定义内部__init__函数内以self开头定义的变量
e.g. self.instance_var = 'I am a instance varibale' #成员变量（实例变量）
静态变量：
因为Python是动态语言，不存在完全静态的变量，这个概念查阅相关资料后认为指的就是类内部定义的类变量（欢迎指正）
类方法：
类内部定义的以@classmethod装饰的函数是类方法，类方法的调用关系可以通过print后的表述得知。
e.g. @classmethod def class_method(cls, formal_parameter): #类方法 print 'I am class method, I can visit class var and instance var' print 'I am class method, I am modifying the instance var' cls.instance_var = formal_parameter print cls.instance_var print 'I am class method, I am modifying the class var' class_var = formal_parameter print class_var
静态方法：
类内部定义的以@staticmethod装饰的函数，类方法的调用关系可以通过print后的表述得知。
e.g. @staticmethod def static_method(formal_parameter): print 'I am static method, I am the Adopted son(干儿子) for this class!!' print "I can't modify anything in the class " #print class_var #print self.instance_var
实例方法：
类内部定义的没有装饰器且第一个参数为self的函数，类方法的调用关系可以通过print后的表述得知。
e.g. def instance_method(self, formal_parameter): local_var_in_function = formal_parameter #实例方法局部变量 self.local_var_also_in_function = formal_parameter #实例方法局部变量
普通函数：
类内部定义的既没有装饰器，也没有参数self的函数，类方法的调用关系可以通过print后的表述得知。
e.g. def ordinary_function(formal_parameter): print "I am an ordinary function, I can't vist class var and intance var" print self.instance_var #报错，因此普通函数无法访问成员函数 print clacc_var#报错，因此普通函数无法访问类变量
1.变量
-
_xxx，单下划线开头的变量，标明是一个受保护(protected)的变量，原则上不允许直接访问，但外部类还是可以访问到这个变量。这只是程序员之间的一个约定，用于警告说明这是一个私有变量，外部类不要去访问它。class Student(object): def __init__(self, name): self._name = name >>> sd = Student('Tom') >>> sd._name 'Tom' -
__xxx，双下划线开头的，表示的是私有类型(private)的变量。只能是允许这个类本身进行访问了, 连子类也不可以,用于命名一个类属性（类变量），调用时名字被改变（在类Student内部，__name变成_Student__name,如self._Student__name)
双下划线开头的实例变量是不是一定不能从外部访问呢？其实也不是。仍然可以通过_Student__name来访问__name变量：
class Student(object):
def __init__(self, name):
self.__name = name
>>> sd = Student('Tom')
>>> sd.__name
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'Student' object has no attribute '__name'
>>> sd._Student__name
'Tom'-
__xxx__，以双下划线开头，并且以双下划线结尾的，是内置变量，内置变量是可以直接访问的，不是 private 变量，如__init__，__import__或是__file__。所以，不要自己定义这类变量。 -
xxx_，单下划线结尾的变量一般只是为了避免与 Python 关键字的命名冲突。 -
USER_CONSTANT，大写加下划线，对于不会发生改变的全局变量，使用大写加下划线。
2.函数和方法
总体而言应该使用，小写和下划线。但有些比较老的库使用的是混合大小写，即首单词小写，之后每个单词第一个字母大写，其余小写。但现在，小写和下划线已成为规范。
-
私有方法 ： 小写和一个前导下划线
def _secrete(self): print "don't test me."这里和私有变量一样，并不是真正的私有访问权限。同时也应该注意一般函数不要使用两个前导下划线(当遇到两个前导下划线时，Python 的名称改编特性将发挥作用)。特殊函数后面会提及。
-
特殊方法 ： 小写和两个前导下划线，两个后置下划线
def __add__(self, other): return int.__add__(other)这种风格只应用于特殊函数，比如操作符重载等。
-
函数参数 : 小写和下划线，缺省值等号两边无空格
def connect(self, user=None): self._user = user -
一、实例方法
实例方法就是类的实例能够使用的方法。如下：
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)
运行结果为：
letian
<type 'classobj'>
<type 'instance'>
40124704
31323448[code]
可以看到，Foo的type为classobj（类对象，python中定义的类本身也是对象），foo01的type为instance（实例）。而hi()是实例方法，所以foo01.hi()会输出'letian'。实例方法的第一个参数默认为self，代指实例。self不是一个关键字，而是约定的写法。init()是生成实例时默认调用的实例方法。将Foo的定义改为以下形式：
[code]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)
运行结果如下：
letian
3
3
注意，很多编程语言不允许实例调用静态方法。
三、类方法
类方法是将类本身作为对象进行操作的方法。类方法使用@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
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()
运行结果：
hi,Foo
注意，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
运行结果为：
1
0
实例也能够访问类变量，如下：
class Foo(object):
val = 0
def __init__(self):
pass
if __name__ == '__main__':
foo = Foo()
print foo.val
print Foo.val
运行结果如下：
0
0
另外，可以通过以下方式访问类变量：
class Foo(object):
val = 3
def __init__(self):
print self.__class__.val
if __name__ == '__main__':
foo = Foo()
运行结果：
3
还可以这样：
class Foo(object):
val = 3
def __init__(self):
pass
@classmethod
def echo(cls):
print cls.val
if __name__ == '__main__':
Foo.echo()
运行结果：
3
六、如何调用父类的构造函数
子类（派生类）并不会自动调用父类（基类）的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()
这两种方法的运行结果均为：
1
不过这两种方法是有区别的。
扫一扫
803
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
