traverseda
/
cpython
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Work around the conversion of ">>" and "<<" to guillemets. Reported by Ping. 

Wrap some long lines and fix some markup nits.
This commit is contained in:
Fred Drake 2001-04-13 15:54:41 +00:00
parent d9994e0115
commit fb8ffe6b5e
1 changed files with 56 additions and 51 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

107
Doc/ref/ref3.tex
View File

@ -1233,22 +1233,24 @@ object is created instead, and passed to \method{__getitem__()} instead.
Called to implement assignment to \code{\var{self}[\var{i}:\var{j}]}.
Same notes for \var{i} and \var{j} as for \method{__getslice__()}.
This method is deprecated. If no \method{__setslice__()} is found, a slice
object is created instead, and passed to \method{__setitem__()} instead.
This method is deprecated. If no \method{__setslice__()} is found, a
slice object is created instead, and passed to \method{__setitem__()}
instead.
\end{methoddesc}
\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__()}.
This method is deprecated. If no \method{__delslice__()} is found, a slice
object is created instead, and passed to \method{__delitem__()} instead.
This method is deprecated. If no \method{__delslice__()} is found, a
slice object is created instead, and passed to \method{__delitem__()}
instead.
\end{methoddesc}
Notice that these methods are only invoked when a single slice with a single
colon is used, and the slice method is available. For slice operations
involving extended slice notation, or in absence of the slice methods,
\method{__getitem__()}, \method{__setitem__()} or \method{__delitem__()} is
called with a slice object as argument.
Notice that these methods are only invoked when a single slice with a
single colon is used, and the slice method is available. For slice
operations involving extended slice notation, or in absence of the
slice methods, \method{__getitem__()}, \method{__setitem__()} or
\method{__delitem__()} is called with a slice object as argument.
The following example demonstrate how to make your program or module
compatible with earlier versions of Python (assuming that methods
@ -1326,10 +1328,10 @@ These functions are
called to implement the binary arithmetic operations (\code{+},
\code{-}, \code{*}, \code{/}, \code{\%},
\function{divmod()}\bifuncindex{divmod},
\function{pow()}\bifuncindex{pow}, \code{**}, \code{<<}, \code{>>},
\code{\&}, \code{\^}, \code{|}). For instance, to evaluate the
expression \var{x}\code{+}\var{y}, where \var{x} is an instance of a
class that has an \method{__add__()} method,
\function{pow()}\bifuncindex{pow}, \code{**}, \code{<}\code{<},
\code{>}\code{>}, \code{\&}, \code{\^}, \code{|}). For instance, to
evaluate the expression \var{x}\code{+}\var{y}, where \var{x} is an
instance of a class that has an \method{__add__()} method,
\code{\var{x}.__add__(\var{y})} is called. Note that
\method{__pow__()} should be defined to accept an optional third
argument if the ternary version of the built-in
@ -1352,14 +1354,15 @@ These functions are
called to implement the binary arithmetic operations (\code{+},
\code{-}, \code{*}, \code{/}, \code{\%},
\function{divmod()}\bifuncindex{divmod},
\function{pow()}\bifuncindex{pow}, \code{**}, \code{<<}, \code{>>},
\code{\&}, \code{\^}, \code{|}) with reflected (swapped) operands. These
functions are only called if the left operand does not support the
corresponding operation. For instance, to evaluate the expression
\var{x}\code{-}\var{y}, where \var{y} is an instance of a class that
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
\function{pow()}\bifuncindex{pow}, \code{**}, \code{<}\code{<},
\code{>}\code{>}, \code{\&}, \code{\^}, \code{|}) with reflected
(swapped) operands. These functions are only called if the left
operand does not support the corresponding operation. For instance,
to evaluate the expression \var{x}\code{-}\var{y}, where \var{y} is an
instance of a class that 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).
\end{methoddesc}
@ -1374,27 +1377,28 @@ complicated).
\methodline[numeric object]{__iand__}{self, other}
\methodline[numeric object]{__ixor__}{self, other}
\methodline[numeric object]{__ior__}{self, other}
These methods are called to implement the augmented arithmetic operations
(\code{+=}, \code{-=}, \code{*=}, \code{/=}, \code{\%=}, \code{**=},
\code{<<=}, \code{>>=}, \code{\&=}, \code{\^=}, \code{|=}). These methods
should attempt to do the operation in-place (modifying \var{self}) and
return the result (which could be, but does not have to be, \var{self}). If
a specific method is not defined, the augmented operation falls back to the
normal methods. For instance, to evaluate the expression
\var{x}\code{+=}\var{y}, where \var{x} is an instance of a class that has an
\method{__iadd__()} method, \code{\var{x}.__iadd__(\var{y})} is called. If
\var{x} is an instance of a class that does not define a \method{__iadd()}
method, \code{\var{x}.__add__(\var{y})} and \code{\var{y}.__radd__(\var{x})}
are considered, as with the evaluation of \var{x}\code{+}\var{y}.
These methods are called to implement the augmented arithmetic
operations (\code{+=}, \code{-=}, \code{*=}, \code{/=}, \code{\%=},
\code{**=}, \code{<}\code{<=}, \code{>}\code{>=}, \code{\&=},
\code{\^=}, \code{|=}). These methods should attempt to do the
operation in-place (modifying \var{self}) and return the result (which
could be, but does not have to be, \var{self}). If a specific method
is not defined, the augmented operation falls back to the normal
methods. For instance, to evaluate the expression
\var{x}\code{+=}\var{y}, where \var{x} is an instance of a class that
has an \method{__iadd__()} method, \code{\var{x}.__iadd__(\var{y})} is
called. If \var{x} is an instance of a class that does not define a
\method{__iadd()} method, \code{\var{x}.__add__(\var{y})} and
\code{\var{y}.__radd__(\var{x})} are considered, as with the
evaluation of \var{x}\code{+}\var{y}.
\end{methoddesc}
\begin{methoddesc}[numeric object]{__neg__}{self}
\methodline[numeric object]{__pos__}{self}
\methodline[numeric object]{__abs__}{self}
\methodline[numeric object]{__invert__}{self}
Called to implement the unary arithmetic operations (\code{-}, \code{+},
\function{abs()}\bifuncindex{abs} and \code{\~{}}).
Called to implement the unary arithmetic operations (\code{-},
\code{+}, \function{abs()}\bifuncindex{abs} and \code{\~{}}).
\end{methoddesc}
\begin{methoddesc}[numeric object]{__complex__}{self}
@ -1427,17 +1431,17 @@ the other type here).
\end{methoddesc}
\strong{Coercion rules}: to evaluate \var{x} \var{op} \var{y}, the
following steps are taken (where \method{__op__()} and
\method{__rop__()} are the method names corresponding to \var{op},
e.g., if var{op} is `\code{+}', \method{__add__()} and
following steps are taken (where \method{__\var{op}__()} and
\method{__r\var{op}__()} are the method names corresponding to
\var{op}, e.g., if \var{op} is `\code{+}', \method{__add__()} and
\method{__radd__()} are used). If an exception occurs at any point,
the evaluation is abandoned and exception handling takes over.
\begin{itemize}
\item[0.] If \var{x} is a string object and op is the modulo operator (\%),
the string formatting operation is invoked and the remaining steps are
skipped.
\item[0.] If \var{x} is a string object and \var{op} is the modulo
operator (\%), the string formatting operation is invoked and
the remaining steps are skipped.
\item[1.] If \var{x} is a class instance:
@ -1451,8 +1455,8 @@ skipped.
\item[1b.] If neither \var{x} nor \var{y} is a class instance
after coercion, go to step 3.
\item[1c.] If \var{x} has a method \method{__op__()}, return
\code{\var{x}.__op__(\var{y})}; otherwise, restore \var{x} and
\item[1c.] If \var{x} has a method \method{__\var{op}__()}, return
\code{\var{x}.__\var{op}__(\var{y})}; otherwise, restore \var{x} and
\var{y} to their value before step 1a.
\end{itemize}
@ -1469,9 +1473,9 @@ skipped.
\item[2b.] If neither \var{x} nor \var{y} is a class instance
after coercion, go to step 3.
\item[2b.] If \var{y} has a method \method{__rop__()}, return
\code{\var{y}.__rop__(\var{x})}; otherwise, restore \var{x}
and \var{y} to their value before step 2a.
\item[2b.] If \var{y} has a method \method{__r\var{op}__()},
return \code{\var{y}.__r\var{op}__(\var{x})}; otherwise,
restore \var{x} and \var{y} to their value before step 2a.
\end{itemize}
@ -1480,11 +1484,12 @@ instance.
\begin{itemize}
\item[3a.] If op is `\code{+}' and \var{x} is a sequence,
sequence concatenation is invoked.
\item[3a.] If \var{op} is `\code{+}' and \var{x} is a
sequence, sequence concatenation is invoked.
\item[3b.] If op is `\code{*}' and one operand is a sequence
and the other an integer, sequence repetition is invoked.
\item[3b.] If \var{op} is `\code{*}' and one operand is a
sequence and the other an integer, sequence repetition is
invoked.
\item[3c.] Otherwise, both operands must be numbers; they are
coerced to a common type if possible, and the numeric