Python自学笔记二、面向对象编程

面对对象编程简称OOP，是一种程序思想。将对象作为程序的基本单元，一个对象包含了数据和操作数据的函数。面向对象的程序设计把计算机程序视为一组对象的集合，而每个对象都可以接收其他对象发过来的消息，并处理这些消息，计算机程序的执行就是一系列消息在各个对象之间传递。

#创建对象
class Foo():
    def Bar(self,backend):
        print 'Hello,'+backend
#创建实例
f=Foo()
f.Bar('peter')
#Hello,peter

其中self作为形式参数，谁调用该函数，谁就传进来作为self。本实例中f调用了Bar函数，所以这里的self相当于f本身。
f.Bar(‘peter’) ==>self:f , backend：’peter’

类的三大特性：封装，继承，多态
1，封装
类是创建实例的模板，而实例则是一个一个具体的对象，各个实例拥有的数据都互相独立，互不影响。在上面的例子中，我们要创建一个实例，然后传参，如果有很多个实例的话，操作起来会非常麻烦。这里举一个学校花名册的例子：

class Student(object):
    #构造方法，在创建实例时默认执行__init__函数 
    def __init__(self, name, score):
    #将对象的参数封装
        self.name = name
        self.score = score

bart=Student('Bart jepson',88)
print bart.name
#'Bart jepson'

#当我们需要打印花名册时

class Student:
    def print_information(self):
        print '%s:%s' %(self.name,self.score)

print bart.print_information
#Bart jeson:88

可以看出，当众多的实例具有相同类型的参数时，可以直接将其封装，然后调用类中的方法，减少代码量。

__del__方发在解释器销毁对象时自动调用，该方法称为析构方法。

2.继承
继承是面向对象编程的一个重要的方式，因为通过继承，子类就可以扩展父类的功能。新的class称为子类，而被继承的class称为基类，父类或超类。

a.继承要在子类加上父类的类名
b.子类和父类都有的方法，优先找子类的方法
c.python里面可以继承多个类C#,java 不可以多继承
d.如果继承多个类，继承顺序为从左至右

class GrandPa:
    def house(self):
        print (self.name+'has a house')
class Dad(GrandPa):
    def __init__(self,name):
        self.name = name
    def car (self):
        print(self.name + ' has a car')
me =Dad('Peter')

me.house()
me.car()
#Peterhas a house
#Peter has a car

多继承实例

class GrandPa:
    def house(self):
        print (self.name+'has a house')
class Grandma:
    def car (self):
        print(self.name + ' has a car')
class Me(GrandPa,Grandma):
    def __init__(self,name):
        self.name = name
me =Me('Peter')
me.house()
me.car()
#Peterhas a house
#Peter has a car

如果继承多个类，当多父类中拥有同样的方法时，首先调用左边的父类。继承关系如下：

E继承（C,D)–>C继承（A）–>D继承(B),Python3下。

当AB具有相同的父类时:
E继承(C,D)–>C继承(A),D继承(B)–>A和B都继承(Boos) ,python3下。

下图为Python2.7版本下的继承关系。

补充：执行父类的构造方式。

class Annimal(object):
    def __init__(self):
        print('Annimal method')

        self.ty = 'animal'

class Cat(Annimal):
    def __init__(self):
        print('Cat method')
        self.n = 'cat'
        super(Cat, self).__init__()  
c = Cat()
print c.__dict__

#Cat mehtod
#Annimal method
#{'ty': 'animal', 'n': 'cat'}

3.多态
比如我们这里有一个作用函数，当我们需要传入众多子类时，我们只需要让该函数接受子类的父类即可，因为这些子类都是父类的类型，按照其父类的类型操作即可。

class Grandpa:
    def run():
        print 'grandpa is running...'

class father(Grandpa):
    def run():
        print 'father is running...'

class Uncle(Grandpa):
    def run():
        print 'Uncle is running...'

#添加一个作用函数
def run_again(Grandpa):
    Grandpa.run()
    Grandpa.run()
#新添加一个子类

class Uncle2(Granpa):
    def run():
        print 'Uncle2 is running...'

run_again(Uncle2())
#Uncle2 is running...
#Uncle2 is running...

当我们添加一个新的子类时，不必对run_again进行修改，只要是Granpa类或者子类，就会自动调用实际类型的run()方法，这就是多态的意思。
Python原生支持多态。