delta time = time stop - time start

[Dan Bishop]

engsol <engsolnorm at ipns.com> wrote in message news:<cs9910pcgktdrp1e8abctoptue7braqvqu at 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)