Python(七)-面对对象编程

第一章 面向对象设计的问题

    1、什么是面向对象编程
         -- 以前使用函数来实现，使用函数比较复杂的实现，现在使用面向对象，实现起来更简单。
         -- 面向对象就是现在就是用类和对象来进行实现
    2、什么是类？什么是对象？两者又有什么关系？
        -- 类里面就是函数的集合
        -- 例如：obj = 类名()，
            obj就是对象，这个过程叫做实例化的过程，最后调用时使用对象名.函数()的格式进行调用，例如：obj.函数()。
        -- 两者的关系是实例化与被实例化，调用与被调用的关系。
    3、什么时候适用面向对象？
        -- 根据一个模板创建某些东西时。
        -- 当很多函数需要传多个相同参数时。
        -- 当函数中又有很多重复代码时。        

第二章 面向对象基础概述

2.1 面向过程

    根据业务逻辑从上到下垒加代码（如果程序修改，对于依赖的过程都需要进行修改）

2.2练习代码

        面向对象编程方式实现监控报警：
            #/usr/bin/env python
           while True:
                if cpu利用率 > 90 %:
                   BR # 发送邮件提醒/BR
                    连接邮箱服务器
                    发送邮件
                    关闭连接
                if 硬盘使用空间 > 90 %:
                    # 发送邮件提醒
                    连接邮箱服务器
                    发送邮件
                    关闭连接
                if 内存占用 > 80 %:
                    # 发送邮件提醒
                    连接邮箱服务器
                    发送邮件
                    关闭连接       

2.3 函数式

    将某功能代码封装到函数中，如后便无需重复编写，仅仅需要代用函数即可。
面向对象
        
    世界万物，皆可分类。
    世界万物，皆为对象。
    只要是对象，就肯定属于某种品类。
    只要是对象，就肯定有属性（名称或功能）
    对函数进行分类和封装，让开发“更快、更好、更强”
    无论用什么形式来编程，我们都要明确记住以下原则：
        写重复代码是非常低级的行为
        你写的代码需要经常变更。

2.4使用函数式编程来实现，增强代码的重用性和可读性 

        #/usr/bin/env python
        def 发送邮件(内容)
            # 发送邮件提醒
            连接邮箱服务器
            发送邮件
            关闭连接
        while True：
            if cpu利用率 > 90 %:
                发送邮件('CPU报警')
            if 硬盘使用空间 > 90 %:
                发送邮件('硬盘报警')
            if 内存占用 > 80 %:
                发送邮件('内存报警') 

第三章 面向对象简介    

3.1、类的特性 

        类有三大特性：封装、继承、多态。
        封装特性：
            防止数据被随意修改。
        继承特性：
            通过父类--->子类的fang'shi方式以最小代码量的方式实现不同角色的共同点,和不同点的同时存在。
            经典类重构写法：
                SchoolMember.__init__(self,name,age,sex)
            新式类重构写法(强烈推荐使用)：
                super(Teacher,self).__init__(name,age,sex)
        多态特性：
            -- 多态是面向对象语言的一个基本特性，多态意味着变量并不知道引用的对象是什么。
            -- 根据引用对象的不同表现不同的行为方式，在处理多态对象时，只需要关注它的接口即可。
            -- 可以看到跟一般的静态语言相比，Python并没有在语言级别来保证接口的正确性。
            -- 只能依靠文档、代码来保证。

3.2、类的定义

    例如：
        定义：
        class Dog(object):
            def __init__(self,name,age):
                self.NAME=name
                self.AGE=age
            def sayhi(self):
                print("hello, you is a dog.")
        实例化：
            d = Dog()
        调用：
            d.sayhi()
    类---->实例化---->实例对象
    __init__   构造函数
    self.NAME=name 属性，成员变量
    def sayhi() 方法，动态属性。

3.3  使用面向对象来实现代码

　　面向对象编程是一种编程方式，此变成方式和落地需要使用“类（class）”和“对象（object）”来实现，所以，面向对象编程其实就是对“类”和“对象”的使用。
        
　　类就是一个模板，模板里可以包含多个函数，函数里实现具体功能（把一个类变成具体的过程叫做实例化）
        
