More markup additions

fa91858c · Andrew M. Kuchling · 63b482ce · fa91858c
Kaydet (Commit) fa91858c authored Ara 30, 2002 tarafından Andrew M. Kuchling
Hide whitespace changes
Inline Side-by-side

Showing with 264 additions and 156 deletions

libdatetime.tex Doc/lib/libdatetime.tex +264 -156

No files found.
--- a/Doc/lib/libdatetime.tex
+++ b/Doc/lib/libdatetime.tex
@@ -147,9 +147,11 @@ between two dates or times.
    and days, seconds and microseconds are then normalized so that the
    representation is unique, with
-        0 <= microseconds < 1000000
+\begin{itemize}
-        0 <= seconds < 3600*24 (the number of seconds in one day)
+  \item \code{0 <= \var{microseconds} < 1000000}
-        -999999999 <= days <= 999999999
+  \item \code{0 <= \var{seconds} < 3600*24} (the number of seconds in one day)
+  \item \code{-999999999 <= \var{days} <= 999999999}
+\end{itemize}
    If any argument is a float, and there are fractional microseconds,
    the fractional microseconds left over from all arguments are combined
@@ -174,11 +176,11 @@ between two dates or times.
 Class attributes are:
 \begin{memberdesc}{min}
-        The most negative timedelta object, \code{timedelta(-999999999)}.
+        The most negative \class{timedelta} object, \code{timedelta(-999999999)}.
 \end{memberdesc}
 \begin{memberdesc}{max}
-        The most positive timedelta object,
+        The most positive \class{timedelta} object,
        timedelta(days=999999999, hours=23, minutes=59, seconds=59,
                  microseconds=999999)
 \end{memberdesc}
@@ -189,7 +191,7 @@ Class attributes are:
 \end{memberdesc}
 Note that, because of normalization, timedelta.max > -timedelta.min.
-timedelta.max is not representable as a timedelta object.
+-timedelta.max is not representable as a \class{timedelta} object.
 Instance attributes (read-only):
@@ -238,21 +240,21 @@ Supported operations:
  \item
    +timedelta -> timedelta
-    Returns a timedelta object with the same value.
+    Returns a \class{timedelta} object with the same value.
  \item
    -timedelta -> timedelta
    -t is equivalent to timedelta(-t.days, -t.seconds, -t.microseconds),
    and to t*-1.  This is exact, but may overflow (for example,
-    -timedelta.max is not representable as a timedelta object).
+    -timedelta.max is not representable as a \class{timedelta} object).
  \item
-    abs(timedelta) -> timedelta
+    \code{abs(timedelta) -> timedelta}:
-    abs(t) is equivalent to +t when t.days >= 0, and to -t when
+    \code{abs(t)} is equivalent to +t when \code{t.days >= 0}, and to -t when
-    t.days < 0.  This is exact, and cannot overflow.
+    \code{t.days < 0}.  This is exact, and cannot overflow.
  \item
-    comparison of timedelta to timedelta; the timedelta representing
+    comparison of \class{timedelta} to timedelta; the \class{timedelta} representing
    the smaller duration is considered to be the smaller timedelta
  \item
@@ -262,7 +264,7 @@ Supported operations:
    efficient pickling
  \item
-    in Boolean contexts, a timedelta object is considred to be true
+    in Boolean contexts, a \class{timedelta} object is considered to be true
    if and only if it isn't equal to \code{timedelta(0)}
 \end{itemize}
@@ -284,9 +286,9 @@ proleptic Gregorian ordinals and many other calendar systems.
    following ranges:
 \begin{itemize}
-  \item     MINYEAR <= \var{year} <= MAXYEAR
+  \item \code{MINYEAR <= \var{year} <= MAXYEAR}
-  \item     1 <= \var{month} <= 12
+  \item \code{1 <= \var{month} <= 12}
-  \item     1 <= \var{day} <= number of days in the given month and year
+  \item \code{1 <= \var{day} <= number of days in the given month and year}
 \end{itemize}
 If an argument outside those ranges is given, \exception{ValueError}
