python学习笔记8--面向对象编程

1、面向对象编程

面向对象--Object Oriented Programming，简称oop，是一种程序设计思想。在说面向对象以前，先说一下什么是编程范式，编程范式你按照什么方式来去编程，去实现一个功能。举个例子，你要作饭，能够用电磁炉，也能够用煤气灶。不一样的编程范式本质上表明对各类类型的任务采起的不一样的解决问题的思路，两种最重要的编程范式分别是面向过程编程和面向对象编程。

提到面向对象，就不得不提到另外一种编程思想，面向过程；什么是面向过程呢，面向过程的思想是把一个项目、一件事情按照必定的顺序，从头至尾一步一步地作下去，先作什么，后作什么，一直到结束。这种思想比较好理解，其实这也是一我的作事的方法，咱们以前编程的思想也都是使用这种思想。这种编程思想，只要前面有一个步骤变了，那么后面的就也要变，后面维护起来比较麻烦，这样的编程思想，咱们在写一些简单的小程序、只执行一次的脚本时可使用。而面向对象呢，面向对象的思想是把一个项目、一件事情分红更小的项目，或者说分红一个个更小的部分，每一部分负责什么方面的功能，最后再由这些部分组合而成为一个总体。这种思想比较适合多人的分工合做，就像一个大的机关，分各个部门，每一个部门分别负责某样职能，各个部门能够充分发挥本身的特点，只要符合必定前提就好了。

举个例子：好比刚才说的一个大的机关，要作某一个项目，从面向过程的思想来讲，应该是这样分析的，先怎么样，再怎么样，最后怎么样。第同样应该如何完成，第二样应该如何完成等等。等到每一步骤都完成，项目也就完成了。而面向对象的思想则应该是这样想的，这个项目是由几个部分组成的，咱们就作好分工，成立一个部门来作一个部分的功能，另外一个部门来作另外一个部分。各个部门能够不用理解其余部门的事，只要完成本身那一部分的事情就OK了。

2、面向对象的特性

类：class

类，对比现实世界来讲就是一个种类，一个模型。

一个类便是对一类拥有相同属性的对象的抽象、蓝图、原型。

在类中定义了这些对象的都具有的属性（variables(data)）、共同的方法。

对象：object

对象，也就是指模型造出来的具体的东西。

一个对象便是一个类的实例化后实例，一个类必须通过实例化后方可在程序中调用，一个类能够实例化多个对象，每一个对象亦能够有不一样的属性，就像人类是指全部人，每一个人是指具体的对象，人与人以前有共性，亦有不一样。

实例化：

初始化一个类，造了一个对象。把一个类变成一个具体的对象的过程，叫作实例化。

封装：

把一些功能的实现细节不对外暴露，类中对数据的赋值、内部调用对外部用户是透明的，这使类变成了一个胶囊或容器，里面包含着类的数据和方法。

好比说造的一我的，你把他身体内部的什么心肝脾肺肾都封装起来了，其余人都看不到，你直接找这我的。

继承：

一个类能够派生出子类，在这个父类里定义的属性、方法自动被子类继承。好比说你继承了你父亲的姓。

python3中多继承都是广度优先，python2中经典类的多继承是深度优先，新式类的多继承是按照广度优先的。

继承是为了代码的重用

多态：

对不一样类的对象发出相同的消息将会有不一样的行为。好比，你的老板让全部员工在九点钟开始工做, 他只要在九点钟的时候说：“开始工做”便可，而不须要对销售人员说：“开始销售工做”，对技术人员说：“开始技术工做”, 由于“员工”是一个抽象的事物, 只要是员工就能够开始工做，他知道这一点就好了。至于每一个员工，固然会各司其职，作各自的工做。

多态就是抽象化的一种体现，把一系列具体事物的共同点抽象出来, 再经过这个抽象的事物, 与不一样的具体事物进行对话。

一种接口，多种实现。

3、面向对象的好处

