面对对象&异常&模块
一 . 工厂模式
解耦: 降低耦合
def order(self,car_type):
class Store(object):
#工厂方法模式 : 在接口定义抽象方法 在子类中实现
def select_car(self):
pass
def order(self,car_type):
return self.select_car(car_type)
class BMWCarStore(Store):
def select_car(self,car_type):
return BMWFactory().select_car_by_type(car_type)
bmw_store = BMWCarStore()
bmw = bmw_store.order("720li")
class CarStore(Store):
def select_car(self,car_type):
return Factory().select_car_by_type(car_type)
class BMWFactory(object):
def select_car_by_type(self,car_type):
pass
if car_type = "720li":
return Mingtu()
elif car_type == 'Ix35':
return Ix35()
elif car_type == "mini":
return Sounata()
if car_type == 'mini':
return Suonata()
elif car_type == '720li':
return Mingtu()
elif car_type == 'x6':
return Ix35()
class Factory(object):
#解耦 工厂模式
def select_car_by_type(car_type):
return Fute()
if(car_type=="桑塔纳"):
return Santana()
elif car_type=="福特":
class Car(object):
def move(self):
print("车在移动...")
def music(self):
print("正在播放音乐")
def stop(self):
print("车已停止")
class Santana(Car):
pass
class Fute(Car):
pass
class Mingtu(Car):
pass
class Suonata(Car):
pass
class Ix35(Car):
pass
car_store = CarStore()
car =car_store.order("桑塔纳")
car.move()
car.music()
定义一个创建对象的接口(可以理解为函数),但由子类决定要实例化的类是哪个,
工厂方法的实例化推迟到子类,抽象的CarStore提供了一个创建createCar,也叫做工厂方法
子类真正实现这个createCar方法创建出具体产品.i创建者类不需要直到实际创建的产品是哪一个,选择
了使用了那个子类,自然也就决定了实际创建的产品是什么.
二 . __new__
__new__
class A (object):
"""docstring for ."""
def __init__(self):
print('这是init方法')
def __new__(cls):
print("这是new方法")
return object.__new__(cls)
a = A()
-
__new__
-
__new__
__new__
__new__
__new__
-
__init__
__new__
__init__
__new__
__init__
- 我们将类比作制造商,
__new__
__init__
a= A()
相当于做了三件事:
- 1.调用
__new__
方法创建对象,然后找一个变量来接收
__new__
的返回值,这个返回值表示创建出来的对象的引用
- 2.
__init__(刚刚创建出来的对象的应用)
- 3.返回对象的引用
注意:
__init__
方法不等于构造方法
__init__
只负责初始化
__new___
只负责创建
两者结合==构造方法
三 单例模式
只能创建同一对象的类
# 实例化一个单例
class Singleton(object):
__instance = None
__first_init = False
def __new__(cls, age, name):
#只产生同一对象
if cls.__instance == None:
cls.__instance = object.__new__(cls)
return cls.__instance
def __init__(self, age, name):
#只初始化一次
if self.__first_init == False:
self.name = name
self.age = age
self.__first_init == True
a = Singleton(, "longge")
b = Singleton(, "long")
print(id(a))
print(id(b))
print(a.age)
print(b.age)
四 捕获异常
<1> 捕获异常 try…except..
try:
pass #可能会出异常的操作
except IOError:
pass #异常处理
<2> except 捕获多个异常
try:
open("123.txt","r") # 文件不存在产生错误
print num #num 未定义产生错误
except IOError
print('产生错误')
还会产生错误 ,问题不止一个
try:
open("123.txt","r") # 文件不存在产生错误
print num #num 未定义产生错误
except (IOError,NameError): #捕获多个异常使用元组 将可能产生的异常的名字卸载except 后 并使用元组方式存储
print(errorMsg) #errorMsg保存捕获到的错误信息
<3> 捕获所有异常
# 不存储异常的基本信息
try:
open("123.txt","r") # 文件不存在产生错误
print num #num 未定义产生错误
except :
print('产生错误')
# 捕获所有异常,并存储异常基本信息
try:
open("123.txt","r") # 文件不存在产生错误
print num #num 未定义产生错误
except Exception as result:
print('产生错误')
else:
print('没有产生异常')
<6> try…finally
用来处理必须的执行,无论是否产生异常 eg:文件关闭,释放锁,把数据库进行链接返还给链接池等
try:
f = open("test")
while True:
content = f.readLine()
if len(content)==:
break
time.sleep()
print(content)
finally:
f.close()
print('关闭文件')
五 传递异常
def test1():
print("----test1----")
open('num')
print("----test1---2-")
def test2():
print("----test2----")
test1()
print("----test2---2-")
def test3():
try:
print("----test3----1")
test1()
print("----test3----2")
except Exception as result:
print('捕获所有异常:%s'%result)
print("----test3----3")
test3()
print("-------------------")
test2()
异常: test1 (产生异常,不处理)—->test3 ( 处理异常,未返回test1)
—–>test2 (未处理异常,继续传递,所有都没处理,进行默认异常处理)
<六> 抛出自定义异常
可用raise 语句引发一个异常, 异常/错误对象必须有一个名字,且它们应是Error或Exception类的子类
class ShortInputException(Exception):
'''自定异常类'''
def __init__(self ,length,atleast):
#super.__init__()
self.length = length
self.atleast = atleast
try:
s = input('请输入-->')
if len(s) < :
#raise 引发一个自定的异常
raise ShortInputException(len(s),)
except EOFError:
print('你输入了结束标志EOF')
except ShortInputException as result:
print('ShortInputException:输入长度是%d,长度应为 %d'%(result.length,result.atleast))
else:
print('没有异常发生')
注意: #super().init() 可调用可不调用,建议调用,因为init方法往往是用来对创建完的对象进行初始化工作,
如果在子类中重写父类的init方法意味着父类中的很多初始化工作没有做,不能保证程序的稳定,
重写init方法做好先调用父类该方法,再添加自己的功能
七 异常中抛出异常
class Test(object):
def __init__(self,switch):
self.switch =switch
def calc(self,a,b):
try:
return a/b
except Exception as result:
if self.switch:
print('捕获开启,已经捕获异常,信息如下:')
print(result)
else:
#重新抛出此异常,并且不会被这个异常处理捕获,出发默认异常处理
raise
a = Test(True)
a.calc(,)
print('--------------从天而降割线------------------')
a.switch =False
a.calc(,)
![TestLink导出用例转换工具(XML2Excel)[图]](data:image/gif;base64,R0lGODlhAQABAIAAAP///wAAACwAAAAAAQABAAACAkQBADs=)