engsol <en********@ipns.com> wrote in message news:<cs********************************@4ax.com>. ..
I'm using Python to parse a bunch of s/w test files and make csv files for later report generation by MS ACCESS....(my boss
loves the quick turn-around compared to C). Each log file may contain one or more 'sessions', and each session may contain
one or more 'nodes'.
Each session in the log has an ASCII start and stop time, as does each node.
I have the basic parse part done for parameters, errors, etc., but noticed my routine for determining how long each
session/node took (delta time) was a bit repetitive, so decided to make a 'stand-alone' routine to handle this.
The time format from the log is in the format of:
hh:mm:ss
and is a string with leading zeros where appropiate. Date is never a factor. The longest "delta" is maybe 5 hours.
The routine I came up with is below, but seems a bit clunky.
Is there a better way of doing this? I think it relies too much on integers rounding off in the proper direction, a la
d_time_hr = d_time / 3600 below.
It also relies on -Qold. Please use the // operator for integer
division. Or you're going to regret it when you upgrade to Python
3.0.
Also, this will have to transition to Linux, if that makes a difference.
In your code, it makes no difference. I'm using a Linux box right
now.
START CODE:
import string
Unless you have a very old version of Python, this is no longer
needed; string.atoi has been officially replaced with the "int"
constructor.
def deltatime(start, stop):
t_start = (string.atoi(start[0:2]) * 3600) + (string.atoi(start[3:5]) * 60) + string.atoi(start[6:8])
t_stop = (string.atoi(stop [0:2]) * 3600) + (string.atoi(stop [3:5]) * 60) + string.atoi(stop [6:8])
Rather than count character positions, take advantage of the fact that
the strings are colon-delimited.
def toSeconds(timeString):
hour, min, sec = map(int, timeString.split(':'))
return (hour * 60 + min) * 60 + sec
t_start = toSeconds(start)
t_stop = toSeconds(stop)
if t_start < t_stop:
d_time = t_stop - t_start
else:
d_time = (86400 - t_start) + t_stop
You can eliminate the if-else test by taking advantage of Python's %
operator
d_time = (t_stop - t_start) % 86400
d_time_hr = d_time / 3600
d_time_min = (d_time - d_time_hr * 3600) / 60
d_time_sec = (d_time - d_time_hr * 3600) - (d_time_min * 60)
Rather than calculate remainders the hard way, use the % operator. Or
since you need both the quotient and remainder, use the divmod
function.
d_time_min, d_time_sec = divmod(d_time, 60)
d_time_hr, d_time_min = divmod(d_time_min, 60)
return str(d_time_hr) + 'hr ' + str(d_time_min) + 'min ' + str(d_time_sec) + 'sec'
A more concise way of writing this is
return '%dhr %dmin %ssec' % (d_time_hr, d_time_min, d_time_sec)
The complete rewritten function is
def deltatime(start, stop):
def toSeconds(timeString):
hour, min, sec = map(int, timeString.split(':'))
return (hour * 60 + min) * 60 + sec
t_start = toSeconds(start)
t_stop = toSeconds(stop)
d_time = (t_stop - t_start) % 86400
d_time_min, d_time_sec = divmod(d_time, 60)
d_time_hr, d_time_min = divmod(d_time_min, 60)
return '%dhr %dmin %ssec' % (d_time_hr, d_time_min, d_time_sec)
which is still too verbose for my tastes; I would rewrite it as:
def deltatime(start, stop):
def toSeconds(timeString):
hour, min, sec = map(int, timeString.split(':'))
return (hour * 60 + min) * 60 + sec
d_time_min, d_time_sec = divmod(toSeconds(stop) - toSeconds(start),
60)
d_time_hr, d_time_min = divmod(d_time_min, 60)
return '%dhr %dmin %ssec' % (d_time_hr % 24, d_time_min,
d_time_sec)
