python异常处理和面向对象编程总结

我不是女神ヾ 2022-09-29 01:47 144阅读 0赞

异常处理和面向对象编程，是python编程中，比较重要的基础。在实际生产编程设计和开发中，异常处理和面向读象都是必须在设计和开发过程中充分考虑的。  
    对于python开发和面向对象这两部分基础，用一个python程序进行封装说明，结果如下：

#!/usr/bin/env python
    # _*_ coding:utf-8 _*_
    
    #################
    #异常处理
    #################
    print '''
    异常处理是用于处理软件或信息系统中出现的异常状况的一种机制，及超出程序正常执行流程的某些特殊条件。
    在当前主流的编程语言的错误处理机制中，异常处理逐步替代了error code错误的处理方式，异常处理分离了接收和处理错误代码。
    这个功能理清编程思路，使代码的可读性增强，方便维护者阅读和理解。
    '''
    print
    print '''
    异常处理，有称错误处理，提供了程序运行时出现的任何意外或异常情况的方法。
    python异常处理使用try,catch,else,finally等关键字来尝试可能未成功的操作，处理失败及正常情况，在事后清理资源。
    python异常捕捉及处理的语法如下：
    #可能会发生异常的程序块
    try:
                block_try
    #第1种except形式
    except Exception1:
                block_when_exception1_happen
    
    #第2种except形式
    except (Exception2, Exception3, Exception4):
                block_when_exception2_or_3_or_4_happen
    
    #第3种except形式
    except Exception5, variance
        block_when_exception5_happen
    
    #第4种except形式
    except (Exception6, Exception7),variance
        block_when_exception6_or_7_happen
    
    #第5种except形式
    except:
                blok_for_all_other_exceptions
    
    #当没有出现异常情况时的处理
    else:
                block_for_no_exceptions
        
    #无论是否出现异常，最后要做的处理
    finally:
                block_anyway
    '''
    print
    print '''
    异常处理规则分为四部分：
        可能产生异常的代码，写在try块中，try块中发生异常，则try块剩余的代码被终止；
        异常判断和发生时的代码，写在except中，具有有5种形式：
        1是一种异常发生时，执行except块内代码；2是捕获多种异常，执行代码；3是捕获的异常可以转换为变量；4是捕获多种异常转换为变量；5是捕获任何异常；
        每种except捕获形式，都可以定义多次，系统会逐个检查，但有一个满足条件时，执行except块，其他的不再检查和执行，类似于多个if-else条件；
        else是可选模块，定义如果没有发生异常时，需要做的处理；
        finally是可选模块，无论try模块是否发生异常，都会执行这里的代码；
    总结一下，try模块是程序对象，except是异常捕获提交及应对，else是没有异常时的处理，finally是最后必定执行的内容，与是否出现异常无关。
    '''
    print
    #简单异常处理示例
    try:
        result = 3/0
        print "This is never been called"
    except:
        print "Exception happened"
    finally:
        print "Process finished!"
        
    #多个except异常捕获模块的示例
    try:
        myList = [4, 6]
        print myList[10]
        print "This is never been called"
    except ZeroDivisionError, e:
        print "ZeroDivisionError happened"
        print e
    except (IndexError, EOFError), e:
        print "Exception happened"
        print e
    except :
        print "Unkown exception happened"
    else:
        print "No exception happened!"
    finally:
        print "Process finished!"
        
        
    print
    print '''
    除了系统预定义的异常，还可以定义自己的特定逻辑异常。
    自己定义异常，建立一个继承系统异常的子类，并且在需要引发该异常时用raise语句抛出该异常。
    '''
    #自定义异常示例
    import sys
    class MyError(Exception):
        def __str__(self):
            return " I'm a self-defined Error! "
        
    def main_except():
        try:
            print "**********Start of main()**********"
            if len(sys.argv) == 1:
                raise MyError()
            print "**********End of main()**********"
        except MyError, e:
            print e
    
    main_except()
    
    
    #################
    #面向对象编程
    #################
    print 
    print '''
    面向读象编程，与面向过程编程，函数式编程的特点是：
        面向过程：根据业务逻辑从上到下写垒代码
        函数式：将某功能代码封装到函数中，日后便无需重复编写，仅调用函数即可
        面向对象：对函数进行分类和封装，让开发“更快更好更强...”
    面向对象编程是一种编程方式，此编程方式的落地需要使用 “类” 和 “对象” 来实现，所以，面向对象编程其实就是对 “类” 和 “对象” 的使用。
    　　类就是一个模板，模板里可以包含多个函数，函数里实现一些功能
    　　对象则是根据模板创建的实例，通过实例对象可以执行类中的函数
    面向对象的三大特性是指：封装、继承和多态。
    '''
    print 
    print '''
    面向对象是中程序设计规范，也是一种程序开发方法。python即可支持函数式编程，又可以支持面向对象编程，面向对象编程可以实现函数式编程的功能，函数式编程则不一定。
    一般能够使用面向对象编程，就尽量使用面向对象编程来实现。有的高级函数，如C#和Java只支持面向对象编程，不支持函数式编程。
    面向对象，对象是指类的实例，类是创建对象的模板，一个类可以创建多个对象，每个对象都是类类型的一个变量；创建对象的过程，也叫作类的实例化。
    面向对象编程中的主要概念有：
        类 class：定义了一个事物抽象的特点。类定义了事物的属性和它可以做到的行为，一个类中可以有成员函数和成员变量，在面向读象中，成员函数叫方法，成员变量叫属性；
        对象 object：是类的实例，每个类可以有若干个被实例化的对象。在OS中，熊给读象分配内存，不会给类分配内存；
        继承 inheritance：是指通过一个已有的类（父类）定义另外一个类（子类），子类共享父类开放的属性和方法。子类的对象是一个子类的实例，还是父类的一个实例。
        封装性 encapsulation：封装性是指在定义时，可以将不能或不需要其他类知道的成员定义成私有成员，而只公开需要使用的成员，以达到信息隐藏和简化的作用。
        多态性 polymorphism：是指同一方法作用于不同的读象，可以有不同的解释，产生不同的执行结果，在实现上，多态性是孕妇开发者将父对象的变量设置为对子对象的引用，赋值之后，父对象变量就可以根据当前的赋值给子对象的特性以不同方式运作。
    
    随着面向对象编程OOP的普及，面向对象涉及OOD也逐渐成熟，形成了以UML为代表的标准建模语言。
    UML是一个支持模型化和软件系统开发的图形化语言，为软件开发所有阶段提供了模型化和可视化支持，包括有需求分析到规格，再到构造和配置的所有阶段。
    '''
    print
    print "类和读象是面向对象编程的基础，通过在类名后面加小括号可以直接实例化类来获得读象变量，使用对象变量可以访问成员函数和成员变量。在构造函数中不能有返回值。"
    #定义一个类
    class MyClass(object):
        message = "Hello, Developer."
        
        def show(self):
            print self.message
    
    print MyClass.message
    MyClass.message = "Good Morning!"
    print MyClass.message
    inst = MyClass()
    inst.show()
    
    print
    print "构造函数是一种特殊的类成员方法，主要用来在创建对象时，初始化对象，为对象成员赋初始值。python中构造函数用 __init__命名，为类添加一个构造方法，实例一个对象。"
    #定义类，增加构造函数示例
    class MyClass(object):
        message = 'Hello, Developer.'
        
        def show(self):
            print self.message
            
        def _init__(self):
            print "Constructor is called"
    
    inst = MyClass()
    inst.show()
    
    #用默认参数的方式，实现多种方式构造对象
    class MyClass(object):
        message = "Hello, Developer."
        
        def show(self):
            print self.message
        
        def __init__(self, name = "unset", color = "black"):
            print "Constructor is called with params: ", name, " ", color
        
    inst = MyClass()
    inst.show()
    
    inst2 = MyClass("David")
    inst2.show()
    
    inst3 = MyClass("Lisa", "Yellow")
    inst3.show()
    
    inst4 = MyClass(color = "Green")
    inst4.show()
    
    
    print 
    print '''
    析构函数，是构造函数的反向函数，在销毁释放对象时，调用析构函数。析构函数往往做清理善后工作，例如数据库连接，可以用析构函数是否对数据库资源的占用。
    python中为类定义析构函数的方法是在类中定义一个 __del__ 的没有返回值和参数的函数。
    与Java类似，python解释器的堆中存储这正在运行程序锁建立的对象，不需要形式释放；如果需要显示销毁对象，就使用del关键字。
    '''
    #创建类，调用析构函数示例
    class MyClass(object):
        message = 'Hello, Developer.'
        
        def show(self):
            print self.message
        
        def __init__(self, name = 'unset', color = "black"):
            print "Constructor is called with params: ", name, " ", color
        
        def __del__(self):
            print "Destructor is called!"
        
    inst = MyClass()
    inst.show()
    
    inst2 = MyClass("David")    
    inst2.show()
    
    del inst, inst2
    
    inst3 = MyClass("Lisa", "Yellow")
    inst3.show()
    
    del inst3
    
    print 
    print "类中有共享成员变量，如上面类中的message。如果要定义每个对象自己的成员变量，就要在构造函数中定义self引用的变量，即实例成员变量。"
    #实例成员变量示例
    class MyClass(object):
        message = "Hello, Developer."
        
        def show(self):
            print self.message
            print "Here is %s in %s!" % (self.name, self.color)
        
        def __init__(self, name = "unset", color = "black"):
            print "Constructor is called with params : ", name, " ", color
            self.name = name
            self.color = color
        
        def __del__(self):
            print "Destructor is called for %s!" % self.name
        
    inst2 = MyClass("David")    
    inst2.show()
    print "Color of inst2 is ", inst2.color, "\n"
    
    inst3 = MyClass("Lisa", "Yellow")
    inst3.show()
    print "Name of inst3 is ", inst3.name, "\n"
    
    del inst2, inst3
    
    
    print '''
    访问类时，类成员函数与实例绑定，只能通过对象访问而不能通过类名访问。
    python中支持两种基于类名访问成员的函数：静态函数和类函数，它们的不同点是类函数有一个隐形参数cls可以用来获取类信息，而静态函数没有改参数。
    静态函数使用装饰器@staticmethod定义，类函数使用 装饰器@classmethod 定义。
    '''
    #静态函数和类函数的代码示例
    class MyClass(object):
        message = "Hello, Developer."
        
        def show(self):
            print self.message
            print "Here is %s in %s !" % (self.name, self.color)
        
        @staticmethod
        def printMessage():
            print "print Message is called"
            print MyClass.message
        
        @classmethod
        def createObj(cls, name, color):
            print "Object will be created: %s(%s, %s)" % (cls.__name__, name, color)
            return cls(name, color)
        
        def __init__(self, name = "unset", color = "black" ):
            print "Constructor is called with params: ", name, " ", color
            self.name = name
            self.color = color
            
        def __del__(self):
            print "Destructor is called for %s !" % self.name
            
    MyClass.printMessage()
    
    inst = MyClass.createObj("Toby", "Red")
    print inst.message
    del inst
    
    print
    print '''
    封装性，是面向读象编程的重要特点，python也提供了不让外部看到成员吟唱起来的私有成员机制。
    但与大多数编程语言用public,private关键字表达可见范围的方法不同，python指定变量名格式的方法定义私有成员,以双下划线__开始命名的成员都是是有成员变量。
    '''
    #封装，私有成员示例代码
    class MyClass(object):
        def __init__(self, name = "unset", color = "black"):
            print "Constructor is called with params: ", name, " ", color
            self.__name = name
            self.__color = color
        
        def __del__(self):
            print "Destructor is called for %s!" % self.__name
        
    inst = MyClass("Jojo", "White")    
    del inst
    
    print '''
    继承，类之间的继承是面向对象设计的重要方法，通过继承可以简化代码和优化设计模式。
    python类在定义时，可以在小括号中指定基类，所有python类都是object类型的子类，语法如下：
    class BaseClass(object):      #父类定义
        block_class
        
    class SubClass(BaseClass):    #子类定义
        block_class
    
    子类除了具备自己的 block_class 中定义的特性，还从父类继承了非私有特性。
    在子类的析构函数中调用基类的析构函数，是一种比较好的方法，但这样可能导致父类资源不能如期被释放。
    '''
    #继承，子类继承父类示例
    class Base(object):
        def __init__(self):
            print "Constructor fo Base is called !"
        
        def __del__(self):
            print "Destructor of Base is called !"
        
        def move(self):
            print "move called in Base !"
        
    class SubA(Base):
        def __init__(self):
            print "Constructor of subA is called ! "
        
        def move(self):
            print "move called in subA ! "
            
    class SubB(Base):        
        def __del__(self):
            print "Destructor of SubB is called ! "
            super(SubB, self).__del__()
        
    instA = SubA()
    instA.move()
    del instA
    
    print "-----------------------"    
    instB = SubB()
    instB.move()
    del instB
    
    print
    print "python中允许类的多继承，也就是一个子类可以有多个基类。"
    #一个子类，继承多个父类示例
    class BaseA(object):
        def move(self):
            print "move called in BaseA ! "
        
    class BaseB(object):    
        def move(self):
            print "move called in BaseB ! "
    
    class BaseC(BaseA):    
        def move(self):
            print "move called in BaseC ! "
        
    class Sub(BaseC, BaseB):    
        pass
        
    inst = Sub()    
    inst.move()

