python面向对象学习总结

引言

提到面向对象，总是离不开几个重要的术语：多态（Polymorphism），继承（Inheritance）和封装（Encapsulation）。Python也是一种支持OOP的动态语言，本文将简单阐述Python对面向对象的支持。在讨论Python的OOP之前，先看几个OOP术语的定义：?类：对具有相同数据和方法的一组对象的描述或定义。

?对象：对象是一个类的实例。

?实例(instance)：一个对象的实例化实现。

?标识(identity)：每个对象的实例都需要一个可以唯一标识这个实例的标记。

?实例属性（instance attribute）：一个对象就是一组属性的集合。

?实例方法(instance method)：所有存取或者更新对象某个实例一条或者多条属性的函数的集合。

?类属性（classattribute）：属于一个类中所有对象的属性，不会只在某个实例上发生变化

?类方法（classmethod）：那些无须特定的对性实例就能够工作的从属于类的函数。

1.Python中的类与对象

Python中定义类的方式比较简单：

c l a s s类名：

类变量

d e f__i n i t__(s e l f,p a r a m e r s):

d e f函数(s e l f,...)

其中直接定义在类体中的变量叫类变量，而在类的方法中定义的变量叫实例变量。类的属性包括成员变量和方法，其中方法的定义和普通函数的定义非常类似，但方法必须以self作为第一个参数。

举例：

c l a s s M y F i r s t T e s t C l a s s:

c l a s s S p e c="i t i s a t e s t c l a s s"

d e f__i n i t__(s e l f,w o r d):

p r i n t"s a y"+w o r d

d e f h e l l o(s e l f,n a m e):

p r i n t"h e l l o"+n a m e

在Python类中定义的方法通常有三种：实例方法，类方法以及静态方法。这三者之间的区别是实例方法一般都以self作为第一个参数，必须和具体的对象实例进行绑定才能访问，而类方法以cls作为第一个参数，cls表示类本身，定义时使用@classmethod；而静态方法不需要默认的任何参数,跟一般的普通函数类似.定义的时候使用@staticmethod。

c l a s s M e t h o

d T

e s t():

c o u n t=0

d e f a d d C o u n t(s e l f):

M e t h o d T e s t.c o u n t+=1

p r i n t"I a m a n i n s t a n c e m e t h o d,m y c o u n t i s"+

s t r(M e t h o d T e s t.c o u n t),s e l f

@s t a t i c m e t h o d

d e f s t a t i c M e t h o d A d d():

M e t h o d T e s t.c o u n t+=1

p r i n t"I a m a s t a t i c m e t h o n d,m y c o u n t

i s"+s t r(M e t h o d T e s t.c o u n t)

@c l a s s m e t h o d

d e f c l a s s M e t h o d A d d(c l s):

M e t h o d T e s t.c o u n t+=1

p r i n t"I a m a c l a s s m e t h o d,m y c o u n t

i s"+s t r(M e t h o d T e s t.c o u n t),c l s

a=M e t h o d T e s t()

a.a d d C o u n t()

'''I a m a n i n s t a n c e m e t h o d,m y c o u n t i s1<__m a i n__.M e t h o d T e s t i n s t a n c e a t0x011E C990>

'''

a.s t a t i c M e t h o d A d d();#I a m a s t a t i c m e t h o n d,m y c o u n t i s2

M e t h o d T e s t.s t a t i c M e t h o d A d d();#I a m a s t a t i c m e t h o n d,m y c o u n t i s3

a.c l a s s M e t h o d A d d();#I a m a c l a s s m e t h o d,m y c o u n t i s4

__m a i n__.M e t h o d T e s t

M e t h o d T e s t.c l a s s M e t h o d A d d();#I a m a c l a s s m e t h o d,m y c o u n t i s5 __m a i n__.M e t h o d T e s t

M e t h o d T e s t.a d d C o u n t()

'''T r a c e b a c k(m o s t r e c e n t c a l l l a s t):

F i l e"

",l i n e1,i n

M e t h o d T e s t.a d d C o u n t()

T y p e E r r o r:u n b o u n d m e t h o d a d d C o u n t()m u s t b e c a l l e d w i t h

M e t h o d T e s t i n s t a n c e a s f i r s t a r g u m e n t(g o t n o t h i n g i n s t e a d) '''