对于编程语言的初学者来说，OOP不是一个很容易理解的编程方式，你们虽然都按老师讲的都知道OOP的三大特性是继承、封装、多态，而且你们也都知道了如何定义类、方法等面向对象的经常使用语法，可是一到真正写程序的时候，仍是不少人喜欢用函数式编程来写代码，特别是初学者，很容易陷入一个窘境就是“我知道面向对象，我也会写类，但我依然没发如今使用了面向对象后，对咱们的程序开发效率或其它方面带来什么好处，由于我使用函数编程就能够减小重复代码并作到程序可扩展了，为啥子还用面向对象？”对于此，我我的以为缘由应该仍是由于你没有充分了解到面向对象能带来的好处。

不管用什么形式来编程，咱们都要明确记住如下原则：

写重复代码是很是很差的低级行为

你写的代码须要常常变动

开发正规的程序跟那种写个运行一次就扔了的小脚本一个很大不一样就是，你的代码老是须要不断的更改，不是修改bug就是添加新功能等，因此为了往后方便程序的修改及扩展，你写的代码必定要遵循易读、易改的原则（专业数据叫可读性好、易扩展）。

若是你把一段一样的代码复制、粘贴到了程序的多个地方以实如今程序的各个地方调用，这个功能，那往后你再对这个功能进行修改时，就须要把程序里多个地方都改一遍，这种写程序的方式是有问题的，由于若是你不当心漏掉了一个地方没改，那可能会致使整个程序的运行都 出问题。 所以咱们知道 在开发中必定要努力避免写重复的代码，不然就至关于给本身再挖坑。

还好，函数的出现就能帮咱们轻松的解决重复代码的问题，对于须要重复调用的功能，只须要把它写成一个函数，而后在程序的各个地方直接调用这个函数名就行了，而且当须要修改这个功能时，只需改函数代码，而后整个程序就都更新了。

其实OOP编程的主要做用也是使你的代码修改和扩展变的更容易，那么小白要问了，既然函数都能实现这个需求了，还要OOP干毛线用呢？ 呵呵，说这话就像，古时候，人们打仗杀人都用刀，后来出来了枪，它的主要功能跟刀同样，也是杀人，而后小白就问，既然刀能杀人了，那还要枪干毛线，哈哈，显而易见，由于枪能更好更快更容易的杀人。函数编程与OOP的主要区别就是OOP可使程序更加容易扩展和易更改。

4、类

一些概念：

属性：属性就是类里面的一个变量，有类变量和实例变量，类变量是类在定义的时候就有的，实例变量是在实例化的时候才产生的变量。这个能够理解为，人是一个类，他的名字、年龄、性别就是它的属性。

方法：方法就是类的功能，也就是定义在类里面的函数，它实现了某个功能，好比说人有睡觉的功能。

构造函数：什么是构造函数，就是类在实例化的时候作的某些初始化操做，好比说人，你造一个汽车的时候，它得有颜色、型号等等。

析构函数：析构函数就是这个实例在销毁的时候作的一些操做。

定义类：

定义类使用class关键字，类名通常咱们开发的时候首字母要大写。python中有经典类和新式类，他俩在python3中没有区别，在python2中经典类在多继承的时候是深度优先，新式类是广度优先。python3中统一是广度优先，这个后面在说继承的时候会说。

class Car():#模型，模板
	def __del__(self):
		#析构函数，这个实例被销毁的执行的。
		print('over..')

	def my_self(self):
		print(
			'我是一个汽车 个人颜色是【%s】,我有【%s】个窗户'%(self.color,self.window)
		)
		self.price = 10002
	def run(self):
		print(self.color)
		print(self.window)
		print(self.price)
		print('汽车在跑。。。')

	def __init__(self,color,window):
		#
		#构造函数，是类在初始化的时候会执行它
		#若是你的类在实例化的时候要传入一些参数，那么你就要在__init__这个函数里写参数了
		self.color = color  #绑定属性
		self.window = window
		print('执行我了。。')

#把模型作成实际的一个汽车，这个过程叫作实例化。
bus = Car('黄色','3开门') #实例化
bus2 = Car('黑色','4开门') #实例化
bus3 = Car('粉色','2开门') #实例化
bus.my_self()   #
bus2.my_self()
bus3.my_self()