　　对象则是根据模板创建的实例，通过实例对象可以执行类中函数。

    class Dog(object):
        def __init__(self,name):  #构造函数，构造方法， 等于 初始化方法。所有传进来的参数先传到这里。。
            self.NAME = name    #其中self就是d或者d2
        def sayhi(self):  #类的方法
            print("hello , i am a dog .my name is ",self.NAME)
        def eat(self,food):
            print("%s is eating %s "%(self.NAME,food))
    d = Dog("Lichuang")
    d2 = Dog("Chuang2")
    
    d.sayhi()
    d2.eat("baozi")

第四章 面向对象三大特征    

    面向对象的三大特性：封装、继承、多态

4.1 封装    

    在类中对数据的赋值，内部调用对外部用户是透明的，这使类变成了类似一个容器，里面包含着类的数据和方法。
    接下来我们进一步细分封装功能

4.1.1 封装调用    

    1、通过对象直接调用

        #/usr/bin/env python
        class C1:   #创建类
            # init构造函数，在实例化时做一些类的初始化的工作
            def __init__(self,name):
                self.name=name
            #创建一个功能方法，
            def chi(self,food): #方法可以穿参数一个food
                print("%s正在吃%s"%(self.name,food))
        
        #实例化C1的类，将实例化功能的name在实例化时传进来。
        obj1 = C1('陈鑫')
        obj2 = C1('蜡笔小新')
        
        #进行调用类，使用chi的方法，将方法的参数在调用时穿入进去即可
        obj1.chi('汉堡')
        obj2.chi('米饭')

    2、通过self间接调用
        执行类中的方法时，需要通过self间调用被封装的内容

        class F2():
            def __init__(self,name,age):
                self.name = name
                self.age = age    
        
            def test(self):
                print(self.name)
                print(self.age)
        
        test1=F2('chenxin',22)  
        test1.test()  ##Python默认会将test1传给self参数，self.test()即相当于test1.test(test1),所以self=tets1，因此self.name就是chenxin，self.age是22

    上述内容，对于面向对象的封装来说，其实就是使用构造方法将内容封装到对象中，然后通过对象直接或者self间接获取被封装的内容。    

4.1.2 练习题：在终端输出如下信息

    沁夫，30岁，女，搞网恋。
    沁夫，30岁，女，不学习，搞毛细。
    沁夫，30岁，女，很坑爹（坑了我）。
    
    刘强，35岁，男，每天大保健。
    刘强，35岁，男，每天净扯淡。
    刘强，35岁，男，常年蹲级生。

