python 类的理解

class (类) 的理解

        很多人在学习面向对象编程语言时对“类”这个概念难以理解，写出的程序当然也就很难用类的方法加以实现。尤其对长期学习面向过程化编程的爱好者，那更是一个不可逾越的横沟。今天，本个就以自身的学习体会来谈谈如何学习“类”，如何去理解“类”。
        谈到类理解，网上很多例子，360百科是这样说的“对象是对客观事物的抽象，类是对对象的抽象。类是一种抽象的数据类型。”，也有说“类是一种复杂的数据类型，它是将不同类型的数据和与这些数据相关的操作封装在一起的集合体”，还有说“类，相关事物的集合，如所有卡车的集合就一个类，对象，类的具体化，如卡车中的一种”。现在我们以python编程语言用函数的方法来理解“类”。

首先，我们写一个程序，实现两数的加、减、乘、除及密运算，如下：

#!/usr/bin/python


a=1.0;
b=2.0;
_plus_=a+b;
_minus_=a-b;
_divs_=a/b;
_mult_=a*b;
_exp_=a**b;

print _plus_,_minus_,_divs_,_mult_,_exp_;

当我们运行之后，屏幕会输出“3.0 -1.0 0.5 2.0 1.0”。

然而，问题来了，如果是要做很多次“两数求和”，那是不是要写很多的语句，如下：

#!/usr/bin/python


a=1.0;
b=2.0;
_plus_=a+b;
_minus_=a-b;
_divs_=a/b;
_mult_=a*b;
_exp_=a**b;


print _plus_,_minus_,_divs_,_mult_,_exp_;


c=3.0;
d=2.0;
_plus_=c+d;
_minus_=c-d;
_divs_=c/d;
_mult_=c*d;
_exp_=c**d;


print _plus_,_minus_,_divs_,_mult_,_exp_;


e=1.0;
f=2.0;
_plus_=e+f;
_minus_=e-f;
_divs_=e/f;
_mult_=e*f;
_exp_=e**f;


print _plus_,_minus_,_divs_,_mult_,_exp_;

… …

        这里，你就会发现，代码是不是过于冗长，也不利于阅读，更不利于程序的修改，因此，一个比较好的解决方法就是“函数”，如果写成函数，每次只要调用不就可以吗！当然可以，这也是面向过程化编程爱好者喜闻乐见的。那我们把上面的程序改写如下：

#!/usr/bin/python


def plu(a,b):
fc=a+b;
return fc;
def mins(a,b):
fc=a-b;
return fc;
def divs(a,b):
fc=a/b;
return fc;
def mult(a,b):
fc=a*b;
return fc;
def expa(a,b):
fc=a**b;
return fc;


a=1.0;
b=2.0;
_plus_=plu(a,b);
_minus_=mins(a,b);
_divs_=divs(a,b);
_mult_=mult(a,b);
_exp_=expa(a,b);

print _plus_,_minus_,_divs_,_mult_,_exp_;

屏幕会输出：“3.0 -1.0 0.5 2.0 1.0”。

        可能就有同学发现，这不是比之前的还要长吗？没错，代码是加长了，可实用性却更强了！大家想一想，如果我们有成千上百个(a,b)都要进行这样的操作，上面的代码是不是就更好呢？这里用的是加、减、乘、除及密运算，本可以不用写，而这样写是为了说明类(看官勿喷)。
        就上面的代码而言，问题已经可以得到解决了。实事是否如此？当然不是，那还有什么问题？例如，现在我们要将mult函数再除以10，其中大家能想到的是在原mult函数中改为如下：

def mult(a,b):
fc=a*b/10;

return fc;

        但是，这样一来，原来的mutl函数就不复存在了，这并不是我们所希望看到的结果。那只有再定义一个新函数，如下：

def mult2(a,b):
fc=a*b/10;

return fc;

        这样，原函数没有改变，又可以加入新的功能(函数)，问题也就可以解决了。现在我们来看下类是如何解决问题的。
        首先，我们要了解类的四性---封装、继承、重载与重写及多态（不同语言有些不同）。

封装，封装是指将现实世界中存在的某个客体的属性与行为绑定在一起，并放置在一个逻辑单元内。
继承：继承性是子类自动共享父类数据结构和方法的机制，这是类之间的一种关系。在定义和实现一个类的时候，可以在一个已经存在的类的基础之上来进行，把这个已经存在的类所定义的内容作为自己的内容，并加入若干新的内容。
重载，简单说，就是函数或者方法有同样的名称，但是参数列表不相同的情形，这样的同名不同参数的函数或者方法之间，互相称之为重载函数或者方法。
多态，多态性是指相同的操作或函数、过程可作用于多种类型的对象上并获得不同的结果。不同的对象，收到同一消息可以产生不同的结果，这种现象称为多态性。

类解决上面所提到冗余问题所用到的就是类的继承性。现在将原代码改写成类，代码如下：

#!/usr/bin/python
class mathOP:
a=0;
b=0;
def __init__(self,a,b):
self.a=a;
self.b=b;
def plu(self):
fc=self.a+self.b;
return fc;
def mins(self):
fc=self.a-self.b;
return fc;
def divs(self):
fc=self.a/self.b;
return fc;
def mult(self):
fc=self.a*self.b;
return fc;
def expa(self):
fc=self.a**self.b;
return fc;


A=mathOP(1.0,2.0);


_plus_=A.plu();
_minus_=A.mins();
_divs_=A.divs();
_mult_=A.mult();
_exp_=A.expa();

print _plus_,_minus_,_divs_,_mult_,_exp_;

屏幕会输出：“3.0 -1.0 0.5 2.0 1.0”。

与之前的相一致。现在我们利用继承性将方法进行改造，代码如下：

#!/usr/bin/python
class mathOP:
a=0;
b=0;
def __init__(self,a,b):
self.a=a;
self.b=b;
def plu(self):
fc=self.a+self.b;
return fc;
def mins(self):
fc=self.a-self.b;
return fc;
def divs(self):
fc=self.a/self.b;
return fc;
def mult(self):
fc=self.a*self.b;
return fc;
def expa(self):
fc=self.a**self.b;
return fc;
def __del__(self):
self.a=0;
self.b=0;
class mathOP_sub(mathOP):
def __init__(self,a,b):
mathOP.__init__(self,a,b);
def mult(self):
fc=self.a*self.b/10;
return fc;




A=mathOP_sub(1.0,2.0);


_plus_=A.plu();
_minus_=A.mins();
_divs_=A.divs();
_mult_=A.mult();
_exp_=A.expa();


print _plus_,_minus_,_divs_,_mult_,_exp_;


屏幕会输出：“3.0 -1.0 0.5 0.2 1.0”。
之前会输出：“3.0 -1.0 0.5 2.0 1.0”。
这里，我们已用函数的方法介绍了类的概念，当你看到这里，相信你对类也不会太陌生了吧！