#实例就是指具体造出来的东西，经过类实例化处理的东西，就是实例
#对象，就是实例

继承：

                class F(object):
                    '''
                    这个是父类
                    '''
                    def __init__(self,name,sex):
                        self.name = name
                        self.sex = sex
                    def info():#方法
                        print('name is %s sex is %s '%(self.name,self.sex))
                class S(F):#继承F这个类
                    pass
                s1 = S('牛牛','男')#实例化子类
                s1.info()#由于继承父类，因此父类的方法他都有
                那若是在父类里面有一个方法，子类里面也有的话，可是子类想重写一下父类的方法，增长新功能下面这么写：
                class test():
                    def __init__(self,name):
                        self.name = name
                class test1(test):
                    def __init__(self,name,age):
                        # test.__init__(self,name)#修改父类的方法，这个是经典类里面的写法
                        super(test1,self).__init__(name)#和上面的效果同样，这个是新式类里面的写法
                        self.name = name
                        self.age = age
                test1('name','age')
                多继承，上面写的都是单继承的，python里面还支持多继承，多继承就是继承多个父类，在python3中多继承都是广度优先的，在python2中有点不一样，经典类是深度优先，新式类是广度优先。
                class A:
                    def say(self):
                        print('A')
                class B(A):
                    # pass
                    def say(self):
                        print('B')
                class C(A):
                    pass
                    # def say(self):
                    #     print('c')
                class D(C,B):
                    pass
                s=D()
                s.say()　　

 

多态：python里面是不直接支持多态的，能够经过别的方法来实现多态。经过下面的例子就能够实现一种接口，多种实现，对于下面的cry方法来讲，无论你传入的是什么对象，只要有cry的方法，都会去调用它的cry方法，不用再一个个的去调用了　

                
                class Animal(object):
                    '''
                    父类
                    '''
                    def __init__(self,name):
                        self.name = name
                class Dog(Animal):
                    '''
                    狗类，有叫的方法
                    '''
                    def cry(self):
                        print('狗 [%s] 汪汪汪'%self.name)
                class Cat(Animal):
                    '''
                    猫类，有叫的方法
                    '''
                    def cry(self):
                        print('猫 [%s] 喵喵喵'%self.name)
                def cry(obj):
                    '''
                    定义一个函数，去调用传进来的实例的cry方法
                    '''
                    obj.cry()
                d1 = Dog('大黄')#实例化狗
                d2 = Dog('小黄')#实例化狗
                c1 = Cat('小白')#实例化猫
                c2 = Cat('小黑')#实例化猫
                cry(d1)#把对象d1传进来
                cry(d2)#把对象d2传进来
                objs = [d1,d2,c1,c2]#把上面实例化的对象都放到一个list里面
                for obj in objs:#循环统一调用
                    cry(obj)　　

　

私有方法，私有属性：什么是私有，私有就是只有在类里面能够访问，实例化以后不能够访问和调用，有私有方法和私有属性。私有就把变量名或者函数名前面加上"__"两个下划线，其实就是经过私有来实现封装的。

                class Dog(object):
                    __type = '狗'#私有属性
                    def cry(self):
                        self.__test()#调用私有方法
                        print('私有属性%s'%self.__type)
                        print('狗 [%s] 汪汪汪'%self.name)
                    def __test(self):#私有方法
                        self.name = 'test'#
                d = D()
                d.cry()#正常能够调用
                d.__type#报错，由于是私有属性，在外面不能访问
                d.__test()#报错，由于是私有方法，在外面不能访问

静态方法和类方法：

        class Stu(object):
            country = 'china'#类变量
            def __init__(self,name):
                self.name = name
            @staticmethod
            #静态方法，和类自己没有什么关系了，就至关于在类里面定义了一个方法而已
            def say():
                print('xxx')
            @classmethod#类方法
            #静态方法，和类方法不一样的是，它可使用类变量，必需要传一个值，表明的就是这个类
            def hello(cls):
                 print(cls.country)
            def hi(self):
                #这个是实例方法
                print(self.name)
        t = Stu('name')
        Stu.hello()
        Stu.say()
        t.hi()
        t.say()
        t.hello()