异常处理和面向对象编程,是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
- Exception happened
- list index out of range
- Process
-
-
- 除了系统预定义的异常,还可以定义自己的特定逻辑异常。
- 自己定义异常,建立一个继承系统异常的子类,并且在需要引发该异常时用raise语句抛出该异常。
-
- **********Start of main()**********
- I
来自 “ ITPUB博客 ” ,链接:http://blog.itpub.net/24638123/viewspace-2135220/,如需转载,请注明出处,否则将追究法律责任。
转载于:http://blog.itpub.net/24638123/viewspace-2135220/