【python学习-5】面向对象的python

python是一种面向对象的编程语言，虽然与C++一样，支持面向过程的程序设计，python完全可以使用函数、模块等方式来完成工作，但是当使用python编写一个较大的项目时，则应该考虑使用面向对象的方法，以便于更好地对项目进行管理。

1、python的类特性：

　　① 类的抽象性：类是对具有共同方法和属性的一类对象的描述。

　　② 类的封装性：类将属性和方法封装，外部是不可见的，只有通过类提供的接口才能与属于类的的实例对象进行信息交换。

　　③ 类的继承性：类可以由已有的类派生，派生出来的类拥有父类方法和属性。

　　④ 类的多态性：类可以根据不同的参数类型调用不同的方法，同一个方法可以处理不同类型的参数。

　　在python中， 对象概念比较广泛，对象不一定就是类的实例。python的内置数据类型如字符串、列表、字典等，都不是类，但却具有一些和类相似的语法。

2、类的定义和使用：

　　类的定义如下：

class <类名>:
    <语句1>
    <语句2>
    ...
    <语句n>

class <类名>(父类名):
    <语句1>
    <语句2>
    ...
    <语句n>

　　上面两种定义方式，第一种是没有继承关系的，第二种是继承了父类的，在类名后面的圆括号里面加上父类的名字就行。

　　类内部与函数内部一样，相当于一个局部作用域，不同类的内部可以使用相同的属性名。

　　虽然类首先需要实例化，然后才能使用其属性。但实际上当创建一个类以后就可以通过类名访问其属性了。如果直接使用类名修改其属性，那么将影响已经通过该类实例化的其他对象。

#!/usr/bin/python
class animal:
    name = "animal";
    num = 1;

class human(animal):
    name = "human";
    age = 99;

h = human();
# python 没有java的toString机制，所以不同类型的数据相加需要转化
print( h.name + ',' + str(h.num) ); # human,1
human.name = 'new human'; # 改变类的name属性
print(h.name);    # 实例h中并没有修改name的值，所以默认使用的是类的name值，值变了：new human
h.name = 'human h'; # 实例h中修改了name的值
print(h.name); # human h
human.name = 'new human2';
print(h.name); # 实例h中并修改了name的值，虽然类的name值变了，但h.name还是：human h
h2 = human(); # 第二个实例
print(h2.name); # 新建的对象，name属性是：new human2

3、类的私有属性和方法

　　类的外部可以设置其属性的值，在某些情况下，我们不希望在类外部对其进行操作，所以就有了私有属性。

　　python的私有属性不是通过关键字控制的，而是通过变量名控制的：变量名以双下划线开始的变量，是私有属性，如 __myAttr ； 如果在类内部方法中访问私有属性，应该加上self，如：self.__myAttr 。

　　定义类的方法，与函数定义十分相似，也是使用def 定义的，但是和函数有一点区别是，类的方法，入参的第一个需要是 self 。

　　类的私有方法与私有属性一样，只能在类内部使用，名称是以双下划线开头的，类内部调用私有方法，要使用 “ self.私有方法名 ” 的形式调用。

#!/usr/bin/python
class animal:
    name = "animal";
    num = 1;
    __nickName = "Some thing just like this";    # 类私有属性
    def __getNickName(self):                    # 类私有方法
        return self.__nickName;
    def showNickName(self):                        # 类对外提供的方法
        print("I have a NickName:" + self.__getNickName() );
    def showNickNameAbc(self,abc):                # 类对外提供的方法
        self.showNickName();
        print("this is a secret:" + str(abc) );
    def addNum(self,*nums):                        # 类对外提供的方法，任意个数参数
        result = 0;
        for i in nums:
            result += i;
        return result;

a = animal();
# print(a.__nickName);        # 报错：AttributeError: 'animal' object has no attribute '__nickName'
# print(a.__getNickName());    # 报错：AttributeError: 'animal' object has no attribute '__getNickName'
a.showNickName();
print(a.addNum(1,2,3,4,5));
a.showNickNameAbc('Mike');

4、类的专有方法

　　在python中，类中有一些以双下划线开始并且以双下划线结束的方法，我们称之为类的专有方法，比如 __init__ 方法是类实例化的时候调用的。

__init__               构造函数，生成对象时调用
__del__                析构函数，释放对象时调用
__add__                加运算
__mul__                乘运算
__cmp__                比较运算
__repr__               打印，转换
__setitem__            按照索引赋值
__getitem__            按照索引获取值
__len__                获取长度
__call__               函数调用

#!/usr/bin/python
class animal:
    name = "animal";
    num = 1;
    __nickName = "Some thing just like this";    # 类私有属性
    def __getNickName(self):                    # 类私有方法
        return self.__nickName;
    def showNickName(self):                        # 类对外提供的方法
        print("I have a NickName:" + self.__getNickName() );
    def __init__(self,nickName):                # 类构造方法
        self.__nickName = nickName;

a = animal('Mike');
a.showNickName();

5、类的继承

　　前面已经提到类的继承了，新类可以继承父类的公用属性和共有方法，但是不能继承父类的私有属性和私有方法。

　　python的类继承是多继承，一个类可以继承多个类，格式如下：

class 新类名(父类1,父类2,...,父类n):
    <语句1>
    <语句2>
    ...
    <语句n>

6、类中重载方法和运算符

　　继承父类之后，避免重命名函数，可以使用方法的重载来解决

#!/usr/bin/python
class animal:
    name = "animal";
    num = 1;
    def show(self):                        # 类对外提供的方法
        print(self.name);
        print(self.num);

class human(animal):
    name = "human";
    age = 100;
    def show(self):                        # 重载方法
        animal.show(self);
        print(self.age);

h = human();
h.show();

运算符重载，对应的是类的专有方法：

+      __add__
-      __sub__
*      __mul__
/      __div__
%      __mod__
**     __pow__

#!/usr/bin/python
class animal:
    name = "animal";
    num = 1;
    def show(self):                        # 类对外提供的方法
        print(self.name);
        print(self.num);
    def __add__(self,n):
        self.num += n;

h = animal();
h.show();
h+5;                                    # 调用 __add__ 方法
h.show();

可以在模块中定义类，在访问的类时候，就使用 “ 模块名.类名 ” 对类进行调用。