@@ -312,7 +314,7 @@ Other constructors, all class methods:
 \begin{methoddesc}{fromordinal}{ordinal}
    Return the date corresponding to the proleptic Gregorian ordinal,
    where January 1 of year 1 has ordinal 1.  \exception{ValueError}
-    is raised unless 1 <= \var{ordinal} <= \code{date.max.toordinal()}.  For any
+    is raised unless \code{1 <= \var{ordinal} <= date.max.toordinal()}.  For any
    date \var{d}, \code{date.fromordinal(\var{d}.toordinal()) == \var{d}}.
 \end{methoddesc}
@@ -484,13 +486,13 @@ The year, month and day arguments are required.  Arguments may be ints
 or longs, in the following ranges:
 \begin{itemize}
-  \item        \member{MINYEAR} <= \var{year} <= \member{MAXYEAR}
+  \item \code{\member{MINYEAR} <= \var{year} <= \member{MAXYEAR}}
-  \item        1 <= \var{month} <= 12
+  \item \code{1 <= \var{month} <= 12}
-  \item        1 <= \var{day} <= number of days in the given month and year
+  \item \code{1 <= \var{day} <= number of days in the given month and year}
-  \item        0 <= \var{hour} < 24
+  \item \code{0 <= \var{hour} < 24}
-  \item        0 <= \var{minute} < 60
+  \item \code{0 <= \var{minute} < 60}
-  \item        0 <= \var{second} < 60
+  \item \code{0 <= \var{second} < 60}
-  \item        0 <= \var{microsecond} < 1000000
+  \item \code{0 <= \var{microsecond} < 1000000}
 \end{itemize}
 If an argument outside those ranges is given,
@@ -560,28 +562,51 @@ Other constructors, all class methods:
 Class attributes:
-    .min
+\begin{memberdesc}{min}
-        The earliest representable datetime,
+        The earliest representable \class{datetime},
-        datetime(MINYEAR, 1, 1).
+        \code{datetime(MINYEAR, 1, 1)}.
+\end{memberdesc}
-    .max
+\begin{memberdesc}{max}
-        The latest representable datetime,
+        The latest representable \class{datetime},
-        datetime(MAXYEAR, 12, 31, 23, 59, 59, 999999).
+        \code{datetime(MAXYEAR, 12, 31, 23, 59, 59, 999999)}.
+\end{memberdesc}
-    .resolution
+\begin{memberdesc}{resolution}
-        The smallest possible difference between non-equal datetime
+        The smallest possible difference between non-equal \class{datetime}
-        objects, timedelta(microseconds=1).
+        objects, \code{timedelta(microseconds=1)}.
+\end{memberdesc}
 Instance attributes (read-only):
-    .year           between \constant{MINYEAR} and \constant{MAXYEAR} inclusive
+\begin{memberdesc}{year}
-    .month          between 1 and 12 inclusive
+Between \constant{MINYEAR} and \constant{MAXYEAR} inclusive
-    .day            between 1 and the number of days in the given month
+\end{memberdesc}
-                    of the given year
-    .hour           in range(24)
+\begin{memberdesc}{month}
-    .minute         in range(60)
+Between 1 and 12 inclusive
-    .second         in range(60)
+\end{memberdesc}
-    .microsecond    in range(1000000)
+\begin{memberdesc}{day}
+Between 1 and the number of days in the given month
+                    of the given year.
+\end{memberdesc}
+\begin{memberdesc}{hour}
+In \code{range(24)}.
+\end{memberdesc}
+\begin{memberdesc}{minute}
+In \code{range(60)}.
+\end{memberdesc}
+\begin{memberdesc}{second}
+In \code{range(60)}.
+\end{memberdesc}
+\begin{memberdesc}{microsecond}
+In \code{range(1000000)}.
+\end{memberdesc}
 Supported operations:
