Some operations are supported by several object types; in particular,
all objects can be compared, tested for truth value, and converted to
-a string (with the \code{`{\rm \ldots}`} notation). The latter conversion is
-implicitly used when an object is written by the \code{print} statement.
-\stindex{print}
+a string (with the \code{`\textrm{\ldots}`} notation). The latter
+conversion is implicitly used when an object is written by the
+\keyword{print}\stindex{print} statement.
\subsection{Truth Value Testing \label{truth}}
-Any object can be tested for truth value, for use in an \code{if} or
-\code{while} condition or as operand of the Boolean operations below.
+Any object can be tested for truth value, for use in an \keyword{if} or
+\keyword{while} condition or as operand of the Boolean operations below.
The following values are considered false:
\stindex{if}
\stindex{while}
There are four numeric types: \dfn{plain integers}, \dfn{long integers},
\dfn{floating point numbers}, and \dfn{complex numbers}.
Plain integers (also just called \dfn{integers})
-are implemented using \code{long} in \C{}, which gives them at least 32
+are implemented using \ctype{long} in \C{}, which gives them at least 32
bits of precision. Long integers have unlimited precision. Floating
-point numbers are implemented using \code{double} in \C{}. All bets on
+point numbers are implemented using \ctype{double} in \C{}. All bets on
their precision are off unless you happen to know the machine you are
working with.
\indexii{numeric}{types}
\indexii{C@\C{}}{language}
Complex numbers have a real and imaginary part, which are both
-implemented using \code{double} in \C{}. To extract these parts from
+implemented using \ctype{double} in \C{}. To extract these parts from
a complex number \var{z}, use \code{\var{z}.real} and \code{\var{z}.imag}.
Numbers are created by numeric literals or as the result of built-in
smaller than complex.
Comparisons between numbers of mixed type use the same rule.%
\footnote{As a consequence, the list \code{[1, 2]} is considered equal
- to \code{[1.0, 2.0]}, and similar for tuples.}
-The functions \code{int()}, \code{long()}, \code{float()},
-and \code{complex()} can be used
+ to \code{[1.0, 2.0]}, and similar for tuples.}
+The functions \function{int()}, \function{long()}, \function{float()},
+and \function{complex()} can be used
to coerce numbers to a specific type.
\index{arithmetic}
\bifuncindex{int}
\item[(2)]
Conversion from floating point to (long or plain) integer may round or
-truncate as in \C{}; see functions \code{floor()} and \code{ceil()} in
-module \code{math} for well-defined conversions.
-\bifuncindex{floor}
-\bifuncindex{ceil}
+truncate as in \C{}; see functions \function{floor()} and \function{ceil()} in
+module \module{math} for well-defined conversions.
+\withsubitem{(in module math)}{%
+ \ttindex{floor()}%
+ \ttindex{ceil()}}
\indexii{numeric}{conversions}
\refbimodindex{math}
\indexii{C@\C{}}{language}
equal to \var{x}, else \code{1}}{}
\hline
\lineiii{\var{s} + \var{t}}{the concatenation of \var{s} and \var{t}}{}
- \lineiii{\var{s} * \var{n}{\rm ,} \var{n} * \var{s}}{\var{n} copies of \var{s} concatenated}{(3)}
+ \lineiii{\var{s} * \var{n}\textrm{,} \var{n} * \var{s}}{\var{n} copies of \var{s} concatenated}{(3)}
\hline
\lineiii{\var{s}[\var{i}]}{\var{i}'th item of \var{s}, origin 0}{(1)}
\lineiii{\var{s}[\var{i}:\var{j}]}{slice of \var{s} from \var{i} to \var{j}}{(1), (2)}
\begin{description}
\item[(1)] Raises an exception when \var{x} is not found in \var{s}.
-\item[(2)] The \code{sort()} method takes an optional argument
+\item[(2)] The \method{sort()} method takes an optional argument
specifying a comparison function of two arguments (list items) which
should return \code{-1}, \code{0} or \code{1} depending on whether the
first argument is considered smaller than, equal to, or larger than the
second argument. Note that this slows the sorting process down
considerably; e.g. to sort a list in reverse order it is much faster
- to use calls to \code{sort()} and \code{reverse()} than to use
- \code{sort()} with a comparison function that reverses the ordering of
- the elements.
+ to use calls to the methods \method{sort()} and \method{reverse()}
+ than to use the built-in function \function{sort()} with a
+ comparison function that reverses the ordering of the elements.
-\item[(3)] The \code{sort()} and \code{reverse()} methods modify the
+\item[(3)] The \method{sort()} and \method{reverse()} methods modify the
list in place for economy of space when sorting or reversing a large
list. They don't return the sorted or reversed list to remind you of
this side effect.
The only special operation on a module is attribute access:
\code{\var{m}.\var{name}}, where \var{m} is a module and \var{name}
accesses a name defined in \var{m}'s symbol table. Module attributes
-can be assigned to. (Note that the \code{import} statement is not,
+can be assigned to. (Note that the \keyword{import} statement is not,
strictly speaking, an operation on a module object; \code{import
\var{foo}} does not require a module object named \var{foo} to exist,
rather it requires an (external) \emph{definition} for a module named
\var{foo} somewhere.)
-A special member of every module is \code{__dict__}.
+A special member of every module is \member{__dict__}.
This is the dictionary containing the module's symbol table.
Modifying this dictionary will actually change the module's symbol
-table, but direct assignment to the \code{__dict__} attribute is not
+table, but direct assignment to the \member{__dict__} attribute is not
possible (i.e., you can write \code{\var{m}.__dict__['a'] = 1}, which
defines \code{\var{m}.a} to be \code{1}, but you can't write
\code{\var{m}.__dict__ = \{\}}.
\obindex{method}
Methods are functions that are called using the attribute notation.
-There are two flavors: built-in methods (such as \code{append()} on
+There are two flavors: built-in methods (such as \method{append()} on
lists) and class instance methods. Built-in methods are described
with the types that support them.
instance methods: \code{\var{m}.im_self} is the object on which the
method operates, and \code{\var{m}.im_func} is the function
implementing the method. Calling \code{\var{m}(\var{arg-1},
-\var{arg-2}, {\rm \ldots}, \var{arg-n})} is completely equivalent to
+\var{arg-2}, \textrm{\ldots}, \var{arg-n})} is completely equivalent to
calling \code{\var{m}.im_func(\var{m}.im_self, \var{arg-1},
-\var{arg-2}, {\rm \ldots}, \var{arg-n})}.
+\var{arg-2}, \textrm{\ldots}, \var{arg-n})}.
See the \emph{Python Reference Manual} for more information.
``pseudo-compiled'' executable Python code such as a function body.
They differ from function objects because they don't contain a
reference to their global execution environment. Code objects are
-returned by the built-in \code{compile()} function and can be
-extracted from function objects through their \code{func_code}
+returned by the built-in \function{compile()} function and can be
+extracted from function objects through their \member{func_code}
attribute.
\bifuncindex{compile}
\withsubitem{(function object attribute)}{\ttindex{func_code}}
A code object can be executed or evaluated by passing it (instead of a
-source string) to the \code{exec} statement or the built-in
-\code{eval()} function.
+source string) to the \keyword{exec} statement or the built-in
+\function{eval()} function.
\stindex{exec}
\bifuncindex{eval}
\subsubsection{Type Objects \label{bltin-type-objects}}
Type objects represent the various object types. An object's type is
-accessed by the built-in function \code{type()}. There are no special
-operations on types. The standard module \code{types} defines names
+accessed by the built-in function \function{type()}. There are no special
+operations on types. The standard module \module{types} defines names
for all standard built-in types.
\bifuncindex{type}
\refstmodindex{types}
\refbimodindex{socket}
When a file operation fails for an I/O-related reason, the exception
-\code{IOError} is raised. This includes situations where the
-operation is not defined for some reason, like \code{seek()} on a tty
+\exception{IOError} is raised. This includes situations where the
+operation is not defined for some reason, like \method{seek()} on a tty
device or writing a file opened for reading.
Files have the following methods:
\end{methoddesc}
\begin{methoddesc}[file]{flush}{}
- Flush the internal buffer, like \code{stdio}'s \code{fflush()}.
+ Flush the internal buffer, like \code{stdio}'s \cfunction{fflush()}.
\end{methoddesc}
\begin{methoddesc}[file]{isatty}{}
Return the integer ``file descriptor'' that is used by the underlying
implementation to request I/O operations from the operating system.
This can be useful for other, lower level interfaces that use file
-descriptors, e.g. module \code{fcntl} or \code{os.read()} and friends.
+descriptors, e.g. module \module{fcntl} or \function{os.read()} and friends.
\refbimodindex{fcntl}
\end{methoddesc}
projects / python / commitdiff