Python面向对象

Python是纯面向对象语言，使用关键字class定义类。
定义Python 的 Class 比较特别，和我们习惯的静态语言类型定义有很大区别。

使用一个名为 __init__ 的方法来完成初始化。
使用一个名为 __del__ 的方法来完成类似析购操作。
所有的实例方法都拥有一个 self 参数来传递当前实例，类似于 this
可以使用 __class__ 来访问类型成员。

1
2
3
4
5
6
7
8
9
10
11
>>>　class　Class1:
　　def　__init__(self):
　　　　print　"initialize..."
　　def　test(self):
　　　　print　id(self)
>>>　a　=　Class1()
initialize...
>>>　a.test()
13860176
>>>　id(a)
13860176

Class 有一些特殊的属性，便于我们获得一些额外的信息。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
>>>　class　Class1(object):
　　"""Class1　Doc."""
　　def　__init__(self):
　　　　self.i　=　1234
>>>　Class1.__doc__　#　类型帮助信息
'Class1　Doc.'
>>>　Class1.__name__　#　类型名称
'Class1'
>>>　Class1.__module__　#　类型所在模块
'__main__'
>>>　Class1.__bases__　#　类型所继承的基类
(<type　'object'>,)
>>>　Class1.__dict__　#　类型字典，存储所有类型成员信息。
<dictproxy　object　at　0x00D3AD70>
>>>　Class1().__class__　#　类型
<class　'__main__.Class1'>
>>>　Class1().__module__　#　实例类型所在模块
'__main__'
>>>　Class1().__dict__　#　对象字典，存储所有实例成员信息。
{'i':　1234}

继承
　　Python 支持多继承，但有几点需要注意：
　　1. 基类 __init__ / __del__ 需显示调用。
　　2. 继承方法的调用和基类声明顺序有关。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
>>>　class　Base1:
　　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　Class1(Base2,　Base1):
　　def　__init__(self):
　　　　Base1.__init__(self)
　　　　Base2.__init__(self)
　　　　print　"Class1"
>>>　a　=　Class1()
Base1
Base2
Class1
>>>　a.test()
Base2　test...

成员
　　Python Class 同样包含类型和实例两种成员。

1
2
3
4
5
6
7
8
>>>　class　Class1:
　　i　=　123　#　Class　Field
　　def　__init__(self):
　　　　self.i　=　12345　#　Instance　Field
>>>　print　Class1.i
123
>>>　print　Class1().i
12345

有几个很 “特殊” 的 “规则” 需要注意。
　　(1) 我们可以通过实例引用访问类型成员。因此下面的例子中 self.i 实际指向 Class1.i，直到我们为实例新增了一个成员 i。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
>>>　class　Class1:
　　i　=　123
　　def　__init__(self):
　　　　print　self.i　
　　　　print　hex(id(self.i))　
>>>　hex(id(Class1.i))　#　显示　Class1.i
'0xab57a0'
>>>　a　=　Class1()　#　创建　Class1　实例，我们会发现　self.i　实际指向　Class1.i。
123
0xab57a0
>>>　Class1.__dict__　#　显示　Class1　成员
{'i':　123,　'__module__':　'__main__',　'__doc__':　None,　'__init__':　<function　__init__　at　0x00D39470>}
>>>　a.__dict__　#　显示实例成员
{}
>>>　a.i　=　123456789　#　为实例新增一个成员　i
>>>　hex(id(a.i))　#　显示新增实例成员地址
'0xbbb674'
>>>　a.__dict__　#　显示实例成员
{'i':　123456789}

(2) 调用类型内部方法，需要省略 self 参数。

1
2
3
4
5
6
7
8
>>>　class　Class1:
　　def　__init__(self):
　　　　self.__test("Hello,　World!")
　　def　__test(self,　s):
　　　　print　s
>>>　Class1()
Hello,　World!
<__main__.Class1　instance　at　0x00D37B48>

我们可以在成员名称前添加 “__” 使其成为私有成员。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
>>>　class　Class1:
　　__i　=　123
　　def　__init__(self):
　　　　self.__x　=　0
　　def　__test(self):
　　　　print　id(self)
>>>　Class1.i
Traceback　(most　recent　call　last):
　File　"<pyshell#102>",　line　1,　in　<module>
　Class1.i
AttributeError:　class　Class1　has　no　attribute　'i'
>>>　Class1().__x
Traceback　(most　recent　call　last):
　File　"<pyshell#103>",　line　1,　in　<module>
　Class1().__x
AttributeError:　Class1　instance　has　no　attribute　'__x'
>>>　Class1().test()
Traceback　(most　recent　call　last):
　File　"<pyshell#104>",　line　1,　in　<module>
　Class1().test()
AttributeError:　Class1　instance　has　no　attribute　'test'

事实上这只是一种规则，并不是编译器上的限制。我们依然可以用特殊的语法来访问私有成员。

1
2
3
4
5
6
7
>>>　Class1._Class1__i
123
>>>　a　=　Class1()
>>>　a._Class1__x
0
>>>　a._Class1__test()
13860376

除了静态(类型)字段，我们还可以定义静态方法。

1
2
3
4
5
6
>>>　class　Class1:
　　@staticmethod
　　def　test():
　　　　print　"static　method"
>>>　Class1.test()
static　method

重载
　　Python 支持一些特殊方法和运算符重载。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
>>>　class　Class1:
　　def　__init__(self):
　　　　self.i　=　0
　　def　__str__(self):
　　　　return　"id=%i"　%　id(self)
　　def　__add__(self,　other):
　　　　return　self.i　+　other.i
>>>　a　=　Class1()
>>>　a.i　=　10
>>>　str(a)
'id=13876120'
>>>　b　=　Class1()
>>>　b.i　=　20
>>>　a　+　b
30

通过重载 “__eq__”，我们可以改变 “==” 运算符的行为。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
>>>　class　Class1:
　　pass
>>>　a　=　Class1()
>>>　b　=　Class1()
>>>　a　==　b
False
>>>　class　Class1:
　　def　__eq__(self,　x):
　　　　return　True
　　
>>>　a　=　Class1()
>>>　b　=　Class1()
>>>　a　==　b
True

———————–更新与2012-1-31——Demo如下:————-

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
class persons:
    number = 0 #static
    __number = 100 #private
    def __init__(self,name,age):
        self.name = name  #public
        self.age = age  #public
        self.__class__.number += 1 #staitc
        self.__number += 1
    def __del__(self):
        self.__class__.number -= 1
    def getAge(self):
        print 'Person\'s age is %s' %self.age
    def getName(self):
        print 'person\'s name is %s' %self.name
    def getPersonInfo(self):
        print 'Current Person Name: %s Age:%d'%(self.name,self.age)
    def getStaticPersonsCount(self):
        return persons.number
        #return self.__class__.number
    def getPrivatePersonCount(self):
        return self.__number
    def sayHi(self):
        print '%s says:Hello,how are you?'%self.name
    @staticmethod
    def printPersonsClassInfo():
        print persons.__name__
        print persons.__module__

  1. 没有评论

  1. 没有通告