python基础-第七篇-7.1初识类和对象，,创建类和对象　　刚开

python基础-第七篇-7.1初识类和对象，,创建类和对象　　刚开

创建类和对象

　　刚开始我们接触得多的编程方式为面向过程编程，这种方式就是根据业务逻辑从上往下垒代码，后来又出现了函数式编程，就是为了提高代码的重用性，减轻程序猿的工作量--而今天我们即将学的

　　面向对象编程则是使用类和对象来实现的，类就是一个模板，模板里可以包含多个函数，函数里实现一些功能

　　对象则是根据模板创建的实例，通过实例对象可以执行类中的函数

　　

class是关键字，表示类创建对象--类名称后加括号

#创建类class foo:    def bar(self):        print(‘bar‘)    def hello(self,name):        print(‘i am %s‘%name)#根据类foo创建对象ohjobj = foo()obj.bar()  #执行bar方法obj.hello(‘alex‘)  #执行hello函数

　　那你可能会想：这样做好像并不比函数编程简便？？

面向对象--创建对象，通过对象执行方法，看得出在方法执行上有个权限，只有对象才有这个权限函数编程：只用调用就可，可以说没有权限，无论谁叫都到结论：函数式的应用场景，各个函数之间是独立且无共用的数据

面向对象三大特性

　　面向对象有三大神奇功能：封装，继承，多态

一、封装

　　封装--好理解，从字面意思理解，把什么玩意封在某个地方，好比：人的五脏六腑封装在人的体内样的，所以封装特性表现为：

将内容封装到某处从某处调用被封装的内容

第一个表现--将内容封装到某处

第二个表现：从某处调用被封装的内容

通过对象直接调用通过self间接调用

　　好，封装就是这样，封装了某些属性到对象，然后可以用对象直接调用，或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):    passclass ma_pythoner(pythoner,male):    passeva = 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):    passclass ma_pythoner(pythoner,male):    passeva = 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):        passclass 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:    passclass 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.shows2_obj = S2()Func(s2_obj) # 在Func函数中传入Ss类的对象 ss_obj，执行 Ss 的show方法，结果：S2.show

class F1:    passclass 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 执行 【方法一】 时，过程如下：

根据当前对象中的 类对象指针 找到类中的方法将对象 obj1 当作参数传给 方法的第一个参数 self

欢迎大家对我的博客内容提出质疑和提问！谢谢

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　 笔者：拍省先生　　

python基础-第七篇-7.1初识类和对象