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

Whitespace cleanup. Also remove the empty lines 

from the previous check in.
This commit is contained in:
Žiga Seilnacht 2007-03-16 12:11:11 +00:00
parent 6f2d09c949
commit 594965d17a
1 changed files with 38 additions and 41 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

79
Doc/ref/ref3.tex
View File

@ -219,7 +219,7 @@ when using mixed operands.
\indexii{integer}{representation} \indexii{integer}{representation}
\item[Floating point numbers] \item[Floating point numbers]
These represent machine-level double precision floating point numbers. These represent machine-level double precision floating point numbers.
You are at the mercy of the underlying machine architecture (and You are at the mercy of the underlying machine architecture (and
C or Java implementation) for the accepted range and handling of overflow. C or Java implementation) for the accepted range and handling of overflow.
Python does not support single-precision floating point numbers; the Python does not support single-precision floating point numbers; the
@ -471,7 +471,7 @@ parameter list.
\obindex{function} \obindex{function}
\obindex{user-defined function} \obindex{user-defined function}
Special attributes: Special attributes:
\begin{tableiii}{lll}{member}{Attribute}{Meaning}{} \begin{tableiii}{lll}{member}{Attribute}{Meaning}{}
\lineiii{func_doc}{The function's documentation string, or \lineiii{func_doc}{The function's documentation string, or
@ -861,12 +861,12 @@ but they are mentioned here for completeness.
\begin{description} \begin{description}
\item[Code objects] \item[Code objects]
Code objects represent \emph{byte-compiled} executable Python code, or Code objects represent \emph{byte-compiled} executable Python code, or
\emph{bytecode}. \emph{bytecode}.
The difference between a code The difference between a code
object and a function object is that the function object contains an object and a function object is that the function object contains an
explicit reference to the function's globals (the module in which it explicit reference to the function's globals (the module in which it
was defined), while a code object contains no context; was defined), while a code object contains no context;
also the default argument values are stored in the function object, also the default argument values are stored in the function object,
not in the code object (because they represent values calculated at not in the code object (because they represent values calculated at
run-time). Unlike function objects, code objects are immutable and run-time). Unlike function objects, code objects are immutable and
@ -1070,7 +1070,7 @@ by the built-in \function{classmethod()} constructor.
%========================================================================= %=========================================================================
\section{New-style and classic classes} \section{New-style and classic classes}
Classes and instances come in two flavors: old-style or classic, and new-style. Classes and instances come in two flavors: old-style or classic, and new-style.
Up to Python 2.1, old-style classes were the only flavour available to the Up to Python 2.1, old-style classes were the only flavour available to the
user. The concept of (old-style) class is unrelated to the concept of type: if user. The concept of (old-style) class is unrelated to the concept of type: if
@ -1245,7 +1245,7 @@ description...}>} should be returned. The return value must be a
string object. string object.
If a class defines \method{__repr__()} but not \method{__str__()}, If a class defines \method{__repr__()} but not \method{__str__()},
then \method{__repr__()} is also used when an ``informal'' string then \method{__repr__()} is also used when an ``informal'' string
representation of instances of that class is required. representation of instances of that class is required.
This is typically used for debugging, so it is important that the This is typically used for debugging, so it is important that the
representation is information-rich and unambiguous. representation is information-rich and unambiguous.
@ -1403,7 +1403,7 @@ instead of the normal mechanism (i.e.\ store the value in the instance
dictionary). \var{name} is the attribute name, \var{value} is the dictionary). \var{name} is the attribute name, \var{value} is the
value to be assigned to it. value to be assigned to it.
If \method{__setattr__()} wants to assign to an instance attribute, it If \method{__setattr__()} wants to assign to an instance attribute, it
should not simply execute \samp{self.\var{name} = value} --- this should not simply execute \samp{self.\var{name} = value} --- this
would cause a recursive call to itself. Instead, it should insert the would cause a recursive call to itself. Instead, it should insert the
value in the dictionary of instance attributes, e.g., value in the dictionary of instance attributes, e.g.,
@ -1426,8 +1426,8 @@ The following methods only apply to new-style classes.
\begin{methoddesc}[object]{__getattribute__}{self, name} \begin{methoddesc}[object]{__getattribute__}{self, name}
Called unconditionally to implement attribute accesses for instances Called unconditionally to implement attribute accesses for instances
of the class. If the class also defines \method{__getattr__()}, the latter of the class. If the class also defines \method{__getattr__()}, the latter
will not be called unless \method{__getattribute__()} either calls it will not be called unless \method{__getattribute__()} either calls it
explicitly or raises an \exception{AttributeError}. explicitly or raises an \exception{AttributeError}.
This method should return the (computed) attribute This method should return the (computed) attribute
value or raise an \exception{AttributeError} exception. value or raise an \exception{AttributeError} exception.
@ -1479,7 +1479,7 @@ descriptor.
The default behavior for attribute access is to get, set, or delete the The default behavior for attribute access is to get, set, or delete the
attribute from an object's dictionary. For instance, \code{a.x} has a attribute from an object's dictionary. For instance, \code{a.x} has a
lookup chain starting with \code{a.__dict__['x']}, then lookup chain starting with \code{a.__dict__['x']}, then
\code{type(a).__dict__['x']}, and continuing \code{type(a).__dict__['x']}, and continuing
through the base classes of \code{type(a)} excluding metaclasses. through the base classes of \code{type(a)} excluding metaclasses.
However, if the looked-up value is an object defining one of the descriptor However, if the looked-up value is an object defining one of the descriptor
@ -1493,14 +1493,14 @@ The starting point for descriptor invocation is a binding, \code{a.x}.
How the arguments are assembled depends on \code{a}: How the arguments are assembled depends on \code{a}:
\begin{itemize} \begin{itemize}
\item[Direct Call] The simplest and least common call is when user code \item[Direct Call] The simplest and least common call is when user code
directly invokes a descriptor method: \code{x.__get__(a)}. directly invokes a descriptor method: \code{x.__get__(a)}.
\item[Instance Binding] If binding to a new-style object instance, \item[Instance Binding] If binding to a new-style object instance,
\code{a.x} is transformed into the call: \code{a.x} is transformed into the call:
\code{type(a).__dict__['x'].__get__(a, type(a))}. \code{type(a).__dict__['x'].__get__(a, type(a))}.
\item[Class Binding] If binding to a new-style class, \code{A.x} \item[Class Binding] If binding to a new-style class, \code{A.x}
is transformed into the call: \code{A.__dict__['x'].__get__(None, A)}. is transformed into the call: \code{A.__dict__['x'].__get__(None, A)}.
@ -1509,7 +1509,7 @@ How the arguments are assembled depends on \code{a}:
\code{obj.__class__.__mro__} for the base class \code{A} immediately \code{obj.__class__.__mro__} for the base class \code{A} immediately
preceding \code{B} and then invokes the descriptor with the call: preceding \code{B} and then invokes the descriptor with the call:
\code{A.__dict__['m'].__get__(obj, A)}. \code{A.__dict__['m'].__get__(obj, A)}.
\end{itemize} \end{itemize}
For instance bindings, the precedence of descriptor invocation depends For instance bindings, the precedence of descriptor invocation depends
@ -1522,7 +1522,7 @@ descriptors can be overridden by instances.
Python methods (including \function{staticmethod()} and \function{classmethod()}) Python methods (including \function{staticmethod()} and \function{classmethod()})
are implemented as non-data descriptors. Accordingly, instances can are implemented as non-data descriptors. Accordingly, instances can
redefine and override methods. This allows individual instances to acquire redefine and override methods. This allows individual instances to acquire
behaviors that differ from other instances of the same class. behaviors that differ from other instances of the same class.
The \function{property()} function is implemented as a data descriptor. The \function{property()} function is implemented as a data descriptor.
Accordingly, instances cannot override the behavior of a property. Accordingly, instances cannot override the behavior of a property.
@ -1540,14 +1540,14 @@ definition. The \var{__slots__} declaration takes a sequence of instance
variables and reserves just enough space in each instance to hold a value variables and reserves just enough space in each instance to hold a value
for each variable. Space is saved because \var{__dict__} is not created for for each variable. Space is saved because \var{__dict__} is not created for
each instance. each instance.
\begin{datadesc}{__slots__} \begin{datadesc}{__slots__}
This class variable can be assigned a string, iterable, or sequence of strings This class variable can be assigned a string, iterable, or sequence of strings
with variable names used by instances. If defined in a new-style class, with variable names used by instances. If defined in a new-style class,
\var{__slots__} reserves space for the declared variables \var{__slots__} reserves space for the declared variables
and prevents the automatic creation of \var{__dict__} and \var{__weakref__} and prevents the automatic creation of \var{__dict__} and \var{__weakref__}
for each instance. for each instance.
\versionadded{2.2} \versionadded{2.2}
\end{datadesc} \end{datadesc}
\noindent \noindent
@ -1559,23 +1559,23 @@ Notes on using \var{__slots__}
variables not listed in the \var{__slots__} definition. Attempts to assign variables not listed in the \var{__slots__} definition. Attempts to assign
to an unlisted variable name raises \exception{AttributeError}. If dynamic to an unlisted variable name raises \exception{AttributeError}. If dynamic
assignment of new variables is desired, then add \code{'__dict__'} to the assignment of new variables is desired, then add \code{'__dict__'} to the
sequence of strings in the \var{__slots__} declaration. sequence of strings in the \var{__slots__} declaration.
\versionchanged[Previously, adding \code{'__dict__'} to the \var{__slots__} \versionchanged[Previously, adding \code{'__dict__'} to the \var{__slots__}
declaration would not enable the assignment of new attributes not declaration would not enable the assignment of new attributes not
specifically listed in the sequence of instance variable names]{2.3} specifically listed in the sequence of instance variable names]{2.3}
\item Without a \var{__weakref__} variable for each instance, classes \item Without a \var{__weakref__} variable for each instance, classes
defining \var{__slots__} do not support weak references to its instances. defining \var{__slots__} do not support weak references to its instances.
If weak reference support is needed, then add \code{'__weakref__'} to the If weak reference support is needed, then add \code{'__weakref__'} to the
sequence of strings in the \var{__slots__} declaration. sequence of strings in the \var{__slots__} declaration.
\versionchanged[Previously, adding \code{'__weakref__'} to the \var{__slots__} \versionchanged[Previously, adding \code{'__weakref__'} to the \var{__slots__}
declaration would not enable support for weak references]{2.3} declaration would not enable support for weak references]{2.3}
\item \var{__slots__} are implemented at the class level by creating \item \var{__slots__} are implemented at the class level by creating
descriptors (\ref{descriptors}) for each variable name. As a result, descriptors (\ref{descriptors}) for each variable name. As a result,
class attributes cannot be used to set default values for instance class attributes cannot be used to set default values for instance
variables defined by \var{__slots__}; otherwise, the class attribute would variables defined by \var{__slots__}; otherwise, the class attribute would
overwrite the descriptor assignment. overwrite the descriptor assignment.
\item If a class defines a slot also defined in a base class, the instance \item If a class defines a slot also defined in a base class, the instance
variable defined by the base class slot is inaccessible (except by retrieving variable defined by the base class slot is inaccessible (except by retrieving
@ -1584,14 +1584,14 @@ program undefined. In the future, a check may be added to prevent this.
\item The action of a \var{__slots__} declaration is limited to the class \item The action of a \var{__slots__} declaration is limited to the class
where it is defined. As a result, subclasses will have a \var{__dict__} where it is defined. As a result, subclasses will have a \var{__dict__}
unless they also define \var{__slots__}. unless they also define \var{__slots__}.
\item \var{__slots__} do not work for classes derived from ``variable-length'' \item \var{__slots__} do not work for classes derived from ``variable-length''
built-in types such as \class{long}, \class{str} and \class{tuple}. built-in types such as \class{long}, \class{str} and \class{tuple}.
\item Any non-string iterable may be assigned to \var{__slots__}. \item Any non-string iterable may be assigned to \var{__slots__}.
Mappings may also be used; however, in the future, special meaning may Mappings may also be used; however, in the future, special meaning may
be assigned to the values corresponding to each key. be assigned to the values corresponding to each key.
\item \var{__class__} assignment works only if both classes have the \item \var{__class__} assignment works only if both classes have the
same \var{__slots__}. same \var{__slots__}.
@ -1622,7 +1622,7 @@ the role of a factory function.
This variable can be any callable accepting arguments for \code{name}, This variable can be any callable accepting arguments for \code{name},
\code{bases}, and \code{dict}. Upon class creation, the callable is \code{bases}, and \code{dict}. Upon class creation, the callable is
used instead of the built-in \function{type()}. used instead of the built-in \function{type()}.
\versionadded{2.2} \versionadded{2.2}
\end{datadesc} \end{datadesc}
The appropriate metaclass is determined by the following precedence rules: The appropriate metaclass is determined by the following precedence rules:
@ -1639,7 +1639,7 @@ type).
\item Otherwise, the old-style, classic metaclass (types.ClassType) is used. \item Otherwise, the old-style, classic metaclass (types.ClassType) is used.
\end{itemize} \end{itemize}
The potential uses for metaclasses are boundless. Some ideas that have The potential uses for metaclasses are boundless. Some ideas that have
been explored including logging, interface checking, automatic delegation, been explored including logging, interface checking, automatic delegation,
@ -1672,15 +1672,15 @@ defined to handle simple, but not extended slices.) It is also recommended
that mappings provide the methods \method{keys()}, \method{values()}, that mappings provide the methods \method{keys()}, \method{values()},
\method{items()}, \method{has_key()}, \method{get()}, \method{clear()}, \method{items()}, \method{has_key()}, \method{get()}, \method{clear()},
\method{setdefault()}, \method{iterkeys()}, \method{itervalues()}, \method{setdefault()}, \method{iterkeys()}, \method{itervalues()},
\method{iteritems()}, \method{pop()}, \method{popitem()}, \method{iteritems()}, \method{pop()}, \method{popitem()},
\method{copy()}, and \method{update()} behaving similar to those for \method{copy()}, and \method{update()} behaving similar to those for
Python's standard dictionary objects. The \module{UserDict} module Python's standard dictionary objects. The \module{UserDict} module
provides a \class{DictMixin} class to help create those methods provides a \class{DictMixin} class to help create those methods
from a base set of \method{__getitem__()}, \method{__setitem__()}, from a base set of \method{__getitem__()}, \method{__setitem__()},
\method{__delitem__()}, and \method{keys()}. \method{__delitem__()}, and \method{keys()}.
Mutable sequences should provide Mutable sequences should provide
methods \method{append()}, \method{count()}, \method{index()}, methods \method{append()}, \method{count()}, \method{index()},
\method{extend()}, \method{extend()},
\method{insert()}, \method{pop()}, \method{remove()}, \method{reverse()} \method{insert()}, \method{pop()}, \method{remove()}, \method{reverse()}
and \method{sort()}, like Python standard list objects. Finally, and \method{sort()}, like Python standard list objects. Finally,
sequence types should implement addition (meaning concatenation) and sequence types should implement addition (meaning concatenation) and
@ -1703,12 +1703,12 @@ through the values.
\ttindex{items()} \ttindex{items()}
\ttindex{iterkeys()} \ttindex{iterkeys()}
\ttindex{itervalues()} \ttindex{itervalues()}
\ttindex{iteritems()} \ttindex{iteritems()}
\ttindex{has_key()} \ttindex{has_key()}
\ttindex{get()} \ttindex{get()}
\ttindex{setdefault()} \ttindex{setdefault()}
\ttindex{pop()} \ttindex{pop()}
\ttindex{popitem()} \ttindex{popitem()}
\ttindex{clear()} \ttindex{clear()}
\ttindex{copy()} \ttindex{copy()}
\ttindex{update()} \ttindex{update()}
@ -1716,7 +1716,7 @@ through the values.
\withsubitem{(sequence object method)}{ \withsubitem{(sequence object method)}{
\ttindex{append()} \ttindex{append()}
\ttindex{count()} \ttindex{count()}
\ttindex{extend()} \ttindex{extend()}
\ttindex{index()} \ttindex{index()}
\ttindex{insert()} \ttindex{insert()}
\ttindex{pop()} \ttindex{pop()}
@ -1730,7 +1730,7 @@ through the values.
\ttindex{__rmul__()} \ttindex{__rmul__()}
\ttindex{__imul__()} \ttindex{__imul__()}
\ttindex{__contains__()} \ttindex{__contains__()}
\ttindex{__iter__()}} \ttindex{__iter__()}}
\withsubitem{(numeric object method)}{\ttindex{__coerce__()}} \withsubitem{(numeric object method)}{\ttindex{__coerce__()}}
\begin{methoddesc}[container object]{__len__}{self} \begin{methoddesc}[container object]{__len__}{self}
@ -1753,7 +1753,7 @@ raised; if of a value outside the set of indexes for the sequence
(after any special interpretation of negative values), (after any special interpretation of negative values),
\exception{IndexError} should be raised. \exception{IndexError} should be raised.
For mapping types, if \var{key} is missing (not in the container), For mapping types, if \var{key} is missing (not in the container),
\exception{KeyError} should be raised. \exception{KeyError} should be raised.
\note{\keyword{for} loops expect that an \note{\keyword{for} loops expect that an
\exception{IndexError} will be raised for illegal indexes to allow \exception{IndexError} will be raised for illegal indexes to allow
proper detection of the end of the sequence.} proper detection of the end of the sequence.}
@ -1952,7 +1952,7 @@ the alternate context; \exception{TypeError} will be raised instead.
\methodline[numeric object]{__rmul__}{self, other} \methodline[numeric object]{__rmul__}{self, other}
\methodline[numeric object]{__rdiv__}{self, other} \methodline[numeric object]{__rdiv__}{self, other}
\methodline[numeric object]{__rtruediv__}{self, other} \methodline[numeric object]{__rtruediv__}{self, other}
\methodline[numeric object]{__rfloordiv__}{self, other} \methodline[numeric object]{__rfloordiv__}{self, other}
\methodline[numeric object]{__rmod__}{self, other} \methodline[numeric object]{__rmod__}{self, other}
\methodline[numeric object]{__rdivmod__}{self, other} \methodline[numeric object]{__rdivmod__}{self, other}
\methodline[numeric object]{__rpow__}{self, other} \methodline[numeric object]{__rpow__}{self, other}
@ -1973,7 +1973,7 @@ operands are of different types.\footnote{
For operands of the same type, it is assumed that if the For operands of the same type, it is assumed that if the
non-reflected method (such as \method{__add__()}) fails the non-reflected method (such as \method{__add__()}) fails the
operation is not supported, which is why the reflected method operation is not supported, which is why the reflected method
is not called.} is not called.}
For instance, to evaluate the expression \var{x}\code{-}\var{y}, For instance, to evaluate the expression \var{x}\code{-}\var{y},
where \var{y} is an instance of a class that has an where \var{y} is an instance of a class that has an
\method{__rsub__()} method, \code{\var{y}.__rsub__(\var{x})} \method{__rsub__()} method, \code{\var{y}.__rsub__(\var{x})}
@ -1998,7 +1998,7 @@ complicated).
\methodline[numeric object]{__idiv__}{self, other} \methodline[numeric object]{__idiv__}{self, other}
\methodline[numeric object]{__itruediv__}{self, other} \methodline[numeric object]{__itruediv__}{self, other}
\methodline[numeric object]{__ifloordiv__}{self, other} \methodline[numeric object]{__ifloordiv__}{self, other}
\methodline[numeric object]{__imod__}{self, other} \methodline[numeric object]{__imod__}{self, other}
\methodline[numeric object]{__ipow__}{self, other\optional{, modulo}} \methodline[numeric object]{__ipow__}{self, other\optional{, modulo}}
\methodline[numeric object]{__ilshift__}{self, other} \methodline[numeric object]{__ilshift__}{self, other}
\methodline[numeric object]{__irshift__}{self, other} \methodline[numeric object]{__irshift__}{self, other}
@ -2228,6 +2228,3 @@ exception; this is the caller's responsibility.
Python \keyword{with} statement.} Python \keyword{with} statement.}
\end{seealso} \end{seealso}