@@ -625,22 +650,26 @@ Supported operations:
 Instance methods:
-  - date()
+\begin{methoddesc}{date}{}
    Return \class{date} object with same year, month and day.
+\end{methoddesc}
-  - time()
+\begin{methoddesc}{time}{}
    Return time object with same hour, minute, second and microsecond.
+\end{methoddesc}
-  - replace(year=, month=, day=, hour=, minute=, second=, microsecond=)
+\begin{methoddesc}{replace}{year=, month=, day=, hour=, minute=, second=, microsecond=}
    Return a datetime with the same value, except for those fields given
    new values by whichever keyword arguments are specified.
+\end{methoddesc}
-  - astimezone(tz)
+\begin{methoddesc}{astimezone}{tz}
    Return a \class{datetimetz} with the same date and time fields, and
    with \member{tzinfo} member \var{tz}.  \var{tz} must be \code{None},
    or an instance of a \class{tzinfo} subclass.
+\end{methoddesc}
-  - timetuple()
+\begin{methoddesc}{timetuple}{}
    Return a 9-element tuple of the form returned by
    \function{time.localtime()}.
    The DST flag is -1.   \code{d.timetuple()} is equivalent to
@@ -649,26 +678,31 @@ Instance methods:
         d.weekday(),  \# 0 is Monday
         d.toordinal() - date(d.year, 1, 1).toordinal() + 1, \# day of year
         -1)
+\end{methoddesc}
-  - toordinal()
+\begin{methoddesc}{toordinal}{}
    Return the proleptic Gregorian ordinal of the date.  The same as
    \method{date.toordinal()}.
+\end{methoddesc}
-  - weekday()
+\begin{methoddesc}{weekday}{}
    Return the day of the week as an integer, where Monday is 0 and
    Sunday is 6.  The same as \method{date.weekday()}.
    See also \method{isoweekday()}.
+\end{methoddesc}
-  - isoweekday()
+\begin{methoddesc}{isoweekday}{}
    Return the day of the week as an integer, where Monday is 1 and
    Sunday is 7.  The same as \method{date.isoweekday()}.
    See also \method{weekday()}, \method{isocalendar()}.
+\end{methoddesc}
-  - isocalendar()
+\begin{methoddesc}{isocalendar}{}
    Return a 3-tuple, (ISO year, ISO week number, ISO weekday).  The
    same as \method{date.isocalendar()}.
+\end{methoddesc}
-  - isoformat(sep='T')
+\begin{methoddesc}{isoformat}{sep='T'}
    Return a string representing the date and time in ISO 8601 format,
        YYYY-MM-DDTHH:MM:SS.mmmmmm
    or, if self.microsecond is 0,
@@ -678,12 +712,14 @@ Instance methods:
    of the result.  For example,
        datetime(2002, 12, 4, 1, 2, 3, 4).isoformat(' ') ==
        '2002-12-04 01:02:03.000004'
+\end{methoddesc}
-  - __str__()
+\begin{methoddesc}{__str__}{}
    For a \class{datetime} instance \var{d}, \code{str(\var{d})} is
    equivalent to \code{\var{d}.isoformat(' ')}.
+\end{methoddesc}
-  - ctime()
+\begin{methoddesc}{ctime}{}
    Return a string representing the date, for example
    datetime(2002, 12, 4, 20, 30, 40).ctime() == 'Wed Dec  4 20:30:40 2002'.
    \code{d.ctime()} is equivalent to
@@ -692,11 +728,13 @@ Instance methods:
    \function{time.ctime()} invokes, but which
    \method{datetime.ctime()} does not invoke) conforms to the C
    standard.
+\end{methoddesc}
-  - strftime(format)
+\begin{methoddesc}{strftime}{format}
    Return a string representing the date and time, controlled by an
    explicit format string.  See the section on \method{strftime()}
    behavior.
+\end{methoddesc}
 \subsection{\class{time} \label{datetime-time}}
@@ -721,23 +759,34 @@ Constructor:
 Class attributes:
