Returns the result of right shifting \var{o1} by \var{o2} on
success, or \NULL{} on failure. The operation is done
\emph{in-place} when \var{o1} supports it. This is the equivalent
- of the Python statement \samp{\var{o1} >\code{>=} \var{o2}}.
+ of the Python statement \samp{\var{o1} >>= \var{o2}}.
\end{cfuncdesc}
Once the Debug build has succeeded, bring up a DOS box, and change
to the \file{example_nt\textbackslash Debug} directory. You
should now be able to repeat the following session (\code{C>} is
- the DOS prompt, \code{>\code{>}>} is the Python prompt; note that
+ the DOS prompt, \code{>>>} is the Python prompt; note that
build information and various debug output from Python may not
match this screen dump exactly):
\begin{enumerate}
\item Being able to tell if a line of input completes a Python
statement: in short, telling whether to print
- `\code{>\code{>}>~}' or `\code{...~}' next.
+ `\code{>>>~}' or `\code{...~}' next.
\item Remembering which future statements the user has entered, so
subsequent input can be compiled with these in effect.
\end{enumerate}
\end{verbatim}
Any expected output must immediately follow the final
-\code{'>\code{>}>~'} or \code{'...~'} line containing the code, and
-the expected output (if any) extends to the next \code{'>\code{>}>~'}
+\code{'>>>~'} or \code{'...~'} line containing the code, and
+the expected output (if any) extends to the next \code{'>>>~'}
or all-whitespace line.
The fine print:
\end{verbatim}
and as many leading whitespace characters are stripped from the
-expected output as appeared in the initial \code{'>\code{>}>~'} line
+expected output as appeared in the initial \code{'>>>~'} line
that started the example.
\end{itemize}
\begin{methoddesc}{handle_decl}{decl}
Method called when an SGML declaration is read by the parser. The
\var{decl} parameter will be the entire contents of the declaration
-inside the \code{<!}...\code{>} markup.It is intended to be overridden
+inside the \code{<!}...\code{>} markup. It is intended to be overridden
by a derived class; the base class implementation does nothing.
\end{methoddesc}
\begin{funcdesc}{irshift}{a, b}
\funcline{__irshift__}{a, b}
-\code{a = irshift(a, b)} is equivalent to \code{a >}\code{>= b}.
+\code{a = irshift(a, b)} is equivalent to \code{a >>= b}.
\versionadded{2.5}
\end{funcdesc}
{\code{neg(\var{a})}}
\lineiii{Negation (Logical)}{\code{not \var{a}}}
{\code{not_(\var{a})}}
- \lineiii{Right Shift}{\code{\var{a} >\code{>} \var{b}}}
+ \lineiii{Right Shift}{\code{\var{a} >> \var{b}}}
{\code{rshift(\var{a}, \var{b})}}
\lineiii{Sequence Repitition}{\code{\var{seq} * \var{i}}}
{\code{repeat(\var{seq}, \var{i})}}
Strings specifying the primary and secondary prompt of the
interpreter. These are only defined if the interpreter is in
interactive mode. Their initial values in this case are
- \code{'>\code{>}> '} and \code{'... '}. If a non-string object is
+ \code{'>>>~'} and \code{'... '}. If a non-string object is
assigned to either variable, its \function{str()} is re-evaluated
each time the interpreter prepares to read a new interactive
command; this can be used to implement a dynamic prompt.
\item[\longprogramopt{missing}, \programopt{-m}]
When generating annotated listings, mark lines which
-were not executed with \code{>}\code{>}\code{>}\code{>}\code{>}\code{>}.
+were not executed with `\code{>>>>>>}'.
\item[\longprogramopt{summary}, \programopt{-s}]
When using \longprogramopt{count} or \longprogramopt{report}, write a
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{\&}, \code{\^}, \code{|}). For instance, to
+\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,
\code{\var{x}.__add__(\var{y})} is called. The \method{__divmod__()}
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{\&}, \code{\^}, \code{|}) with reflected
+\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
\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{\&=},
+\code{**=}, \code{<<=}, \code{>>=}, \code{\&=},
\code{\textasciicircum=}, \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
\hline
\lineii{\code{\&}} {Bitwise AND}
\hline
- \lineii{\code{<}\code{<}, \code{>}\code{>}} {Shifts}
+ \lineii{\code{<<}, \code{>>}} {Shifts}
\hline
\lineii{\code{+}, \code{-}}{Addition and subtraction}
\hline
\begin{productionlist}
\production{print_stmt}
{"print" ( \optional{\token{expression} ("," \token{expression})* \optional{","}}}
- \productioncont{| ">\code{>}" \token{expression}
+ \productioncont{| ">>" \token{expression}
\optional{("," \token{expression})+ \optional{","}} )}
\end{productionlist}
\index{>>>}
-\item[\code{>\code{>}>}]
+\item[\code{>>>}]
The typical Python prompt of the interactive shell. Often seen for
code examples that can be tried right away in the interpreter.
When commands are read from a tty, the interpreter is said to be in
\emph{interactive mode}. In this mode it prompts for the next command
with the \emph{primary prompt}, usually three greater-than signs
-(\samp{>\code{>}>~}); for continuation lines it prompts with the
+(\samp{>>>~}); for continuation lines it prompts with the
\emph{secondary prompt}, by default three dots (\samp{...~}).
The interpreter prints a welcome message stating its version number
and a copyright notice before printing the first prompt:
\chapter{An Informal Introduction to Python \label{informal}}
In the following examples, input and output are distinguished by the
-presence or absence of prompts (\samp{>\code{>}>~} and \samp{...~}): to repeat
+presence or absence of prompts (\samp{>>>~} and \samp{...~}): to repeat
the example, you must type everything after the prompt, when the
prompt appears; lines that do not begin with a prompt are output from
the interpreter. %
\section{Using Python as a Calculator \label{calculator}}
Let's try some simple Python commands. Start the interpreter and wait
-for the primary prompt, \samp{>\code{>}>~}. (It shouldn't take long.)
+for the primary prompt, \samp{>>>~}. (It shouldn't take long.)
\subsection{Numbers \label{numbers}}
% The empty groups below prevent conversion to guillemets.
The full list of supported assignment operators is \code{+=},
\code{-=}, \code{*=}, \code{/=}, \code{\%=}, \code{**=}, \code{\&=},
-\code{|=}, \verb|^=|, \code{>{}>=}, and \code{<{}<=}. Python classes can
+\code{|=}, \verb|^=|, \code{>>=}, and \code{<<=}. Python classes can
override the augmented assignment operators by defining methods named
\method{__iadd__}, \method{__isub__}, etc. For example, the following
\class{Number} class stores a number and supports using += to create a
projects / python / commitdiff