标签：
刚开始我们接触得多的编程方式为面向过程编程，这种方式就是根据业务逻辑从上往下垒代码，后来又出现了函数式编程，就是为了提高代码的重用性，减轻程序猿的工作量--而今天我们即将学的
面向对象编程则是使用类和对象来实现的，类就是一个模板，模板里可以包含多个函数，函数里实现一些功能
对象则是根据模板创建的实例，通过实例对象可以执行类中的函数
#创建类
class foo:
def bar(self):
print(‘bar‘)
def hello(self,name):
print(‘i am %s‘%name)
#根据类foo创建对象ohj
obj = foo()
obj.bar() #执行bar方法
obj.hello(‘alex‘) #执行hello函数
那你可能会想：这样做好像并不比函数编程简便？？
面向对象有三大神奇功能：封装，继承，多态
封装--好理解，从字面意思理解，把什么玩意封在某个地方，好比：人的五脏六腑封装在人的体内样的，所以封装特性表现为：
第一个表现--将内容封装到某处
第二个表现：从某处调用被封装的内容
好，封装就是这样，封装了某些属性到对象，然后可以用对象直接调用，或self间接调用，简单吧
继承--和生活中的继承是一样一样的，即：子可以继承父的技能
举个列子：
猫可以：喵喵叫、吃喝拉撒
狗可以：汪汪叫、吃喝拉撒
我们可以很明显的发现，狗和猫都会吃喝拉撒，不仅狗和猫会，是个动物都会，如果如要分别写这个两个类，吃喝拉撒是不是就要写两遍了，那继承的特性就是为了在这方面方便我们的
class animal:
def eat(self):
print(‘%s吃‘%self.name)
def drink(self):
print(‘%s喝‘%self.name)
def shit(self):
print(‘%s拉‘%self.name)
def pee(self):
print(‘%s撒‘%self.name)
#在类后面括号中写入另外一个类名，表示当前类继承另外一个类
class cat(animal):
def __init__(self,name):
self.name = name
self.breed = ‘猫‘
def cry(self):
print(‘喵喵叫‘)
class dog(animal):
def __init__(self,name):
self.name = name
self.breed = ‘狗‘
def cry(self):
print(‘汪汪叫‘)
c1 = cat(‘小白家的小黑猫‘)
c1.eat()
d1 = dog(‘胖子家的小瘦狗‘)
d1.drink()
所以，对于面向对象的继承来说，其实就是将多个类共有的方法提取到父类中，子类仅需继承父类而不必一一实现每个方法，另外除了父类和子类的称谓，还可以叫基类和派生类
那疑问又来了，是否可以继承多个类？如果遇到继承的多个类中都定义了相同的函数，那么会执行哪个呢？
1、Python的类可以继承多个类，Java和C#中则只能继承一个类
2、Python的类如果继承了多个类，那么其寻找方法的方式有两种，分别是：深度优先和广度优先
经典类和新式类，从字面上可以看出一个老一个新，新的必然包含了跟多的功能，也是之后推荐的写法，从写法上区分的话，如果 当前类或者父类继承了object类，那么该类便是新式类，否则便是经典类。
#多继承
#经典类
class classmate():
def __init__(self,name):
self.name = name
def eat(self):
print(‘%s is eating.‘%self.name)
def drink(self):
print(‘%s is drinking.‘%self.name)
#派生类1：
class female(classmate):
def drink(self):
print(‘%s drink orange juice‘%self.name)
#派生类2：
class male(classmate):
def drink(self):
print(‘%s is drink alcohol‘%self.name)
class pythoner(classmate):
def occuption(self):
print(‘%s is a pythoner.‘%self.name)
class fe_pythoner(pythoner,female):
pass
class ma_pythoner(pythoner,male):
pass
eva = fe_pythoner(‘eva‘)
eva.drink()
sweet = ma_pythoner(‘sweet‘)
sweet.drink()
#新生类
class classmate(object):
def __init__(self,name):
self.name = name
def eat(self):
print(‘%s is eating.‘%self.name)
def drink(self):
print(‘%s is drinking.‘%self.name)
class female(classmate):
def drink(self):
print(‘%s drink orange juice.‘%self.name)
class male(classmate):
def drink(self):
print(‘%s drink alcohol.‘%self.name)
class pythoner(classmate):
def occupation(self):
print(‘%s is a pythoner.‘%self.name)
class fe_pythoner(pythoner,female):
pass
class ma_pythoner(pythoner,male):
pass
eva = fe_pythoner(‘eva‘)
eva.drink()
sweet = ma_pythoner(‘sweet‘)
sweet.drink()
#结论：在python3中，类的继承默认就是广度优先
# 在python2中，经典类多继承，按照深度优先查找，新式类多继承按广度优先查找
另外子类继承父类的构造方法：
class fund(object):
def __init__(self,fund_type,fund_name):
self.fund_type = fund_type
self.fund_name = fund_name
def chao(self):
pass
class index_fund(fund):
def __init__(self,fund_type,fund_name,nav):
super(index_fund,self).__init__(fund_type,fund_name)
self.nav = nav
def cao(self):
pass
def prin(self):
print(‘{} is {},now jingzhi is {}‘.format(self.fund_name,self.fund_type,self.nav))
obj1 = index_fund(‘指数型基金‘,‘富国中证500‘,2.2)
obj1.prin()
Pyhon不支持多态并且也用不到多态，多态的概念是应用于Java和C#这一类强类型语言中，而Python崇尚“鸭子类型”。
class F1:
pass
class S1(F1):
def show(self):
print ‘S1.show‘
class S2(F1):
def show(self):
print ‘S2.show‘
# 由于在Java或C#中定义函数参数时，必须指定参数的类型
# 为了让Func函数既可以执行S1对象的show方法，又可以执行S2对象的show方法，所以，定义了一个S1和S2类的父类
# 而实际传入的参数是：S1对象和S2对象
def Func(F1 obj):
"""Func函数需要接收一个F1类型或者F1子类的类型"""
print obj.show()
s1_obj = S1()
Func(s1_obj) # 在Func函数中传入S1类的对象 s1_obj，执行 S1 的show方法，结果：S1.show
s2_obj = S2()
Func(s2_obj) # 在Func函数中传入Ss类的对象 ss_obj，执行 Ss 的show方法，结果：S2.show
class F1:
pass
class S1(F1):
def show(self):
print ‘S1.show‘
class S2(F1):
def show(self):
print ‘S2.show‘
def Func(obj):
print obj.show()
s1_obj = S1()
Func(s1_obj)
s2_obj = S2()
Func(s2_obj)
类以及类中的方法在内存中只有一份，而根据类创建的每一个对象都在内存中需要存一份
如上图所示，根据类创建对象时，对象中除了封装 name 和 age 的值之外，还会保存一个类对象指针，该值指向当前对象的类。
当通过 obj1 执行 【方法一】 时，过程如下：
欢迎大家对我的博客内容提出质疑和提问！谢谢
笔者：拍省先生
标签：
原文地址：http://www.cnblogs.com/xinsiwei18/p/5614659.html