-    .min
+\begin{memberdesc}{min}
-        The earliest representable time, time(0, 0, 0, 0).
+        The earliest representable \class{time}, \code{time(0, 0, 0, 0)}.
+\end{memberdesc}
-    .max
+\begin{memberdesc}{max}
-        The latest representable time, time(23, 59, 59, 999999).
+        The latest representable \class{time}, \code{time(23, 59, 59, 999999)}.
+\end{memberdesc}
-    .resolution
+\begin{memberdesc}{resolution}
-        The smallest possible difference between non-equal time
+        The smallest possible difference between non-equal \class{time}
-        objects, timedelta(microseconds=1), although note that
+        objects, \code{timedelta(microseconds=1)}, although note that
-        arithmetic on time objects is not supported.
+        arithmetic on \class{time} objects is not supported.
+\end{memberdesc}
 Instance attributes (read-only):
-    .hour           in range(24)
+\begin{memberdesc}{hour}
-    .minute         in range(60)
+In \code{range(24)}.
-    .second         in range(60)
+\end{memberdesc}
-    .microsecond    in range(1000000)
+\begin{memberdesc}{minute}     
+In \code{range(60)}.
+\end{memberdesc}
+\begin{memberdesc}{second}         
+In \code{range(60)}.
+\end{memberdesc}
+\begin{memberdesc}{microsecond}    
+In \code{range(1000000)}.
+\end{memberdesc}
 Supported operations:
@@ -759,23 +808,27 @@ Supported operations:
 Instance methods:
-  - replace(hour=, minute=, second=, microsecond=)
+\begin{methoddesc}{replace}{hour=, minute=, second=, microsecond=}
    Return a time with the same value, except for those fields given
    new values by whichever keyword arguments are specified.
+\end{methoddesc}
-  - isoformat()
+\begin{methoddesc}{isoformat}{}
    Return a string representing the time in ISO 8601 format,
        HH:MM:SS.mmmmmm
    or, if self.microsecond is 0
        HH:MM:SS
+\end{methoddesc}
-  - __str__()
+\begin{methoddesc}{__str__}{}
    For a time \var{t}, \code{str(\var{t})} is equivalent to
    \code{\var{t}.isoformat()}.
+\end{methoddesc}
-  - strftime(format)
+\begin{methoddesc}{strftime}{format}
    Return a string representing the time, controlled by an explicit
    format string.  See the section on \method{strftime()} behavior.
+\end{methoddesc}
 \subsection{\class{tzinfo} \label{datetime-tzinfo}}
@@ -808,7 +861,7 @@ or \class{timetz} object, passing itself as the argument.  A
 argument of \code{None} or of type \class{timetz} or
 \class{datetimetz}.
-  - utcoffset(dt)
+\begin{methoddesc}{utcoffset}{dt}
    Return offset of local time from UTC, in minutes east of UTC.  If
    local time is west of UTC, this should be negative.  Note that this
    is intended to be the total offset from UTC; for example, if a
@@ -819,8 +872,9 @@ argument of \code{None} or of type \class{timetz} or
    the magnitude of the offset must be less than one day), or a
    \class{timedelta} object representing a whole number of minutes
    in the same range.
+\end{methoddesc}
-  - tzname(dt)
+\begin{methoddesc}{tzname}{dt}
    Return the timezone name corresponding to the \class{datetime} represented
    by dt, as a string.  Nothing about string names is defined by the
    \module{datetime} module, and there's no requirement that it mean anything
@@ -830,8 +884,9 @@ argument of \code{None} or of type \class{timetz} or
    rather than a fixed string primarily because some \class{tzinfo} objects
    will wish to return different names depending on the specific value
    of dt passed, especially if the \class{tzinfo} class is accounting for DST.
+\end{methoddesc}
-  - dst(dt)
+\begin{methoddesc}{dst}{dt}
    Return the DST offset, in minutes east of UTC, or \code{None} if
    DST information isn't known.  Return 0 if DST is not in effect.
    If DST is in effect, return the offset as an integer or
