Mirror
/
cpython
mirror of https://github.com/python/cpython
4
1
Fork 0
Code Issues Releases Wiki Activity

Massive change to just about every construct that impacts the index. 

Blame it on Just.  ;-)
This commit is contained in:
Fred Drake 1998-11-25 17:58:50 +00:00
parent ea81edf059
commit 1e42d8aaab
1 changed files with 207 additions and 222 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

429
Doc/ref/ref3.tex
View File

@ -110,8 +110,9 @@ object, if it has any.
\index{attribute}
\indexii{special}{attribute}
\indexiii{generic}{special}{attribute}
\ttindex{__methods__}
\ttindex{__members__}
\withsubitem{(built-in object attribute)}{%
\ttindex{__methods__}
\ttindex{__members__}}
\begin{description}
@ -387,12 +388,13 @@ defines the global namespace of the module in which the function was
defined. Additional information about a function's definition can be
retrieved from its code object; see the description of internal types
below.
\ttindex{func_doc}
\ttindex{__doc__}
\ttindex{__name__}
\ttindex{func_defaults}
\ttindex{func_code}
\ttindex{func_globals}
\withsubitem{(function attribute)}{%
\ttindex{func_doc}%
\ttindex{__doc__}%
\ttindex{__name__}%
\ttindex{func_defaults}%
\ttindex{func_code}%
\ttindex{func_globals}}
\indexii{global}{namespace}
\item[User-defined methods]
@ -409,6 +411,9 @@ base class of the class of which \member{im_self} is an instance);
\member{__doc__} is the method's documentation (same as
\code{im_func.__doc__}); \member{__name__} is the method name (same as
\code{im_func.__name__}).
\withsubitem{(method attribute)}{%
\ttindex{im_func}%
\ttindex{im_self}}
User-defined method objects are created in two ways: when getting an
attribute of a class that is a user-defined function object, or when
@ -425,6 +430,10 @@ function \method{f()}, \code{C.f} does not yield the function object
instance, \code{x.f} yields a bound method object \code{m} where
\code{m.im_class} is \code{C}, \code{m.im_func} is \method{f()}, and
\code{m.im_self} is \code{x}.
\withsubitem{(method attribute)}{%
\ttindex{im_class}%
\ttindex{im_func}%
\ttindex{im_self}}
When an unbound user-defined method object is called, the underlying
function (\member{im_func}) is called, with the restriction that the
@ -446,9 +455,6 @@ Also notice that this transformation only happens for user-defined
functions; other callable objects (and all non-callable objects) are
retrieved without transformation.
\ttindex{im_func}
\ttindex{im_self}
\item[Built-in functions]
A built-in function object is a wrapper around a \C{} function. Examples
of built-in functions are \function{len()} and \function{math.sin()}
@ -482,7 +488,7 @@ returned. This implies a call to the class's \method{__init__()} method
if it has one. Any arguments are passed on to the \method{__init__()}
method. If there is no \method{__init__()} method, the class must be called
without arguments.
\ttindex{__init__}
\withsubitem{(object method)}{\ttindex{__init__()}}
\obindex{class}
\obindex{class instance}
\obindex{instance}
@ -514,7 +520,7 @@ e.g., \samp{m.x = 1} is equivalent to \samp{m.__dict__["x"] = 1}.
Special read-only attribute: \member{__dict__} is the module's
namespace as a dictionary object.
\ttindex{__dict__}
\withsubitem{(module attribute)}{\ttindex{__dict__}}
Predefined (writable) attributes: \member{__name__}
is the module's name; \member{__doc__} is the
@ -525,9 +531,10 @@ The \member{__file__} attribute is not present for C{} modules that are
statically linked into the interpreter; for extension modules loaded
dynamically from a shared library, it is the pathname of the shared
library file.
\ttindex{__name__}
\ttindex{__doc__}
\ttindex{__file__}
\withsubitem{(module attribute)}{%
\ttindex{__name__}%
\ttindex{__doc__}%
\ttindex{__file__}}
\indexii{module}{namespace}
\item[Classes]
@ -569,11 +576,12 @@ Special attributes: \member{__name__} is the class name;
containing the base classes, in the order of their occurrence in the
base class list; \member{__doc__} is the class's documentation string,
or None if undefined.
\ttindex{__name__}
\ttindex{__module__}
\ttindex{__dict__}
\ttindex{__bases__}
\ttindex{__doc__}
\withsubitem{(class attribute)}{%
\ttindex{__name__}%
\ttindex{__module__}%
\ttindex{__dict__}%
\ttindex{__bases__}%
\ttindex{__doc__}}
\item[Class instances]
A class instance is created by calling a class object (see above).
@ -609,8 +617,9 @@ section \ref{specialnames}, ``Special method names.''
Special attributes: \member{__dict__} is the attribute
dictionary; \member{__class__} is the instance's class.
\ttindex{__dict__}
\ttindex{__class__}
\withsubitem{(instance attribute)}{%
\ttindex{__dict__}%
\ttindex{__class__}}
\item[Files]
A file object represents an open file. File objects are created by the
@ -626,11 +635,12 @@ Library Reference} for complete documentation of file objects.
\indexii{C}{language}
\index{stdio}
\bifuncindex{open}
\bifuncindex{popen}
\bifuncindex{makefile}
\ttindex{stdin}
\ttindex{stdout}
\ttindex{stderr}
\withsubitem{(in module os)}{\ttindex{popen()}}
\withsubitem{(socket method)}{\ttindex{makefile()}}
\withsubitem{(in module sys)}{%
\ttindex{stdin}%
\ttindex{stdout}%
\ttindex{stderr}}
\ttindex{sys.stdin}
\ttindex{sys.stdout}
\ttindex{sys.stderr}
@ -658,26 +668,35 @@ contain no references (directly or indirectly) to mutable objects.
\index{bytecode}
\obindex{code}
Special read-only attributes: \member{co_name}\ttindex{co_name} gives
the function name; \member{co_argcount}\ttindex{co_argcount}
is the number of positional arguments (including arguments with
default values); \member{co_nlocals}\ttindex{co_nlocals} is the number
of local variables used by the function (including arguments);
\member{co_varnames}\ttindex{co_varnames} is a tuple containing the
names of the local variables (starting with the argument names);
\member{co_code}\ttindex{co_code} is a string representing the sequence
of bytecode instructions; \member{co_consts}\ttindex{co_consts} is a
tuple containing the literals used by the bytecode;
\member{co_names}\ttindex{co_names} is a tuple containing the names used
by the bytecode; \member{co_filename}\ttindex{co_filename} is the
filename from which the code was compiled;
\member{co_firstlineno}\ttindex{co_firstlineno} is the first line number
of the function; \member{co_lnotab}\ttindex{co_lnotab} is a string
encoding the mapping from byte code offsets to line numbers (for
detais see the source code of the interpreter);
\member{co_stacksize}\ttindex{co_stacksize} is the required stack size
(including local variables); \member{co_flags}\ttindex{co_flags} is an
integer encoding a number of flags for the interpreter.
Special read-only attributes: \member{co_name} gives the function
name; \member{co_argcount} is the number of positional arguments
(including arguments with default values); \member{co_nlocals} is the
number of local variables used by the function (including arguments);
\member{co_varnames} is a tuple containing the names of the local
variables (starting with the argument names); \member{co_code} is a
string representing the sequence of bytecode instructions;
\member{co_consts} is a tuple containing the literals used by the
bytecode; \member{co_names} is a tuple containing the names used by
the bytecode; \member{co_filename} is the filename from which the code
was compiled; \member{co_firstlineno} is the first line number of the
function; \member{co_lnotab} is a string encoding the mapping from
byte code offsets to line numbers (for detais see the source code of
the interpreter); \member{co_stacksize} is the required stack size
(including local variables); \member{co_flags} is an integer encoding
a number of flags for the interpreter.
\withsubitem{(code object attribute)}{%
\ttindex{co_argcount}%
\ttindex{co_code}%
\ttindex{co_consts}%
\ttindex{co_filename}%
\ttindex{co_firstlineno}%
\ttindex{co_flags}%
\ttindex{co_lnotab}%
\ttindex{co_name}%
\ttindex{co_names}%
\ttindex{co_nlocals}%
\ttindex{co_stacksize}%
\ttindex{co_varnames}}
The following flag bits are defined for \member{co_flags}: bit 2 is set
if the function uses the \samp{*arguments} syntax to accept an
@ -687,6 +706,7 @@ arguments; other bits are used internally or reserved for future use.
If a code object represents a function, the first item in
\member{co_consts} is the documentation string of the
function, or \code{None} if undefined.
\index{documentation string}
\item[Frame objects]
Frame objects represent execution frames. They may occur in traceback
@ -704,24 +724,26 @@ executing in restricted execution mode;
\member{f_lineno} gives the line number and \member{f_lasti} gives the
precise instruction (this is an index into the bytecode string of
the code object).
\ttindex{f_back}
\ttindex{f_code}
\ttindex{f_globals}
\ttindex{f_locals}
\ttindex{f_lineno}
\ttindex{f_lasti}
\ttindex{f_builtins}
\ttindex{f_restricted}
\withsubitem{(frame attribute)}{%
\ttindex{f_back}%
\ttindex{f_code}%
\ttindex{f_globals}%
\ttindex{f_locals}%
\ttindex{f_lineno}%
\ttindex{f_lasti}%
\ttindex{f_builtins}%
\ttindex{f_restricted}}
Special writable attributes: \member{f_trace}, if not \code{None}, is a
function called at the start of each source code line (this is used by
the debugger); \member{f_exc_type}, \member{f_exc_value},
\member{f_exc_traceback} represent the most recent exception caught in
this frame.
\ttindex{f_trace}
\ttindex{f_exc_type}
\ttindex{f_exc_value}
\ttindex{f_exc_traceback}
\withsubitem{(frame attribute)}{%
\ttindex{f_trace}%
\ttindex{f_exc_type}%
\ttindex{f_exc_value}%
\ttindex{f_exc_traceback}}
\item[Traceback objects] \label{traceback}
Traceback objects represent a stack trace of an exception. A
@ -743,9 +765,10 @@ interactive, it is also made available to the user as
\indexii{stack}{trace}
\indexii{exception}{handler}
\indexii{execution}{stack}
\ttindex{exc_info}
\ttindex{exc_traceback}
\ttindex{last_traceback}
\withsubitem{(in module sys)}{%
\ttindex{exc_info}%
\ttindex{exc_traceback}%
\ttindex{last_traceback}}
\ttindex{sys.exc_info}
\ttindex{sys.exc_traceback}
\ttindex{sys.last_traceback}
@ -759,10 +782,11 @@ precise instruction. The line number and last instruction in the
traceback may differ from the line number of its frame object if the
exception occurred in a \keyword{try} statement with no matching
except clause or with a finally clause.
\ttindex{tb_next}
\ttindex{tb_frame}
\ttindex{tb_lineno}
\ttindex{tb_lasti}
\withsubitem{(traceback attribute)}{%
\ttindex{tb_next}%
\ttindex{tb_frame}%
\ttindex{tb_lineno}%
\ttindex{tb_lasti}}
\stindex{try}
\item[Slice objects]
@ -770,11 +794,15 @@ Slice objects are used to represent slices when \emph{extended slice
syntax} is used. This is a slice using two colons, or multiple slices
or ellipses separated by commas, e.g., \code{a[i:j:step]}, \code{a[i:j,
k:l]}, or \code{a[..., i:j])}. They are also created by the built-in
\function{slice()} function.
\function{slice()}\bifuncindex{slice} function.
Special read-only attributes: \member{start} is the lowerbound;
\member{stop} is the upperbound; \member{step} is the step value; each is
\code{None} if omitted. These attributes can have any type.
\withsubitem{(slice object attribute)}{%
\ttindex{start}%
\ttindex{stop}%
\ttindex{step}}
\end{description} % Internal types
@ -792,24 +820,23 @@ this class, then \code{x[i]} is equivalent to
a list object, \code{x.__getitem__(i)} is not equivalent to
\code{x[i]}.) Except where mentioned, attempts to execute an
operation raise an exception when no appropriate method is defined.
\ttindex{__getitem__}
\withsubitem{(mapping object method)}{\ttindex{__getitem__()}}
\subsection{Basic customization\label{customization}}
\begin{methoddescni}{__init__}{self\optional{, args...}}
\begin{methoddesc}[object]{__init__}{self\optional{, args...}}
Called when the instance is created. The arguments are those passed
to the class constructor expression. If a base class has an
\method{__init__()} method the derived class's \method{__init__()} method must
explicitly call it to ensure proper initialization of the base class
part of the instance, e.g., \samp{BaseClass.__init__(\var{self},
[\var{args}...])}.
\ttindex{__init__}
\indexii{class}{constructor}
\end{methoddescni}
\end{methoddesc}
\begin{methoddescni}{__del__}{self}
\begin{methoddesc}[object]{__del__}{self}
Called when the instance is about to be destroyed. This is also
called a destructor\index{destructor}. If a base class
has a \method{__del__()} method, the derived class's \method{__del__()} method
@ -821,7 +848,6 @@ reference to it. It may then be called at a later time when this new
reference is deleted. It is not guaranteed that
\method{__del__()} methods are called for objects that still exist when
the interpreter exits.
\ttindex{__del__}
\stindex{del}
\strong{Programmer's note:} \samp{del x} doesn't directly call
@ -853,9 +879,9 @@ deleted from their module before other globals are deleted; if no
other references to such globals exist, this may help in assuring that
imported modules are still available at the time when the
\method{__del__()} method is called.
\end{methoddescni}
\end{methoddesc}
\begin{methoddescni}{__repr__}{self}
\begin{methoddesc}[object]{__repr__}{self}
Called by the \function{repr()}\bifuncindex{repr} built-in function
and by string conversions (reverse quotes) to compute the ``official''
string representation of an object. This should normally look like a
@ -864,36 +890,33 @@ the same value. By convention, objects which cannot be trivially
converted to strings which can be used to create a similar object
produce a string of the form \samp{<\var{...some useful
description...}>}.
\ttindex{__repr__}
\indexii{string}{conversion}
\indexii{reverse}{quotes}
\indexii{backward}{quotes}
\index{back-quotes}
\end{methoddescni}
\end{methoddesc}
\begin{methoddescni}{__str__}{self}
\begin{methoddesc}[object]{__str__}{self}
Called by the \function{str()}\bifuncindex{str} built-in function and
by the \keyword{print}\stindex{print} statement to compute the
``informal'' string representation of an object. This differs from
\method{__repr__()} in that it does not have to be a valid Python
expression: a more convenient or concise representation may be used
instead.
\ttindex{__str__}
\end{methoddescni}
\end{methoddesc}
\begin{methoddescni}{__cmp__}{self, other}
\begin{methoddesc}[object]{__cmp__}{self, other}
Called by all comparison operations. Should return a negative integer if
\code{self < other}, zero if \code{self == other}, a positive integer if
\code{self > other}. If no \method{__cmp__()} operation is defined, class
instances are compared by object identity (``address'').
(Note: the restriction that exceptions are not propagated by
\method{__cmp__()} has been removed in Python 1.5.)
\ttindex{__cmp__}
\bifuncindex{cmp}
\index{comparisons}
\end{methoddescni}
\end{methoddesc}
\begin{methoddescni}{__hash__}{self}
\begin{methoddesc}[object]{__hash__}{self}
Called for the key object for dictionary\obindex{dictionary}
operations, and by the built-in function
\function{hash()}\bifuncindex{hash}. Should return a 32-bit integer
@ -910,18 +933,17 @@ implements a \method{__cmp__()} method it should not implement
\method{__hash__()}, since the dictionary implementation requires that
a key's hash value is immutable (if the object's hash value changes, it
will be in the wrong hash bucket).
\ttindex{__cmp__}
\ttindex{__hash__}
\end{methoddescni}
\withsubitem{(object method)}{\ttindex{__cmp__()}}
\end{methoddesc}
\begin{methoddescni}{__nonzero__}{self}
\begin{methoddesc}[object]{__nonzero__}{self}
Called to implement truth value testing; should return \code{0} or
\code{1}. When this method is not defined, \method{__len__()} is
called, if it is defined (see below). If a class defines neither
\method{__len__()} nor \method{__nonzero__()}, all its instances are
considered true.
\ttindex{__nonzero__}
\end{methoddescni}
\withsubitem{(mapping object method)}{\ttindex{__len__()}}
\end{methoddesc}
\subsection{Customizing attribute access\label{attribute-access}}
@ -933,13 +955,12 @@ For performance reasons, these methods are cached in the class object
at class definition time; therefore, they cannot be changed after the
class definition is executed.
\begin{methoddescni}{__getattr__}{self, name}
\begin{methoddesc}[object]{__getattr__}{self, name}
Called when an attribute lookup has not found the attribute in the
usual places (i.e. it is not an instance attribute nor is it found in
the class tree for \code{self}). \code{name} is the attribute name.
This method should return the (computed) attribute value or raise an
\exception{AttributeError} exception.
\ttindex{__getattr__}
Note that if the attribute is found through the normal mechanism,
\method{__getattr__()} is not called. (This is an intentional
@ -950,40 +971,38 @@ the instance.
Note that at least for instance variables, you can fake
total control by not inserting any values in the instance
attribute dictionary (but instead inserting them in another object).
\ttindex{__setattr__}
\end{methoddescni}
\withsubitem{(object method)}{\ttindex{__setattr__()}}
\end{methoddesc}
\begin{methoddescni}{__setattr__}{self, name, value}
\begin{methoddesc}[object]{__setattr__}{self, name, value}
Called when an attribute assignment is attempted. This is called
instead of the normal mechanism (i.e.\ store the value in the instance
dictionary). \var{name} is the attribute name, \var{value} is the
value to be assigned to it.
\ttindex{__setattr__}
If \method{__setattr__()} wants to assign to an instance attribute, it
should not simply execute \samp{self.\var{name} = value} --- this
would cause a recursive call to itself. Instead, it should insert the
value in the dictionary of instance attributes, e.g.,
\samp{self.__dict__[\var{name}] = value}.
\ttindex{__dict__}
\end{methoddescni}
\withsubitem{(instance attribute)}{\ttindex{__dict__}}
\end{methoddesc}
\begin{methoddescni}{__delattr__}{self, name}
\begin{methoddesc}[object]{__delattr__}{self, name}
Like \method{__setattr__()} but for attribute deletion instead of
assignment.
\ttindex{__delattr__}
\end{methoddescni}
assignment. This should only be implemented if \samp{del
obj.\var{name}} is meaningful for the object.
\end{methoddesc}
\subsection{Emulating callable objects\label{callable-types}}
\begin{methoddescni}{__call__}{self\optional{, args...}}
\begin{methoddesc}[object]{__call__}{self\optional{, args...}}
Called when the instance is ``called'' as a function; if this method
is defined, \code{\var{x}(arg1, arg2, ...)} is a shorthand for
\code{\var{x}.__call__(arg1, arg2, ...)}.
\ttindex{__call__}
\indexii{call}{instance}
\end{methoddescni}
\end{methoddesc}
\subsection{Emulating sequence and mapping types\label{sequence-types}}
@ -1007,57 +1026,60 @@ multiplication (meaning repetition) by defining the methods
\method{__add__()}, \method{__radd__()}, \method{__mul__()} and
\method{__rmul__()} described below; they should not define
\method{__coerce__()} or other numerical operators.
\ttindex{keys}
\ttindex{values}
\ttindex{items}
\ttindex{has_key}
\ttindex{get}
\ttindex{clear}
\ttindex{copy}
\ttindex{update}
\ttindex{append}
\ttindex{count}
\ttindex{index}
\ttindex{insert}
\ttindex{pop}
\ttindex{remove}
\ttindex{reverse}
\ttindex{sort}
\ttindex{__add__}
\ttindex{__radd__}
\ttindex{__mul__}
\ttindex{__rmul__}
\ttindex{__coerce__}
\withsubitem{(mapping object method)}{%
\ttindex{keys()}%
\ttindex{values()}%
\ttindex{items()}%
\ttindex{has_key()}%
\ttindex{get()}%
\ttindex{clear()}%
\ttindex{copy()}%
\ttindex{update()}}
\withsubitem{(sequence object method)}{%
\ttindex{append()}%
\ttindex{count()}%
\ttindex{index()}%
\ttindex{insert()}%
\ttindex{pop()}%
\ttindex{remove()}%
\ttindex{reverse()}%
\ttindex{sort()}%
\ttindex{__add__()}%
\ttindex{__radd__()}%
\ttindex{__mul__()}%
\ttindex{__rmul__()}}
\withsubitem{(numberic object method)}{\ttindex{__coerce__()}}
\begin{methoddescni}{__len__}{self}
\begin{methoddesc}[mapping object]{__len__}{self}
Called to implement the built-in function
\function{len()}\bifuncindex{len}. Should return the length of the
object, an integer \code{>=} 0. Also, an object that doesn't define a
\method{__nonzero__()} method and whose \method{__len__()} method
returns zero is considered to be false in a Boolean context.
\ttindex{__len__}
\ttindex{__nonzero__}
\end{methoddescni}
\withsubitem{(object method)}{\ttindex{__nonzero__()}}
\end{methoddesc}
\begin{methoddescni}{__getitem__}{self, key}
\begin{methoddesc}[mapping object]{__getitem__}{self, key}
Called to implement evaluation of \code{\var{self}[\var{key}]}.
For a sequence types, the accepted keys should be integers. Note that the
special interpretation of negative indices (if the class wishes to
emulate a sequence type) is up to the \method{__getitem__()} method.
\ttindex{__getitem__}
\end{methoddescni}
\end{methoddesc}
\begin{methoddescni}{__setitem__}{self, key, value}
\begin{methoddesc}[mapping object]{__setitem__}{self, key, value}
Called to implement assignment to \code{\var{self}[\var{key}]}. Same
note as for \method{__getitem__()}.
\ttindex{__setitem__}
\end{methoddescni}
note as for \method{__getitem__()}. This should only be implemented
for mappings if the objects support changes to the values for keys, or
if new keys can be added, or for sequences if elements can be
replaced.
\end{methoddesc}
\begin{methoddescni}{__delitem__}{self, key}
\begin{methoddesc}[mapping object]{__delitem__}{self, key}
Called to implement deletion of \code{\var{self}[\var{key}]}. Same
note as for \method{__getitem__()}.
\ttindex{__delitem__}
\end{methoddescni}
note as for \method{__getitem__()}. This should only be implemented
for mappings if the objects support removal of keys, or for sequences
if elements can be removed from the sequence.
\end{methoddesc}
\subsection{Additional methods for emulation of sequence types
@ -1068,7 +1090,7 @@ objects. Immutable sequences methods should only define
\method{__getslice__()}; mutable sequences, should define all three
three methods.
\begin{methoddescni}{__getslice__}{self, i, j}
\begin{methoddesc}[sequence object]{__getslice__}{self, i, j}
Called to implement evaluation of \code{\var{self}[\var{i}:\var{j}]}.
The returned object should be of the same type as \var{self}. Note
that missing \var{i} or \var{j} in the slice expression are replaced
@ -1076,20 +1098,17 @@ by zero or \code{sys.maxint}, respectively, and no further
transformations on the indices is performed. The interpretation of
negative indices and indices larger than the length of the sequence is
up to the method.
\ttindex{__getslice__}
\end{methoddescni}
\end{methoddesc}
\begin{methoddescni}{__setslice__}{self, i, j, sequence}
\begin{methoddesc}[sequence object]{__setslice__}{self, i, j, sequence}
Called to implement assignment to \code{\var{self}[\var{i}:\var{j}]}.
Same notes for \var{i} and \var{j} as for \method{__getslice__()}.
\ttindex{__setslice__}
\end{methoddescni}
\end{methoddesc}
\begin{methoddescni}{__delslice__}{self, i, j}
\begin{methoddesc}[sequence object]{__delslice__}{self, i, j}
Called to implement deletion of \code{\var{self}[\var{i}:\var{j}]}.
Same notes for \var{i} and \var{j} as for \method{__getslice__()}.
\ttindex{__delslice__}
\end{methoddescni}
\end{methoddesc}
Notice that these methods are only invoked when a single slice with a
single colon is used. For slice operations involving extended slice
@ -1103,18 +1122,18 @@ Methods corresponding to operations that are not supported by the
particular kind of number implemented (e.g., bitwise operations for
non-integral numbers) should be left undefined.
\begin{methoddescni}{__add__}{self, other}
\methodlineni{__sub__}{self, other}
\methodlineni{__mul__}{self, other}
\methodlineni{__div__}{self, other}
\methodlineni{__mod__}{self, other}
\methodlineni{__divmod__}{self, other}
\methodlineni{__pow__}{self, other\optional{, modulo}}
\methodlineni{__lshift__}{self, other}
\methodlineni{__rshift__}{self, other}
\methodlineni{__and__}{self, other}
\methodlineni{__xor__}{self, other}
\methodlineni{__or__}{self, other}
\begin{methoddesc}[numberic interface]{__add__}{self, other}
\methodline{__sub__}{self, other}
\methodline{__mul__}{self, other}
\methodline{__div__}{self, other}
\methodline{__mod__}{self, other}
\methodline{__divmod__}{self, other}
\methodline{__pow__}{self, other\optional{, modulo}}
\methodline{__lshift__}{self, other}
\methodline{__rshift__}{self, other}
\methodline{__and__}{self, other}
\methodline{__xor__}{self, other}
\methodline{__or__}{self, other}
These functions are
called to implement the binary arithmetic operations (\code{+},
\code{-}, \code{*}, \code{/}, \code{\%},
@ -1127,32 +1146,20 @@ class that has an \method{__add__()} method,
\method{__pow__()} should be defined to accept an optional third
argument if the ternary version of the built-in
\function{pow()}\bifuncindex{pow} function is to be supported.
\ttindex{__or__}
\ttindex{__xor__}
\ttindex{__and__}
\ttindex{__rshift__}
\ttindex{__lshift__}
\ttindex{__pow__}
\ttindex{__divmod__}
\ttindex{__mod__}
\ttindex{__div__}
\ttindex{__mul__}
\ttindex{__sub__}
\ttindex{__add__}
\end{methoddescni}
\end{methoddesc}
\begin{methoddescni}{__radd__}{self, other}
\methodlineni{__rsub__}{self, other}
\methodlineni{__rmul__}{self, other}
\methodlineni{__rdiv__}{self, other}
\methodlineni{__rmod__}{self, other}
\methodlineni{__rdivmod__}{self, other}
\methodlineni{__rpow__}{self, other}
\methodlineni{__rlshift__}{self, other}
\methodlineni{__rrshift__}{self, other}
\methodlineni{__rand__}{self, other}
\methodlineni{__rxor__}{self, other}
\methodlineni{__ror__}{self, other}
\begin{methoddesc}[numeric interface]{__radd__}{self, other}
\methodline{__rsub__}{self, other}
\methodline{__rmul__}{self, other}
\methodline{__rdiv__}{self, other}
\methodline{__rmod__}{self, other}
\methodline{__rdivmod__}{self, other}
\methodline{__rpow__}{self, other}
\methodline{__rlshift__}{self, other}
\methodline{__rrshift__}{self, other}
\methodline{__rand__}{self, other}
\methodline{__rxor__}{self, other}
\methodline{__ror__}{self, other}
These functions are
called to implement the binary arithmetic operations (\code{+},
\code{-}, \code{*}, \code{/}, \code{\%},
@ -1166,55 +1173,33 @@ has an \method{__rsub__()} method, \code{\var{y}.__rsub__(\var{x})} is
called. Note that ternary \function{pow()}\bifuncindex{pow} will not
try calling \method{__rpow__()} (the coercion rules would become too
complicated).
\ttindex{__or__}
\ttindex{__xor__}
\ttindex{__and__}
\ttindex{__rshift__}
\ttindex{__lshift__}
\ttindex{__pow__}
\ttindex{__divmod__}
\ttindex{__mod__}
\ttindex{__div__}
\ttindex{__mul__}
\ttindex{__sub__}
\ttindex{__add__}
\end{methoddescni}
\end{methoddesc}
\begin{methoddescni}{__neg__}{self}
\methodlineni{__pos__}{self}
\methodlineni{__abs__}{self}
\methodlineni{__invert__}{self}
\begin{methoddesc}[numeric interface]{__neg__}{self}
\methodline{__pos__}{self}
\methodline{__abs__}{self}
\methodline{__invert__}{self}
Called to implement the unary arithmetic operations (\code{-}, \code{+},
\function{abs()}\bifuncindex{abs} and \code{~}).
\ttindex{__invert__}
\ttindex{__abs__}
\ttindex{__pos__}
\ttindex{__neg__}
\end{methoddescni}
\end{methoddesc}
\begin{methoddescni}{__int__}{self}
\begin{methoddesc}[numeric interface]{__int__}{self}
\methodlineni{__long__}{self}
\methodlineni{__float__}{self}
Called to implement the built-in functions
\function{int()}\bifuncindex{int}, \function{long()}\bifuncindex{long}
and \function{float()}\bifuncindex{float}. Should return a value of
the appropriate type.
\ttindex{__float__}
\ttindex{__long__}
\ttindex{__int__}
\end{methoddescni}
\end{methoddesc}
\begin{methoddescni}{__oct__}{self}
\begin{methoddesc}[numeric interface]{__oct__}{self}
\methodlineni{__hex__}{self}
Called to implement the built-in functions
\function{oct()}\bifuncindex{oct} and
\function{hex()}\bifuncindex{hex}. Should return a string value.
\ttindex{__hex__}
\ttindex{__oct__}
\end{methoddescni}
\end{methoddesc}
\begin{methoddescni}{__coerce__}{self, other}
\ttindex{__coerce__}
\begin{methoddesc}[numeric interface]{__coerce__}{self, other}
Called to implement ``mixed-mode'' numeric arithmetic. Should either
return a 2-tuple containing \var{self} and \var{other} converted to
a common numeric type, or \code{None} if conversion is possible. When
@ -1223,7 +1208,7 @@ return \code{None}, since the interpreter will also ask the other
object to attempt a coercion (but sometimes, if the implementation of
the other type cannot be changed, it is useful to do the conversion to
the other type here).
\end{methoddescni}
\end{methoddesc}
\strong{Coercion rules}: to evaluate \var{x} \var{op} \var{y}, the
following steps are taken (where \method{__op__()} and