该脚本执行结果如下：

# python try.py 
    
    异常处理是用于处理软件或信息系统中出现的异常状况的一种机制，及超出程序正常执行流程的某些特殊条件。
    在当前主流的编程语言的错误处理机制中，异常处理逐步替代了error code错误的处理方式，异常处理分离了接收和处理错误代码。
    这个功能理清编程思路，使代码的可读性增强，方便维护者阅读和理解。
    
    
    
    异常处理，有称错误处理，提供了程序运行时出现的任何意外或异常情况的方法。
    python异常处理使用try,catch,else,finally等关键字来尝试可能未成功的操作，处理失败及正常情况，在事后清理资源。
    python异常捕捉及处理的语法如下：
    #可能会发生异常的程序块
    try:
                block_try
    #第1种except形式
    except Exception1:
                block_when_exception1_happen
    
    #第2种except形式
    except (Exception2, Exception3, Exception4):
                block_when_exception2_or_3_or_4_happen
    
    #第3种except形式
    except Exception5, variance
        block_when_exception5_happen
    
    #第4种except形式
    except (Exception6, Exception7),variance
        block_when_exception6_or_7_happen
    
    #第5种except形式
    except:
                blok_for_all_other_exceptions
    
    #当没有出现异常情况时的处理
    else:
                block_for_no_exceptions
        
    #无论是否出现异常，最后要做的处理
    finally:
                block_anyway
    
    
    
    异常处理规则分为四部分：
        可能产生异常的代码，写在try块中，try块中发生异常，则try块剩余的代码被终止；
        异常判断和发生时的代码，写在except中，具有有5种形式：
        1是一种异常发生时，执行except块内代码；2是捕获多种异常，执行代码；3是捕获的异常可以转换为变量；4是捕获多种异常转换为变量；5是捕获任何异常；
        每种except捕获形式，都可以定义多次，系统会逐个检查，但有一个满足条件时，执行except块，其他的不再检查和执行，类似于多个if-else条件；
        else是可选模块，定义如果没有发生异常时，需要做的处理；
        finally是可选模块，无论try模块是否发生异常，都会执行这里的代码；
    总结一下，try模块是程序对象，except是异常捕获提交及应对，else是没有异常时的处理，finally是最后必定执行的内容，与是否出现异常无关。
    
    
    Exception happened
    Process finished!
    Exception happened
    list index out of range
    Process finished!
    
    
    除了系统预定义的异常，还可以定义自己的特定逻辑异常。
    自己定义异常，建立一个继承系统异常的子类，并且在需要引发该异常时用raise语句抛出该异常。
    
    **********Start of main()**********
     I'm a self-defined Error! 
    
    
    面向读象编程，与面向过程编程，函数式编程的特点是：
        面向过程：根据业务逻辑从上到下写垒代码
        函数式：将某功能代码封装到函数中，日后便无需重复编写，仅调用函数即可
        面向对象：对函数进行分类和封装，让开发“更快更好更强...”
    面向对象编程是一种编程方式，此编程方式的落地需要使用 “类” 和 “对象” 来实现，所以，面向对象编程其实就是对 “类” 和 “对象” 的使用。
    　　类就是一个模板，模板里可以包含多个函数，函数里实现一些功能
    　　对象则是根据模板创建的实例，通过实例对象可以执行类中的函数
    面向对象的三大特性是指：封装、继承和多态。
    
    
    
    面向对象是中程序设计规范，也是一种程序开发方法。python即可支持函数式编程，又可以支持面向对象编程，面向对象编程可以实现函数式编程的功能，函数式编程则不一定。
    一般能够使用面向对象编程，就尽量使用面向对象编程来实现。有的高级函数，如C#和Java只支持面向对象编程，不支持函数式编程。
    面向对象，对象是指类的实例，类是创建对象的模板，一个类可以创建多个对象，每个对象都是类类型的一个变量；创建对象的过程，也叫作类的实例化。
    面向对象编程中的主要概念有：
        类 class：定义了一个事物抽象的特点。类定义了事物的属性和它可以做到的行为，一个类中可以有成员函数和成员变量，在面向读象中，成员函数叫方法，成员变量叫属性；
        对象 object：是类的实例，每个类可以有若干个被实例化的对象。在OS中，熊给读象分配内存，不会给类分配内存；
        继承 inheritance：是指通过一个已有的类（父类）定义另外一个类（子类），子类共享父类开放的属性和方法。子类的对象是一个子类的实例，还是父类的一个实例。
        封装性 encapsulation：封装性是指在定义时，可以将不能或不需要其他类知道的成员定义成私有成员，而只公开需要使用的成员，以达到信息隐藏和简化的作用。
        多态性 polymorphism：是指同一方法作用于不同的读象，可以有不同的解释，产生不同的执行结果，在实现上，多态性是孕妇开发者将父对象的变量设置为对子对象的引用，赋值之后，父对象变量就可以根据当前的赋值给子对象的特性以不同方式运作。
    
    随着面向对象编程OOP的普及，面向对象涉及OOD也逐渐成熟，形成了以UML为代表的标准建模语言。
    UML是一个支持模型化和软件系统开发的图形化语言，为软件开发所有阶段提供了模型化和可视化支持，包括有需求分析到规格，再到构造和配置的所有阶段。
    
    
    类和读象是面向对象编程的基础，通过在类名后面加小括号可以直接实例化类来获得读象变量，使用对象变量可以访问成员函数和成员变量。在构造函数中不能有返回值。
    Hello, Developer.
    Good Morning!
    Good Morning!
    
    构造函数是一种特殊的类成员方法，主要用来在创建对象时，初始化对象，为对象成员赋初始值。python中构造函数用 __init__命名，为类添加一个构造方法，实例一个对象。
    Hello, Developer.
    Constructor is called with params:  unset   black
    Hello, Developer.
    Constructor is called with params:  David   black
    Hello, Developer.
    Constructor is called with params:  Lisa   Yellow
    Hello, Developer.
    Constructor is called with params:  unset   Green
    Hello, Developer.
    
    
    析构函数，是构造函数的反向函数，在销毁释放对象时，调用析构函数。析构函数往往做清理善后工作，例如数据库连接，可以用析构函数是否对数据库资源的占用。
    python中为类定义析构函数的方法是在类中定义一个 __del__ 的没有返回值和参数的函数。
    与Java类似，python解释器的堆中存储这正在运行程序锁建立的对象，不需要形式释放；如果需要显示销毁对象，就使用del关键字。
    
    Constructor is called with params:  unset   black
    Hello, Developer.
    Constructor is called with params:  David   black
    Hello, Developer.
    Destructor is called!
    Destructor is called!
    Constructor is called with params:  Lisa   Yellow
    Hello, Developer.
    Destructor is called!
    
    类中有共享成员变量，如上面类中的message。如果要定义每个对象自己的成员变量，就要在构造函数中定义self引用的变量，即实例成员变量。
    Constructor is called with params :  David   black
    Hello, Developer.
    Here is David in black!
    Color of inst2 is  black 
    
    Constructor is called with params :  Lisa   Yellow
    Hello, Developer.
    Here is Lisa in Yellow!
    Name of inst3 is  Lisa 
    
    Destructor is called for David!
    Destructor is called for Lisa!
    
    访问类时，类成员函数与实例绑定，只能通过对象访问而不能通过类名访问。
    python中支持两种基于类名访问成员的函数：静态函数和类函数，它们的不同点是类函数有一个隐形参数cls可以用来获取类信息，而静态函数没有改参数。
    静态函数使用装饰器@staticmethod定义，类函数使用 装饰器@classmethod 定义。
    
    print Message is called
    Hello, Developer.
    Object will be created: MyClass(Toby, Red)
    Constructor is called with params:  Toby   Red
    Hello, Developer.
    Destructor is called for Toby !
    
    
    封装性，是面向读象编程的重要特点，python也提供了不让外部看到成员吟唱起来的私有成员机制。
    但与大多数编程语言用public,private关键字表达可见范围的方法不同，python指定变量名格式的方法定义私有成员,以双下划线__开始命名的成员都是是有成员变量。
    
    Constructor is called with params:  Jojo   White
    Destructor is called for Jojo!
    
    继承，类之间的继承是面向对象设计的重要方法，通过继承可以简化代码和优化设计模式。
    python类在定义时，可以在小括号中指定基类，所有python类都是object类型的子类，语法如下：
    class BaseClass(object):      #父类定义
        block_class
        
    class SubClass(BaseClass):    #子类定义
        block_class
    
    子类除了具备自己的 block_class 中定义的特性，还从父类继承了非私有特性。
    在子类的析构函数中调用基类的析构函数，是一种比较好的方法，但这样可能导致父类资源不能如期被释放。
    
    Constructor of subA is called ! 
    move called in subA ! 
    Destructor of Base is called !
    -----------------------
    Constructor fo Base is called !
    move called in Base !
    Destructor of SubB is called ! 
    Destructor of Base is called !
    
    python中允许类的多继承，也就是一个子类可以有多个基类。
    move called in BaseC !