@@ -843,6 +898,7 @@ argument of \code{None} or of type \class{timetz} or
    example, \method{datetimetz.timetuple()} calls its \member{tzinfo}
    member's \method{dst()} method to determine how the
    \member{tm_isdst} flag should be set.
+\end{methoddesc}
 Example \class{tzinfo} classes:
@@ -856,32 +912,38 @@ particular day, and subject to adjustment via a \class{tzinfo} object.
 Constructor:
-    time(hour=0, minute=0, second=0, microsecond=0, tzinfo=None)
+\begin{funcdesc}{time}{hour=0, minute=0, second=0, microsecond=0, tzinfo=None}
    All arguments are optional.  \var{tzinfo} may be \code{None}, or
    an instance of a \class{tzinfo} subclass.  The remaining arguments
    may be ints or longs, in the following ranges:
-        0 <= hour < 24
+\begin{itemize}
-        0 <= minute < 60
+  \item \code{0 <= \var{hour} < 24}
-        0 <= second < 60
+  \item \code{0 <= \var{minute} < 60}
-        0 <= microsecond < 1000000
+  \item \code{0 <= \var{second} < 60}
+  \item \code{0 <= \var{microsecond} < 1000000}.
+\end{itemize}
    If an argument outside those ranges is given,
    \exception{ValueError} is raised.
+\end{funcdesc}
 Class attributes:
-    .min
+\begin{memberdesc}{min}
-        The earliest representable time, timetz(0, 0, 0, 0).
+        The earliest representable time, \code{timetz(0, 0, 0, 0)}.
+\end{memberdesc}
-    .max
+\begin{memberdesc}{max}
-        The latest representable time, timetz(23, 59, 59, 999999).
+        The latest representable time, \code{timetz(23, 59, 59, 999999)}.
+\end{memberdesc}
-    .resolution
+\begin{memberdesc}{resolution}
-        The smallest possible difference between non-equal timetz
+        The smallest possible difference between non-equal \class{timetz}
-        objects, timedelta(microseconds=1), although note that
+        objects, \code{timedelta(microseconds=1)}, although note that
        arithmetic on \class{timetz} objects is not supported.
+\end{memberdesc}
 Instance attributes (read-only):
@@ -899,7 +961,7 @@ Supported operations:
  \item
    comparison of \class{timetz} to \class{time} or \class{timetz},
    where \var{a} is considered less than \var{b} when \var{a} precedes
-    \var{b} in time.  If one comparand is naive and the other is aware,
+    \var{b} in time.  If one comparand is {\naive} and the other is aware,
    \exception{TypeError} is raised.  If both comparands are aware, and
    have the same \member{tzinfo} member, the common \member{tzinfo}
    member is ignored and the base times are compared.  If both
@@ -922,44 +984,51 @@ Supported operations:
 Instance methods:
-  - replace(hour=, minute=, second=, microsecond=, tzinfo=)
+\begin{methoddesc}{replace}(hour=, minute=, second=, microsecond=, tzinfo=)
-    Return a timetz with the same value, except for those fields given
+    Return a \class{timetz} with the same value, except for those fields given
    new values by whichever keyword arguments are specified.  Note that
-    \code{tzinfo=None} can be specified to create a naive timetz from an
+    \code{tzinfo=None} can be specified to create a {\naive} \class{timetz} from an
-    aware timetz.
+    aware \class{timetz}.
+\end{methoddesc}
-  - isoformat()
+\begin{methoddesc}{isoformat}{}
    Return a string representing the time in ISO 8601 format,
        HH:MM:SS.mmmmmm
-    or, if self.microsecond is 0
+    or, if self.microsecond is 0,
        HH:MM:SS
    If \method{utcoffset()} does not return \code{None}, a 6-character
    string is appended, giving the UTC offset in (signed) hours and
    minutes:
        HH:MM:SS.mmmmmm+HH:MM
