The time
module provides a number of functions that deal with dates and the
time within a day. It’s a thin layer on top of the C runtime library.
A given date and time can either be represented as a floating-point value (the number of seconds since a reference date, usually January 1, 1970), or as a time tuple.
Example 1-79 shows how you can use the time
module to get the current time.
Example 1-79. Using the time Module to Get the Current Time
File: time-example-1.py import time now = time.time() print now, "seconds since", time.gmtime(0)[:6] print print "or in other words:" print "- local time:", time.localtime(now) print "- utc:", time.gmtime(now)937758359.77 seconds since (1970, 1, 1, 0, 0, 0)
or in other words:
- local time: (1999, 9, 19, 18, 25, 59, 6, 262, 1)
- utc: (1999, 9, 19, 16, 25, 59, 6, 262, 0)
The tuple returned by localtime
and
gmtime
contains the year, month, day, hour, minute,
second, day of the week, day of the year, daylight savings flag. The
year
number is four digits, the day of week begins with 0 for Monday,
and January 1 is day number 1.
You can of course use standard string-formatting operators to convert
a time tuple to a string, but the time
module also
provides a number of standard conversion functions, as Example 1-80 illustrates.
Example 1-80. Using the time Module to Format Dates and Times
File: time-example-2.py import time now = time.localtime(time.time()) print time.asctime(now) print time.strftime("%y/%m/%d %H:%M", now) print time.strftime("%a %b %d", now) print time.strftime("%c", now) print time.strftime("%I %p", now) print time.strftime("%Y-%m-%d %H:%M:%S %Z", now) # do it by hand... year, month, day, hour, minute, second, weekday, yearday, daylight = now print "%04d-%02d-%02d" % (year, month, day) print "%02d:%02d:%02d" % (hour, minute, second) print ("MON", "TUE", "WED", "THU", "FRI", "SAT", "SUN")[weekday], yeardaySun Oct 10 21:39:24 1999
99/10/10 21:39
Sun Oct 10
Sun Oct 10 21:39:24 1999
09 PM
1999-10-10 21:39:24 CEST
1999-10-10
21:39:24
SUN 283
On some platforms, the time
module contains a
strptime
function, which is pretty much the
opposite of strftime
. Given a string and a
pattern, it returns the corresponding time tuple, as shown in Example 1-81.
The time.strptime
function is currently only made
available by Python if it’s provided by the platform’s C libraries.
For platforms that don’t have a standard implementation (this includes
Windows), Example 1-82 offers a partial replacement.
Example 1-82. A strptime Implementation
File: strptime.py import re import string MONTHS = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"] SPEC = { # map formatting code to a regular expression fragment "%a": "(?P<weekday>[a-z]+)", "%A": "(?P<weekday>[a-z]+)", "%b": "(?P<month>[a-z]+)", "%B": "(?P<month>[a-z]+)", "%C": "(?P<century>\d\d?)", "%d": "(?P<day>\d\d?)", "%D": "(?P<month>\d\d?)/(?P<day>\d\d?)/(?P<year>\d\d)", "%e": "(?P<day>\d\d?)", "%h": "(?P<month>[a-z]+)", "%H": "(?P<hour>\d\d?)", "%I": "(?P<hour12>\d\d?)", "%j": "(?P<yearday>\d\d?\d?)", "%m": "(?P<month>\d\d?)", "%M": "(?P<minute>\d\d?)", "%p": "(?P<ampm12>am|pm)", "%R": "(?P<hour>\d\d?):(?P<minute>\d\d?)", "%S": "(?P<second>\d\d?)", "%T": "(?P<hour>\d\d?):(?P<minute>\d\d?):(?P<second>\d\d?)", "%U": "(?P<week>\d\d)", "%w": "(?P<weekday>\d)", "%W": "(?P<weekday>\d\d)", "%y": "(?P<year>\d\d)", "%Y": "(?P<year>\d\d\d\d)", "%%": "%" } class TimeParser: def _ _init_ _(self, format): # convert strptime format string to regular expression format = string.join(re.split("(?:\s|%t|%n)+", format)) pattern = [] try: for spec in re.findall("%\w|%%|.", format): if spec[0] == "%": spec = SPEC[spec] pattern.append(spec) except KeyError: raise ValueError, "unknown specificer: %s" % spec self.pattern = re.compile("(?i)" + string.join(pattern, "")) def match(self, daytime): # match time string match = self.pattern.match(daytime) if not match: raise ValueError, "format mismatch" get = match.groupdict().get tm = [0] * 9 # extract date elements y = get("year") if y: y = int(y) if y < 68: y = 2000 + y elif y < 100: y = 1900 + y tm[0] = y m = get("month") if m: if m in MONTHS: m = MONTHS.index(m) + 1 tm[1] = int(m) d = get("day") if d: tm[2] = int(d) # extract time elements h = get("hour") if h: tm[3] = int(h) else: h = get("hour12") if h: h = int(h) if string.lower(get("ampm12", "")) == "pm": h = h + 12 tm[3] = h m = get("minute") if m: tm[4] = int(m) s = get("second") if s: tm[5] = int(s) # ignore weekday/yearday for now return tuple(tm) def strptime(string, format="%a %b %d %H:%M:%S %Y"): return TimeParser(format).match(string) if _ _name_ _ == "_ _main_ _": # try it out import time print strptime("2000-12-20 01:02:03", "%Y-%m-%d %H:%M:%S") print strptime(time.ctime(time.time()))(2000, 12, 20, 1, 2, 3, 0, 0, 0)
(2000, 11, 15, 12, 30, 45, 0, 0, 0)
Converting a time tuple back to a time value is pretty easy, at least
as long as we’re talking about local time. Just pass the time tuple
to the mktime
function, as shown in Example 1-83.
Unfortunately, there’s no function in the 1.5.2 standard library that
converts UTC time tuples back to time values
(neither in Python nor in the underlying C libraries). Example 1-84 provides a Python implementation of such a function, called
timegm
.
Example 1-84. Converting a UTC Time Tuple to a Time Integer
File: time-example-4.py import time def _d(y, m, d, days=(0,31,59,90,120,151,181,212,243,273,304,334,365)): # map a date to the number of days from a reference point return (((y - 1901)*1461)/4 + days[m-1] + d + ((m > 2 and not y % 4 and (y % 100 or not y % 400)) and 1)) def timegm(tm, epoch=_d(1970,1,1)): year, month, day, h, m, s = tm[:6] assert year >= 1970 assert 1 <= month <= 12 return (_d(year, month, day) - epoch)*86400 + h*3600 + m*60 + s t0 = time.time() tm = time.gmtime(t0) print tm print t0 print timegm(tm)(1999, 9, 8, 22, 12, 12, 2, 251, 0)
936828732.48
936828732
In 1.6 and later, a similar function is available in the
calendar
module, as calendar.timegm
.
The time
module can be used to time the execution
of a Python program, as Example 1-85 demonstrates. You can measure either “wall time”
(real world time), or “process time” (amount of CPU
time the process has consumed, thus far).
Example 1-85. Using the time Module to Benchmark an Algorithm
File: time-example-5.py import time def procedure(): time.sleep(2.5) # measure process time t0 = time.clock() procedure() print time.clock() - t0, "seconds process time" # measure wall time t0 = time.time() procedure() print time.time() - t0, "seconds wall time"0.0 seconds process time
2.50903499126 seconds wall time
Not all systems can measure the true process time. On such systems
(including Windows), clock
usually measures the
wall time since the program was started.
The process time has limited precision. On many systems, it wraps around after just over 30 minutes.
Also, see the timing
module, which measures
the wall time between two events.
Get Python Standard Library now with the O’Reilly learning platform.
O’Reilly members experience books, live events, courses curated by job role, and more from O’Reilly and nearly 200 top publishers.