从上面的例子来看，静态方法和类方法基本上区别不大，特别是有Java编程基础的人会简单的认为静态方法和类方法就是一回事，可是在Python中事实是这样的吗？看下面的例子：

M e t h o d T e s t.c l a s s M e t h o d A d d();#I a m a c l a s s m e t h o d,m y c o u n t i s5 __m a i n__.M e t h o d T e s t

c l a s s s u b M e t h o

d T

e s t(M e t h o d T e s t):

p a s s

b=s u b M e t h o d T e s t()

b.s t a t i c M e t h o d A d d();#I a m a s t a t i c m e t h o n d,m y c o u n t i s6

b.c l a s s M e t h o d A d d();#I a m a c l a s s m e t h o d,m y c o u n t i s7

__m a i n__.s u b M e t h o d T e s t

a.c l a s s M e t h o d A d d();#I a m a c l a s s m e t h o d,m y c o u n t i s8

__m a i n__.M e t h o d T e s t

如果父类中定义有静态方法a(),在子类中没有覆盖该方法的话，Sub.a()仍然指的是父类的a（）方法。而如果a()是类方法的情况下，Sub.a()指向的是子类。@staticmethod只适用于不想定义全局函数的情况。

看看两者的具体定义：

@s t a t i c m e t h o d f u n c t i o n i s n o t h i n g m o r e t h a n a f u n c t i o n d e f i n e d i n s i d e a c l a s s.I t i s c a l l a b l e w i t h o u t i n s t a n t i a t i n g t h e c l a s s f i r s t.I t’s d e f i n i t i o n i s i m m u t a b l e v i a i n h e r i t a n c e.

@c l a s s m e t h o d f u n c t i o n a l s o c a l l a b l e w i t h o u t i n s t a n t i a t i n g t h e c l a s s,b u t i t s d e f i n i t i o n f o l l o w s S u b c l a s s,n o t P a r e n t c l a s s, v i a i n h e r i t a n c e.T h a t’s b e c a u s e t h e f i r s t a r g u m e n t f o r

@c l a s s m e t h o d f u n c t i o n m u s t a l w a y s b e c l s(c l a s s).

?封装和访问控制

与Java不同，Python的访问控制相对简单，没有public，private，protected等属性，python认为用户在访问对象的属性的时候是明确自己在做什么的，因此认为私有数据不是必须的，但是如果你必须实现数据隐藏，也是可以的，具体方法就是在变量名前加双下划线。如__privatedata=0，定义私有方法则是在方法名称前加上__下划线。但即使对于隐藏的数据，也是有一定的方法可以访问的。方法就是

__className__attrName。Python对于私有变量会进行Namemangling 是Python中为了方便定义私有的变量和方法，防止和继承类以及其他外部的变量或者方法冲突而采取的一种机制。在python中通过

__spam定义的私有变量为最终被翻译成_classname__spam，其中classname为类名，当类名是以_开头的时候则不会发生Namemangling。Namemangling 存在的一个问题是当字符串长度超过255的时候则会发生截断。

c l a s s P r i v a t e T e s t:

__m y o w n e d a t a=12

d e f__m y o w n m e t h o d(s e l f):

p r i n t"c a n y o u s e e m e?"

d e f s a y h i(s e l f):

p r i n t"s a y h i"

c l a s s s u b P r i v a t e T e s t(P r i v a t e T e s t):

p a s s

s u b P r i v a t e T e s t.__m y o w n e d a t a

T r a c e b a c k(m o s t r e c e n t c a l l l a s t):

F i l e"

",l i n e1,i n

s u b P r i v a t e T e s t.__m y o w n e d a t a

A t t r i b u t e E r r o r:c l a s s s u b P r i v a t e T e s t h a s n o a t t r i b u t e

'__m y o w n e d a t a'

s u b P r i v a t e T e s t._P r i v a t e T e s t__m y o w n e d a t a

?构造函数和析构函数