-    or, if self.microsecond is 0
+    or, if self.microsecond is 0,
        HH:MM:SS+HH:MM
+\end{methoddesc}
-  - __str__()
+\begin{methoddesc}{__str__}{}
    For a \class{timetz} \var{t}, \code{str(\var{t})} is equivalent to
    \code{\var{t}.isoformat()}.
+\end{methoddesc}
-  - strftime(format)
+\begin{methoddesc}{strftime}{format}
    Return a string representing the time, controlled by an explicit
    format string.  See the section on \method{strftime()} behavior.
+\end{methoddesc}
-  - utcoffset()
+\begin{methoddesc}{utcoffset}{}
    If \member{tzinfo} is \code{None}, returns \code{None}, else
    \code{tzinfo.utcoffset(self)} converted to a \class{timedelta}
    object.
+\end{methoddesc}
-  - tzname():
+\begin{methoddesc}{tzname}{}
    If \member{tzinfo} is \code{None}, returns \code{None}, else
    \code{tzinfo.tzname(self)}.
+\end{methoddesc}
-  - dst()
+\begin{methoddesc}{dst}{}
    If \member{tzinfo} is \code{None}, returns \code{None}, else
    \code{tzinfo.dst(self)} converted to a \class{timedelta} object.
+\end{methoddesc}
@@ -975,74 +1044,99 @@ from a \class{date} object and a \class{timetz} object.
 Constructor:
-    datetimetz(year, month, day,
+\begin{funcdesc}{datetimetz}{year, month, day,
-               hour=0, minute=0, second=0, microsecond=0, tzinfo=None)
+               hour=0, minute=0, second=0, microsecond=0, tzinfo=None}
    The year, month and day arguments are required.  \var{tzinfo} may
    be \code{None}, or an instance of a \class{tzinfo} subclass.  The
    remaining arguments may be ints or longs, in the following ranges:
-        MINYEAR <= year <= MAXYEAR
+\begin{itemize}
-        1 <= month <= 12
+  \item \code{MINYEAR <= \var{year} <= MAXYEAR}
-        1 <= day <= number of days in the given month and year
+  \item \code{1 <= \var{month} <= 12}
-        0 <= hour < 24
+  \item \code{1 <= \var{day} <= number of days in the given month and year}
-        0 <= minute < 60
+  \item \code{0 <= \var{hour} < 24}
-        0 <= second < 60
+  \item \code{0 <= \var{minute} < 60}
-        0 <= microsecond < 1000000
+  \item \code{0 <= \var{second} < 60}
+  \item \code{0 <= \var{microsecond} < 1000000}
+\end{itemize}
    If an argument outside those ranges is given,
    \exception{ValueError} is raised.
+\end{funcdesc}
 Other constructors (class methods):
-  - today()
+\begin{funcdesc}{today}{}
-    utcnow()
+  \methodline{utcnow}{}
-    utcfromtimestamp(timestamp)
+  \methodline{utcfromtimestamp}{timestamp}
-    fromordinal(ordinal)
+  \methodline{fromordinal}{ordinal}
    These are the same as the \class{datetime} class methods of the
    same names, except that they construct a \class{datetimetz}
    object, with tzinfo \code{None}.
+\end{funcdesc}
-  - now([tzinfo=None])
+\begin{funcdesc}{now}{\optional{tzinfo=None}}
-    fromtimestamp(timestamp[, tzinfo=None])
+  \methodline{fromtimestamp}{timestamp\optional{, tzinfo=None}}
    These are the same as the \class{datetime} class methods of the same names,
    except that they accept an additional, optional tzinfo argument, and
    construct a \class{datetimetz} object with that \class{tzinfo} object attached.
+\end{funcdesc}
-  - combine(date, time)
+\begin{funcdesc}{combine}{date, time}
    This is the same as \method{datetime.combine()}, except that it constructs
    a \class{datetimetz} object, and, if the time object is of type timetz,
    the \class{datetimetz} object has the same \class{tzinfo} object as the time object.
