python之路——第三块（面向对象）

编程分为面向对象式编程、面向过程编程、面向函数式编程，其中面向过程和函数式编程都是使用函数，而面向对象使用的是类。如果只是写一些简单的脚本，去做一些一次性任务，用函数的方式是极好的，但如果你要处理的任务是复杂的，且需要不断迭代和维护 的， 那还是用面向对象最方便了。

面向对象式编程是利用类和对象来创建各种模型来实现对真实世界的描述，使用面向对象编程的原因一方面是因为它可以使程序的维护和扩展变得更简单，并且可以大大提高程序开发效率 ，另外，基于面向对象的程序可以使它人更加容易理解你的代码逻辑，从而使团队开发变得更从容。

Class 类
一个类即是对一类拥有相同属性的对象的抽象、蓝图、原型。在类中定义了这些对象的都具备的属性（variables(data)）、共同的方法

Object 对象 
一个对象即是一个类的实例化后实例，一个类必须经过实例化后方可在程序中调用，一个类可以实例化多个对象，每个对象亦可以有不同的属性，就像人类是指所有人，每个人是指具体的对象，人与人之前有共性，亦有不同

Encapsulation 封装
在类中对数据的赋值、内部调用对外部用户是透明的，这使类变成了一个胶囊或容器，里面包含着类的数据和方法

Inheritance 继承
一个类可以派生出子类，在这个父类里定义的属性、方法自动被子类继承

Polymorphism 多态
多态是面向对象的重要特性,简单点说:“一个接口，多种实现”，指一个基类中派生出了不同的子类，且每个子类在继承了同样的方法名的同时又对父类的方法做了不同的实现，这就是同一种事物表现出的多种形态。

　　首先写一个类

class Animal(object):
    def __init__(self,name,skill,food):
        self.Name = name
        self.Skill = skill
        self.Food = food
    def eat(self):
        print("The %s like eating %s"%(self.Name,self.Food))

　　定义了一个动物的类，object这个动物类继承的来源，叫源类；def _init_ （self）是构建函数，传入的是属性/成员变量；def eat（self）是这个类的方法。现有要根据这个类创建实例，即对象：

dog = Animal("dog","bite","bone")
dog.eat()

rabbit = Animal("rabbit","cute","carrot")
rabbit.eat()

　　根据上面的动物类，创建了两个实例，分别是狗和兔子，并调用的类的eat方法。其中，调用类的方法时，将实例传入方法中，self是实例即（dog和rabbit）。

以上就是一个类的初步创建和实例化。

面向对象的特性：

封装：也就是把客观事物封装成抽象的类，并且类可以把自己的数据和方法只让可信的类或者对象操作，对不可信的进行信息隐藏。

继承：继承是指这样一种能力：它可以使用现有类的所有功能，并在无需重新编写原来的类的情况下对这些功能进行扩展。通过继承创建的新类称为“子类”或“派生类”。被继承的类称为“基类”、“父类”或“超类”。继承的过程，就是从一般到特殊的过程。

class Fish(Animal):
    def __init__(self,name,skill,food,size):
        super(Fish,self).__init__(name,skill,food)
        self.Size = size
    def swim(self):
        print("If %s size is small ,%s will swimming fast"%(self.Name,self.Name))

fishc = Fish("tuna","swim","small","worm")
fishc.swim()

fishc.eat()

　　根据上面的动物类，写了一个鱼类，并继承了动物类的属性和方法。super(Fish,self).__init__(name,skill,food)是继承Animal类的属性，def swim（self）是Fish类特有的一个方法，但是鱼类同时具有动物类的方法。上面是单继承，类还有多继承，在python3.x中多继承按照广度查找的原则。

class A(object):
    def __init__(self,name):
        self.name = name
    def a(self):
        print("A------%s------A"%self.name)
class B(A):
    def a(self):
        print("B------%s------B"%self.name)
class C(A):
    def a(self):
        print("C------%s------C" % self.name)
class D(B,C):
    def a(self):
        print("D------%s------D" % self.name)
ddd = D("alex")
ddd.a()

　　结果是打印的D中方法；把D 中方法去掉，打印的是B 中方法；把B中方法去掉，打印的是C 中方法；B、C方法都去掉，打印的是A 中方法。

多态：允许将子类类型的指针赋值给父类类型的指针。封装可以隐藏实现细节，使得代码模块化；继承可以扩展已存在的代码模块（类）；它们的目的都是为了——代码重用。而多态则是为了实现另一个目的——接口重用！多态的作用，就是为了类在继承和派生的时候，保证使用“家谱”中任一类的实例的某一属性时的正确调用。

class Animal(object):
    def __init__(self,name,skill,food):
        self.Name = name
        self.Skill = skill
        self.Food = food
    def eat(self):
        print("The %s like eating %s"%(self.Name,self.Food))
class Dog(Animal):
    def eat(self):
        print("%s is eating %s"%(self.Name,self.Food))
class Cat(Animal):
    def eat(self):
        print("%s don't like eating %s"%(self.Name,self.Food))

　　创建三个类，动物类，狗类和猫类，都有eat的方法。

def func_eat(obj):
    obj.eat()

　　为用户提供一个借口，方便用户直接通过这个结果调用不同的实例的eat方法

dog = Dog("dog","bite","bone")
cat = Cat("cat","bite","bone")

func_eat(dog)
func_eat(cat)

　　实例和调用。

公有属性：所有方法都共同的属性，定义在class下面

class Animal(object):
    IQ = 79
    def __init__(self,name,skill,food):
        self.Name = name
        self.Skill = skill
        self.Food = food
    def eat(self):
        print("The %s like eating %s"%(self.Name,self.Food))
        print("%s IQ is %s"%(self.Name,Animal.IQ))
dog = Animal("dog","bite","bone")
dog.eat()

　　调用公有属性的时候要用Animal.IQ的形式

私有属性：

class Animal(object):
    IQ = 79
    def __init__(self,name,skill,food):
        self.Name = name
        self.Skill = skill
        self.Food = food
        self._heart = "nomal"
    def eat(self):
        self._hert = "loyal"
        print("The %s like eating %s"%(self.Name,self.Food))
        print("%s IQ is %s,%s"%(self.Name,Animal.IQ,self._heart))
dog = Animal("dog","bite","bone")
dog.eat()

　　self._heart就是私有属性，调用的时候需要赋值。