面对对象编程简称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原生支持多态。