+\end{funcdesc}
 Class attributes:
-    .min
+\begin{memberdesc}{min}
-        The earliest representable datetimetz,
+        The earliest representable \class{datetimetz},
-        datetimetz(MINYEAR, 1, 1).
+        \code{datetimetz(MINYEAR, 1, 1)}.
+\end{memberdesc}
-    .max
+\begin{memberdesc}{max}
-        The latest representable datetime,
+        The latest representable \class{datetime},
-        datetimetz(MAXYEAR, 12, 31, 23, 59, 59, 999999).
+        \code{datetimetz(MAXYEAR, 12, 31, 23, 59, 59, 999999)}.
+\end{memberdesc}
-    .resolution
+\begin{memberdesc}{resolution}
-        The smallest possible difference between non-equal datetimetz
+        The smallest possible difference between non-equal \class{datetimetz}
-        objects, timedelta(microseconds=1).
+        objects, \code{timedelta(microseconds=1)}.
+\end{memberdesc}
-Instance attributes (read-only):
+Instance attributes, all read-only:
-    .year           between MINYEAR and MAXYEAR inclusive
+\begin{memberdesc}{year}
-    .month          between 1 and 12 inclusive
+Between MINYEAR and MAXYEAR inclusive
-    .day            between 1 and the number of days in the given month
+\end{memberdesc}
+\begin{memberdesc}{month}
+Between 1 and 12 inclusive
+\end{memberdesc}
+\begin{memberdesc}{day}
+Between 1 and the number of days in the given month
                    of the given year
-    .hour           in range(24)
+\end{memberdesc}
-    .minute         in range(60)
+\begin{memberdesc}{hour}
-    .second         in range(60)
+In \code{range(24)}.
-    .microsecond    in range(1000000)
+\end{memberdesc}
-    .tzinfo         the object passed as the \var{tzinfo} argument to
+\begin{memberdesc}{minute}
+In \code{range(60)}.
+\end{memberdesc}
+\begin{memberdesc}{second}
+In \code{range(60)}.
+\end{memberdesc}
+\begin{memberdesc}{microsecond}
+In \code{range(1000000)}.
+\end{memberdesc}
+\begin{memberdesc}{tzinfo}
+The object passed as the \var{tzinfo} argument to
                    the \class{datetimetz} constructor, or \code{None}
                    if none was passed.
+\end{memberdesc}
 Supported operations:
@@ -1105,30 +1199,33 @@ Supported operations:
 Instance methods:
-  - date()
+\begin{methoddesc}{date}{}
-    time()
+  \methodline{time}{}
-    toordinal()
+  \methodline{toordinal}{}
-    weekday()
+  \methodline{weekday}{}
-    isoweekday()
+  \methodline{isoweekday}{}
-    isocalendar()
+  \methodline{isocalendar}{}
-    ctime()
+  \methodline{ctime}{}
-    __str__()
+  \methodline{__str__}{}
-    strftime(format)
+  \methodline{strftime}{format}
-    These are the same as the \class{datetime} methods of the same names.
+These are the same as the \class{datetime} methods of the same names.
+\end{methoddesc}
-  - timetz()
+\begin{methoddesc}{timetz}{}
    Return \class{timetz} object with same hour, minute, second, microsecond,
    and tzinfo.
+\end{methoddesc}
-  - replace(year=, month=, day=, hour=, minute=, second=, microsecond=,
+\begin{methoddesc}{replace}{year=, month=, day=, hour=, minute=, second=, microsecond=,
-            tzinfo=)
+            tzinfo=}
    Return a datetimetz with the same value, except for those fields given
    new values by whichever keyword arguments are specified.  Note that
    \code{tzinfo=None} can be specified to create a naive datetimetz from
    an aware datetimetz.
