python 读log文件

利用python语言实现读取log文件。并分析文件，计算平均每个事务所用的平均时间，最长，最短时间，统计不完整事务（就是有开始没结束的情况）的总数和详情

部分源码：
# -*- coding: cp936 -*-
#操作系统：winxp
#python版本：2.5

#匹配事务并计算
from datetime import datetime
from DTime import DTime
from DataConvert import DataConvert
class log:

def log(self):

#放置未匹配完成的数据
temp=dict()

#存放待匹配的数据
tempTime=dict()

#存放已匹配完成的数据
avg=dict()

dt=DTime()

i=0

b=True

dc=DataConvert()

items=dc.getData()

strs=items.values()

datas=items.keys()

while b:
try:
#判断数据在之前是否已经存在
order=strs[i][0]
key=strs[i][5]
dtime=strs[i][2]
if temp.has_key(key):
#调用时间转换函数
usetime=dt.convertTime(tempTime.get(key))
othertime=dt.convertTime(dtime)
if usetime>othertime:
usetime=usetime-othertime
elif usetime<othertime:
usetime=othertime-usetime
else:
usetime=usetime-usetime
temp.pop(key)
tempTime.pop(key)
avg[order]=usetime
else:
tempTime[key]=dtime
for k in datas:
if items.get(k)==strs[i]:
temp[key]=k
i=i+1
except:
b=False
print '共处理',i,'条数据'

dc.storeTemp(temp)
return (avg,temp)

#x=log()
#t=x.log()


# -*- coding: cp936 -*-
#从日志文件中得到数据，并处理得到的数据
from File import File
from filterData import filterData
class DataConvert:

def getData(self):

i=0

b=True

self.f=File()

data=dict()

ls=self.f.loadLog()

fd=filterData()

strs=fd.filterStr(ls)

print '加载上次未匹配完的数据'
t=self.f.loadTemp()


if t!=None:
if len(t)!=0:
for value in t.values():
strs.append(value)
print '成功添加上次未匹配完的数据',len(t),'条'

#分解数据
while b:
try:
order=strs[i].split(' ',1)
ip=order[1].split(' [',1)
dtime=ip[1].split('] ',1)
desc=dtime[1].split(': ')
answer=desc[1]
key=strs[i].split(' [')

if data.get(strs[i])!=strs[i]:
l=list()
l.append(order[0])
l.append(ip[0])
l.append(dtime[0])
l.append(desc[0])
l.append(answer)
l.append(key[0])
data[strs[i]]=l
i=i+1
except:
b=False
print '数据转换处理完毕'
return data

def storeTemp(self,temp):
self.f.storeTemp(temp)



#dc=DataConvert()
#dc.getData()


# -*- coding: cp936 -*-
#时间转换类
from datetime import datetime
class DTime:
#datetime(*(time.strptime(date_string, format)[0:6]))
def convertTime(self,dtime):
str=dtime.split(' ')
d=str[0].split('-')
t=str[1].split(':')
yy=d[0]
mm=d[1]
dd=d[2]
hh=t[0]
m=t[1]
ss=t[2]
return datetime(int(yy),int(mm),int(dd),int(hh),int(m),int(ss))


# -*- coding: cp936 -*-
#扫描日志文件
#log为新的要扫描的日志文件
#temp为上次扫描过程中未匹配完的的数据
import cPickle as p
class File:

def loadLog(self):
try:
f=open('log','r')
strs=f.readlines()
return strs
except:
print '加载文件失败，请查看文件是否存在'
finally:
f.close()

def storeTemp(self,data):
try:
f=open('temp','w')
p.dump(data, f)
f.close()
except:
print '存储未匹配完成的数据失败'
finally:
f.close()

def loadTemp(self):
try:
f=open('temp','r')
data=p.load(f)
return data
except:
print '文件中没有数据'
finally:
f.close()


#f=File()
#print f.loadTempTime()



# -*- coding: cp936 -*-

#过滤数据是否合法
class filterData:

def filterStr(self,strs):

i=0

print '一共扫描到',len(strs) ,'条数据'

for spares in strs:
spare=spares.split(' ')
if len(spare)!=7:
i=i+1
strs.remove(spares)
if i!=0:
print '丢弃了',i ,'条不合格的数据'
return strs



#fd=filterData()
#fd.filterStr()

# -*- coding: cp936 -*-
#报表类
class Report:

def report(self,args):
avg=args[0]
leave=args[1]
values=avg.values()
max=values[0]
min=values[0]
maxkeys=list()
minkeys=list()
#find the max value and min value
for value in values:
if max<value:
max=value
if min>value:
min=value
keys=avg.keys()
print '--------------------------报告----------------------------'
print '---完整事务---'
print '完整的事务有：',len(avg),' 个'
print ' 详情如下：'
for key in keys:
if avg.get(key)==max:
maxkeys.append(key)
if avg.get(key)==min:
minkeys.append(key)
#j=j+1
print ' 事务',key,' 的时间为：',avg.get(key)
print ' 其中，最长时间相同的事务有:',len(maxkeys),'个'
for maxkey in maxkeys:
print ' 事务为',maxkey,' 的时间为：',avg.get(maxkey)
print ' 其中，最短时间相同的事务有:',len(minkeys),'个'
for minkey in minkeys:
print ' 事务为',minkey,' 的时间为：',avg.get(minkey)
print '----------------------------------------------------------'
print '---不完整事务----'
print '不完整的事务有：',len(leave),' 个'
print ' 详情如下：'
keys=leave.keys()
for key in keys:
print ' ',leave.get(key)
print '--------------------------结束-----------------------------'

# -*- coding: cp936 -*-
#测试log类
import unittest
from report import Report
from log import log
class TestLog(unittest.TestCase):


def setUp(self):
self.r=Report()
self.Log=log()

def tearDown(self):
self.r=None
self.Log=None

def testLog(self):
test=self.Log.log()
assert test!=None,'测试通过'
#打印报告
self.r.report(test)

def main(self):
suite = unittest.TestLoader().loadTestsFromTestCase(TestLog)
unittest.TextTestRunner().run(suite)


test=TestLog("testLog")
test.main()