码迷,mamicode.com
首页 > 编程语言 > 详细

Python(七)-面对对象编程

时间:2016-11-28 23:16:05      阅读:238      评论:0      收藏:0      [点我收藏+]

标签:连接   3.3   gdi   学习   内存   原则   邮件   多重   复杂   

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

    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,很坑爹(坑了我)。\n"%(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)

Python(七)-面对对象编程

标签:连接   3.3   gdi   学习   内存   原则   邮件   多重   复杂   

原文地址:http://www.cnblogs.com/cxcx/p/6111447.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!