mirror of
https://github.com/python/cpython.git
synced 2025-10-31 02:15:10 +00:00
328 lines
15 KiB
TeX
328 lines
15 KiB
TeX
\section{\module{time} ---
|
|
Time access and conversions}
|
|
|
|
\declaremodule{builtin}{time}
|
|
\modulesynopsis{Time access and conversions.}
|
|
|
|
|
|
This module provides various time-related functions.
|
|
It is always available, but not all functions are available
|
|
on all platforms.
|
|
|
|
An explanation of some terminology and conventions is in order.
|
|
|
|
\begin{itemize}
|
|
|
|
\item
|
|
The \dfn{epoch}\index{epoch} is the point where the time starts. On
|
|
January 1st of that year, at 0 hours, the ``time since the epoch'' is
|
|
zero. For \UNIX, the epoch is 1970. To find out what the epoch is,
|
|
look at \code{gmtime(0)}.
|
|
|
|
\item
|
|
The functions in this module do not handle dates and times before the
|
|
epoch or far in the future. The cut-off point in the future is
|
|
determined by the C library; for \UNIX, it is typically in
|
|
2038\index{Year 2038}.
|
|
|
|
\item
|
|
\strong{Year 2000 (Y2K) issues}:\index{Year 2000}\index{Y2K} Python
|
|
depends on the platform's C library, which generally doesn't have year
|
|
2000 issues, since all dates and times are represented internally as
|
|
seconds since the epoch. Functions accepting a time tuple (see below)
|
|
generally require a 4-digit year. For backward compatibility, 2-digit
|
|
years are supported if the module variable \code{accept2dyear} is a
|
|
non-zero integer; this variable is initialized to \code{1} unless the
|
|
environment variable \envvar{PYTHONY2K} is set to a non-empty string,
|
|
in which case it is initialized to \code{0}. Thus, you can set
|
|
\envvar{PYTHONY2K} to a non-empty string in the environment to require 4-digit
|
|
years for all year input. When 2-digit years are accepted, they are
|
|
converted according to the \POSIX{} or X/Open standard: values 69-99
|
|
are mapped to 1969-1999, and values 0--68 are mapped to 2000--2068.
|
|
Values 100--1899 are always illegal. Note that this is new as of
|
|
Python 1.5.2(a2); earlier versions, up to Python 1.5.1 and 1.5.2a1,
|
|
would add 1900 to year values below 1900.
|
|
|
|
\item
|
|
UTC\index{UTC} is Coordinated Universal Time\index{Coordinated
|
|
Universal Time} (formerly known as Greenwich Mean
|
|
Time,\index{Greenwich Mean Time} or GMT). The acronym UTC is not a
|
|
mistake but a compromise between English and French.
|
|
|
|
\item
|
|
DST is Daylight Saving Time,\index{Daylight Saving Time} an adjustment
|
|
of the timezone by (usually) one hour during part of the year. DST
|
|
rules are magic (determined by local law) and can change from year to
|
|
year. The C library has a table containing the local rules (often it
|
|
is read from a system file for flexibility) and is the only source of
|
|
True Wisdom in this respect.
|
|
|
|
\item
|
|
The precision of the various real-time functions may be less than
|
|
suggested by the units in which their value or argument is expressed.
|
|
E.g.\ on most \UNIX{} systems, the clock ``ticks'' only 50 or 100 times a
|
|
second, and on the Mac, times are only accurate to whole seconds.
|
|
|
|
\item
|
|
On the other hand, the precision of \function{time()} and
|
|
\function{sleep()} is better than their \UNIX{} equivalents: times are
|
|
expressed as floating point numbers, \function{time()} returns the
|
|
most accurate time available (using \UNIX{} \cfunction{gettimeofday()}
|
|
where available), and \function{sleep()} will accept a time with a
|
|
nonzero fraction (\UNIX{} \cfunction{select()} is used to implement
|
|
this, where available).
|
|
|
|
\item
|
|
The time value as returned by \function{gmtime()},
|
|
\function{localtime()}, and \function{strptime()}, and accepted by
|
|
\function{asctime()}, \function{mktime()} and \function{strftime()},
|
|
is a sequence of 9 integers. The return values of \function{gmtime()},
|
|
\function{localtime()}, and \function{strptime()} also offer attribute
|
|
names for individual fields.
|
|
|
|
\begin{tableiii}{c|l|l}{textrm}{Index}{Attribute}{Values}
|
|
\lineiii{0}{\member{tm_year}}{(for example, 1993)}
|
|
\lineiii{1}{\member{tm_mon}}{range [1,12]}
|
|
\lineiii{2}{\member{tm_mday}}{range [1,31]}
|
|
\lineiii{3}{\member{tm_hour}}{range [0,23]}
|
|
\lineiii{4}{\member{tm_min}}{range [0,59]}
|
|
\lineiii{5}{\member{tm_sec}}{range [0,61]; see \strong{(1)} in \function{strftime()} description}
|
|
\lineiii{6}{\member{tm_wday}}{range [0,6], Monday is 0}
|
|
\lineiii{7}{\member{tm_yday}}{range [1,366]}
|
|
\lineiii{8}{\member{tm_isdst}}{0, 1 or -1; see below}
|
|
\end{tableiii}
|
|
|
|
Note that unlike the C structure, the month value is a
|
|
range of 1-12, not 0-11. A year value will be handled as described
|
|
under ``Year 2000 (Y2K) issues'' above. A \code{-1} argument as the
|
|
daylight savings flag, passed to \function{mktime()} will usually
|
|
result in the correct daylight savings state to be filled in.
|
|
|
|
When a tuple with an incorrect length is passed to a function
|
|
expecting a time tuple, or having elements of the wrong type, a
|
|
\exception{TypeError} is raised.
|
|
|
|
\versionchanged[The time value sequence was changed from a tuple to a
|
|
specialized type, with the addition of attribute names
|
|
for the fields]{2.2}
|
|
\end{itemize}
|
|
|
|
The module defines the following functions and data items:
|
|
|
|
|
|
\begin{datadesc}{accept2dyear}
|
|
Boolean value indicating whether two-digit year values will be
|
|
accepted. This is true by default, but will be set to false if the
|
|
environment variable \envvar{PYTHONY2K} has been set to a non-empty
|
|
string. It may also be modified at run time.
|
|
\end{datadesc}
|
|
|
|
\begin{datadesc}{altzone}
|
|
The offset of the local DST timezone, in seconds west of UTC, if one
|
|
is defined. This is negative if the local DST timezone is east of UTC
|
|
(as in Western Europe, including the UK). Only use this if
|
|
\code{daylight} is nonzero.
|
|
\end{datadesc}
|
|
|
|
\begin{funcdesc}{asctime}{\optional{tuple}}
|
|
Convert a tuple representing a time as returned by \function{gmtime()}
|
|
or \function{localtime()} to a 24-character string of the following form:
|
|
\code{'Sun Jun 20 23:21:05 1993'}. If \var{tuple} is not provided, the
|
|
current time as returned by \function{localtime()} is used.
|
|
Locale information is not used by \function{asctime()}.
|
|
\note{Unlike the C function of the same name, there is no trailing
|
|
newline.}
|
|
\versionchanged[Allowed \var{tuple} to be omitted]{2.1}
|
|
\end{funcdesc}
|
|
|
|
\begin{funcdesc}{clock}{}
|
|
On \UNIX, return
|
|
the current processor time as a floating point number expressed in
|
|
seconds. The precision, and in fact the very definition of the meaning
|
|
of ``processor time''\index{CPU time}\index{processor time}, depends
|
|
on that of the C function of the same name, but in any case, this is
|
|
the function to use for benchmarking\index{benchmarking} Python or
|
|
timing algorithms.
|
|
|
|
On Windows, this function returns wall-clock seconds elapsed since the
|
|
first call to this function, as a floating point number,
|
|
based on the Win32 function \cfunction{QueryPerformanceCounter()}.
|
|
The resolution is typically better than one microsecond.
|
|
\end{funcdesc}
|
|
|
|
\begin{funcdesc}{ctime}{\optional{secs}}
|
|
Convert a time expressed in seconds since the epoch to a string
|
|
representing local time. If \var{secs} is not provided, the current time
|
|
as returned by \function{time()} is used. \code{ctime(\var{secs})}
|
|
is equivalent to \code{asctime(localtime(\var{secs}))}.
|
|
Locale information is not used by \function{ctime()}.
|
|
\versionchanged[Allowed \var{secs} to be omitted]{2.1}
|
|
\end{funcdesc}
|
|
|
|
\begin{datadesc}{daylight}
|
|
Nonzero if a DST timezone is defined.
|
|
\end{datadesc}
|
|
|
|
\begin{funcdesc}{gmtime}{\optional{secs}}
|
|
Convert a time expressed in seconds since the epoch to a time tuple
|
|
in UTC in which the dst flag is always zero. If \var{secs} is not
|
|
provided, the current time as returned by \function{time()} is used.
|
|
Fractions of a second are ignored. See above for a description of the
|
|
tuple lay-out.
|
|
\versionchanged[Allowed \var{secs} to be omitted]{2.1}
|
|
\end{funcdesc}
|
|
|
|
\begin{funcdesc}{localtime}{\optional{secs}}
|
|
Like \function{gmtime()} but converts to local time. The dst flag is
|
|
set to \code{1} when DST applies to the given time.
|
|
\versionchanged[Allowed \var{secs} to be omitted]{2.1}
|
|
\end{funcdesc}
|
|
|
|
\begin{funcdesc}{mktime}{tuple}
|
|
This is the inverse function of \function{localtime()}. Its argument
|
|
is the full 9-tuple (since the dst flag is needed; use \code{-1} as
|
|
the dst flag if it is unknown) which expresses the time in
|
|
\emph{local} time, not UTC. It returns a floating point number, for
|
|
compatibility with \function{time()}. If the input value cannot be
|
|
represented as a valid time, either \exception{OverflowError} or
|
|
\exception{ValueError} will be raised (which depends on whether the
|
|
invalid value is caught by Python or the underlying C libraries). The
|
|
earliest date for which it can generate a time is platform-dependent.
|
|
\end{funcdesc}
|
|
|
|
\begin{funcdesc}{sleep}{secs}
|
|
Suspend execution for the given number of seconds. The argument may
|
|
be a floating point number to indicate a more precise sleep time.
|
|
The actual suspension time may be less than that requested because any
|
|
caught signal will terminate the \function{sleep()} following
|
|
execution of that signal's catching routine. Also, the suspension
|
|
time may be longer than requested by an arbitrary amount because of
|
|
the scheduling of other activity in the system.
|
|
\end{funcdesc}
|
|
|
|
\begin{funcdesc}{strftime}{format\optional{, tuple}}
|
|
Convert a tuple representing a time as returned by \function{gmtime()}
|
|
or \function{localtime()} to a string as specified by the \var{format}
|
|
argument. If \var{tuple} is not provided, the current time as returned by
|
|
\function{localtime()} is used. \var{format} must be a string.
|
|
\versionchanged[Allowed \var{tuple} to be omitted]{2.1}
|
|
|
|
The following directives can be embedded in the \var{format} string.
|
|
They are shown without the optional field width and precision
|
|
specification, and are replaced by the indicated characters in the
|
|
\function{strftime()} result:
|
|
|
|
\begin{tableiii}{c|p{24em}|c}{code}{Directive}{Meaning}{Notes}
|
|
\lineiii{\%a}{Locale's abbreviated weekday name.}{}
|
|
\lineiii{\%A}{Locale's full weekday name.}{}
|
|
\lineiii{\%b}{Locale's abbreviated month name.}{}
|
|
\lineiii{\%B}{Locale's full month name.}{}
|
|
\lineiii{\%c}{Locale's appropriate date and time representation.}{}
|
|
\lineiii{\%d}{Day of the month as a decimal number [01,31].}{}
|
|
\lineiii{\%H}{Hour (24-hour clock) as a decimal number [00,23].}{}
|
|
\lineiii{\%I}{Hour (12-hour clock) as a decimal number [01,12].}{}
|
|
\lineiii{\%j}{Day of the year as a decimal number [001,366].}{}
|
|
\lineiii{\%m}{Month as a decimal number [01,12].}{}
|
|
\lineiii{\%M}{Minute as a decimal number [00,59].}{}
|
|
\lineiii{\%p}{Locale's equivalent of either AM or PM.}{}
|
|
\lineiii{\%S}{Second as a decimal number [00,61].}{(1)}
|
|
\lineiii{\%U}{Week number of the year (Sunday as the first day of the
|
|
week) as a decimal number [00,53]. All days in a new year
|
|
preceding the first Sunday are considered to be in week 0.}{}
|
|
\lineiii{\%w}{Weekday as a decimal number [0(Sunday),6].}{}
|
|
\lineiii{\%W}{Week number of the year (Monday as the first day of the
|
|
week) as a decimal number [00,53]. All days in a new year
|
|
preceding the first Monday are considered to be in week 0.}{}
|
|
\lineiii{\%x}{Locale's appropriate date representation.}{}
|
|
\lineiii{\%X}{Locale's appropriate time representation.}{}
|
|
\lineiii{\%y}{Year without century as a decimal number [00,99].}{}
|
|
\lineiii{\%Y}{Year with century as a decimal number.}{}
|
|
\lineiii{\%Z}{Time zone name (no characters if no time zone exists).}{}
|
|
\lineiii{\%\%}{A literal \character{\%} character.}{}
|
|
\end{tableiii}
|
|
|
|
\noindent
|
|
Notes:
|
|
|
|
\begin{description}
|
|
\item[(1)]
|
|
The range really is \code{0} to \code{61}; this accounts for leap
|
|
seconds and the (very rare) double leap seconds.
|
|
\end{description}
|
|
|
|
Here is an example, a format for dates compatible with that specified
|
|
in the \rfc{2822} Internet email standard.
|
|
\footnote{The use of \code{\%Z} is now
|
|
deprecated, but the \code{\%z} escape that expands to the preferred
|
|
hour/minute offset is not supported by all ANSI C libraries. Also,
|
|
a strict reading of the original 1982 \rfc{822} standard calls for
|
|
a two-digit year (\%y rather than \%Y), but practice moved to
|
|
4-digit years long before the year 2000. The 4-digit year has
|
|
been mandated by \rfc{2822}, which obsoletes \rfc{822}.}
|
|
|
|
\begin{verbatim}
|
|
>>> from time import gmtime, strftime
|
|
>>> strftime("%a, %d %b %Y %H:%M:%S +0000", gmtime())
|
|
'Thu, 28 Jun 2001 14:17:15 +0000'
|
|
\end{verbatim}
|
|
|
|
Additional directives may be supported on certain platforms, but
|
|
only the ones listed here have a meaning standardized by ANSI C.
|
|
|
|
On some platforms, an optional field width and precision
|
|
specification can immediately follow the initial \character{\%} of a
|
|
directive in the following order; this is also not portable.
|
|
The field width is normally 2 except for \code{\%j} where it is 3.
|
|
\end{funcdesc}
|
|
|
|
\begin{funcdesc}{strptime}{string\optional{, format}}
|
|
Parse a string representing a time according to a format. The return
|
|
value is a tuple as returned by \function{gmtime()} or
|
|
\function{localtime()}. The \var{format} parameter uses the same
|
|
directives as those used by \function{strftime()}; it defaults to
|
|
\code{"\%a \%b \%d \%H:\%M:\%S \%Y"} which matches the formatting
|
|
returned by \function{ctime()}. The same platform caveats apply; see
|
|
the local \UNIX{} documentation for restrictions or additional
|
|
supported directives. If \var{string} cannot be parsed according to
|
|
\var{format}, \exception{ValueError} is raised. Values which are not
|
|
provided as part of the input string are filled in with default
|
|
values; the specific values are platform-dependent as the XPG standard
|
|
does not provide sufficient information to constrain the result.
|
|
\end{funcdesc}
|
|
|
|
\begin{datadesc}{struct_time}
|
|
The type of the time value sequence returned by \function{gmtime()},
|
|
\function{localtime()}, and \function{strptime()}.
|
|
\versionadded{2.2}
|
|
\end{datadesc}
|
|
|
|
\begin{funcdesc}{time}{}
|
|
Return the time as a floating point number expressed in seconds since
|
|
the epoch, in UTC. Note that even though the time is always returned
|
|
as a floating point number, not all systems provide time with a better
|
|
precision than 1 second. While this function normally returns
|
|
non-decreasing values, it can return a lower value than a previous
|
|
call if the system clock has been set back between the two calls.
|
|
\end{funcdesc}
|
|
|
|
\begin{datadesc}{timezone}
|
|
The offset of the local (non-DST) timezone, in seconds west of UTC
|
|
(negative in most of Western Europe, positive in the US, zero in the
|
|
UK).
|
|
\end{datadesc}
|
|
|
|
\begin{datadesc}{tzname}
|
|
A tuple of two strings: the first is the name of the local non-DST
|
|
timezone, the second is the name of the local DST timezone. If no DST
|
|
timezone is defined, the second string should not be used.
|
|
\end{datadesc}
|
|
|
|
|
|
\begin{seealso}
|
|
\seemodule{locale}{Internationalization services. The locale
|
|
settings can affect the return values for some of
|
|
the functions in the \module{time} module.}
|
|
\seemodule{calendar}{General calendar-related functions.
|
|
\function{timegm()} is the inverse of
|
|
\function{gmtime()} from this module.}
|
|
\end{seealso}
|