+\end{methoddesc}
-  - astimezone(tz)
+\begin{methoddesc}{astimezone}{tz}
    Return a \class{datetimetz} with new tzinfo member \var{tz}.  \var{tz}
    must be \code{None}, or an instance of a \class{tzinfo} subclass.  If
    \var{tz} is \code{None}, self is naive, or
@@ -1143,32 +1240,37 @@ Instance methods:
    \begin{verbatim}
        (self - (self.utcoffset() - tz.utcoffset(self)).replace(tzinfo=tz)
    \end{verbatim}
-    where the result of \code{tz.uctcoffset(self)} is converted to a
+    where the result of \code{tz.utcoffset(self)} is converted to a
    \class{timedelta} if it's an integer.
+\end{methoddesc}
-  - utcoffset()
+\begin{methoddesc}{utcoffset}{}
    If \member{tzinfo} is \code{None}, returns \code{None}, else
    \code{tzinfo.utcoffset(self)} converted to a \class{timedelta}
    object.
+\end{methoddesc}
-  - tzname()
+\begin{methoddesc}{tzname}{}
    If \member{tzinfo} is \code{None}, returns \code{None}, else
-    \code{tzinfo.tzname(self)}.
+    returns \code{tzinfo.tzname(self)}.
+\end{methoddesc}
-  - dst()
+\begin{methoddesc}{dst}{}
    If \member{tzinfo} is \code{None}, returns \code{None}, else
    \code{tzinfo.dst(self)} converted to a \class{timedelta}
    object.
+\end{methoddesc}
-  - timetuple()
+\begin{methoddesc}{timetuple}{}
    Like \function{datetime.timetuple()}, but sets the
    \member{tm_isdst} flag according to the \method{dst()} method:  if
    \method{dst()} returns \code{None}, \member{tm_isdst} is set to
    \code{-1}; else if \method{dst()} returns a non-zero value,
    \member{tm_isdst} is set to \code{1}; else \code{tm_isdst} is set
    to \code{0}.
+\end{methoddesc}
-  - utctimetuple()
+\begin{methoddesc}{utctimetuple}{}
    If \class{datetimetz} instance \var{d} is \naive, this is the same as
    \code{\var{d}.timetuple()} except that \member{tm_isdst} is forced to 0
    regardless of what \code{d.dst()} returns.  DST is never in effect
@@ -1181,8 +1283,9 @@ Instance methods:
    \constant{MINYEAR}-1 or \constant{MAXYEAR}+1, if \var{d}.year was
    \code{MINYEAR} or \code{MAXYEAR} and UTC adjustment spills over a
    year boundary.
+\end{methoddesc}
-  - isoformat(sep='T')
+\begin{methoddesc}{isoformat}{sep='T'}
    Return a string representing the date and time in ISO 8601 format,
        YYYY-MM-DDTHH:MM:SS.mmmmmm
    or, if \member{microsecond} is 0,
@@ -1207,6 +1310,7 @@ Instance methods:
 >>> datetimetz(2002, 12, 25, tzinfo=TZ()).isoformat(' ')
 '2002-12-25 00:00:00-06:39'
 \end{verbatim}
+\end{methoddesc}
 \code{str(\var{d})} is equivalent to \code{\var{d}.isoformat(' ')}.
@@ -1247,7 +1351,7 @@ For an aware object:
  \item[\code{\%Z}]
    If \method{tzname()} returns \code{None}, \code{\%Z} is replaced
-    by an empty string.  Else \code{\%Z} is replaced by the returned
+    by an empty string.  Otherwise \code{\%Z} is replaced by the returned
    value, which must be a string.
 \end{itemize}
@@ -1264,6 +1368,8 @@ varies across platforms.  Regardless of platform, years before 1900
 cannot be used.
+\begin{comment}
 \subsection{C API}
 Struct typedefs:
@@ -1320,3 +1426,5 @@ return ints:
        PyDateTime_TIME_GET_MINUTE(o)
        PyDateTime_TIME_GET_SECOND(o)
        PyDateTime_TIME_GET_MICROSECOND(o)
+\end{comment}