函数式编程方法：
    
    #函数式编程方法（面向过程）：

        def baojian(name,age,gender):
            print("%s,%s岁,%s,每天大保健。"%(name,age,gender))
        def chedan(name,age,gender):
            print("%s,%s岁,%s,每天净扯淡。"%(name,age,gender))
        def kengdie(name,age,gender):
            print("%s,%s岁,%s,很坑爹（坑了我）。
"%(name,age,gender))
        
        baojian('沁夫',30,'女')
        chedan('沁夫',30,'女')
        kengdie('沁夫',30,'女')
        
        baojian('刘强',30,'男')
        chedan('刘强',30,'男')
        kengdie('刘强',30,'男')

    #面向对象编程方法：

    #上述对比，可以看出，如果使用函数式编程，需要在每次执行函数时传入形同的参数，如果参数多的话，又需要粘贴复制了；而对面向对象值需要在创建对象的时，将所有需要的参数封装到当前对象中，之后再次使用时，通过self间接去当前对象中取值就可以了。

4.1.3总结：  

    1、封装不需要重复传入相同的参数。
    2、高内聚，低耦合（即是类里面的方法与都在一个类里面，与外界没关系。）

4.2 继承

    一个类可以派生出子类，在这个父类里定义的属性、方法自动被子类继承。

4.2.1 举例说明    

    开发人员：开发代码，吃，喝，拉，撒
    运维人员：运维工作，吃，喝，拉，撒
 
    #简单实现的内容

 #/usr/bin/env python
    class kaifa:
        def kaifadaima(self):
            print('开发代码')
        def chi(self):
            print('吃')
        def he(self):
            print('喝')
        def la(self):
            print('拉')
        def sa(self):
            print('撒')
    class yunwei:
        def yunweigongzuo(self):
            print('运维工作')
        def chi(self):
            print('吃')
        def he(self):
            print('喝')
        def la(self):
            print('拉')
        def sa(self):
            print('撒')       

    #使用面向对象编程中“继承”的方式实现：

 
    class ren:
        def chi(self):
            print('%s 吃 '%(self.name))
        def he(self):
            print('%s 喝'%(self.name))
        def la(self):
            print('%s 拉'%(self.name))
        def sa(self):
            print('%s 撒'%(self.name))
    
    class kaifa(ren):
        def __init__(self,name):
            self.name=name
            self.renyuan="开发人员"
        def cry(self):
            print('%s 开发代码---->%s '%(self.name,self.renyuan))
    class yunwei(ren):
        def __init__(self,name):
            self.name= name
            self.renyuan="运维人员"
        def cry(self):
            print('%s 运维工作---->%s'%(self.name,self.renyuan))
    
    kf = kaifa('沁夫')
    kf.cry()
    kf.chi()
    kf.he()
    kf.la()
    kf.sa()
    
    yw = yunwei('陈鑫')
    yw.cry()
    yw.chi()
    yw.he()
    yw.la()
    yw.sa()
    
    ##对于面向对象那个的继承来说，其实就是将多个类有的方法提取到父类中，子类仅需继承父类而不必--实现每个方法，避免重复造轮子。
    注意：除了子类和父类的称谓，你可能看到过 派生类和基类，他们与子类和父类只是叫法不同。

2.4.2 多级继承

    1、Python的类可以继承多个类，Java和C#中则只能继承一个类。
    2、Python的类如果继承多个类，那么其寻找方法的方式有两种，分别是：深度查找和广度查找。
        
        python2经典类，按深度优先来继承。
        python2新式类，按广度优先来继承。
        python3经典类，新式类，是按广度优先来继承。
    

经典类（深度优先）
    
    当类是经典类时，多继承情况下，会按照深度优先方式查找。
    #经典类写法：
        class A1:
            pass
        class A2(A1):
            pass
    经典类实战:
        
        class A:
            def bar(self):
                print('A.bar')
        class B(A):
            # pass
        
            def bar(self):
                print('B.bar')
        class C(A):
            # pass
        
            def bar(self):
                print('C.bar')
        class D(B,C):
            # pass
            def bar(self):
                print('D.bar')
        a=D()
        a.bar()
    #执行bar方法时（在Python2.0中）
        首先去D中查找bar方法，如果D没有，就去B中查找，如果B中没有，再去A查找，如果A没有，则去C中查找。
        查找顺序：D-->B-->A-->C
    #执行bar方法时（在Python3.0中）
        首先在D中查找bar方法，如果D没有，就去B中查找，如果B中没有，再去C中查找，最后去A查找。
        查找顺序：D-->B-->C-->A
新式类（广度优先）
    
    当新式类时，多继承情况下，会按照广度优先方式查找。
    #新式类写法：
        class N1(object):
            pass
        class N2(N1):
            pass
    #新式类实战：
        class A(object):
            # pass
            def bar(self):
               print('A.bar')
        class B(A):
             pass
        
            # def bar(self):
            #    print('B.bar')
        class C(A):
            pass
        
            # def bar(self):
            #     print('C.bar')
        class D(B,C):
             pass
            # def bar(self):
            #    print('D.bar')
        a=D()
        a.bar()
        
    #执行bar方式时，（不管是Python2，还是Python3）
        首先在D中查找bar方法，如果D没有，就去B中查找，如果B中没有，再去C中查找，最后去A查找。
        查找顺序：D-->B-->C-->A

2.4.3 广度查找和深度查找         

　 广度查找顺序：如图
    深度查找顺序：如图

2.5 多态

　　多态是面向对象的重要特性，简单点说:一个接口，多种实现。

    #/usr/bin/env python
    class F1(object):
        pass
    class S1(object):
        def show(self):
            print('S1.show')
    
    class S2(F1):
        def show(self):
            print('S2.show')
    def Func(obj):     #在这个函数中的obj的就是实例化后的对象。
        print(obj.show())   #对象在此调用两个类相同的方法，进而实现一个接口，多种实现。
    
    s1_obj = S1()  #实例化S1类
    Func(s1_obj)
    
    s2_obj = S2() #实例化S2类
    Func(s2_obj)