[Python-checkins] r54413 - python/trunk/Doc/ref/ref3.tex
ziga.seilnacht
python-checkins at python.org
Fri Mar 16 13:11:12 CET 2007
Author: ziga.seilnacht
Date: Fri Mar 16 13:11:11 2007
New Revision: 54413
Modified:
python/trunk/Doc/ref/ref3.tex
Log:
Whitespace cleanup. Also remove the empty lines
from the previous check in.
Modified: python/trunk/Doc/ref/ref3.tex
==============================================================================
--- python/trunk/Doc/ref/ref3.tex (original)
+++ python/trunk/Doc/ref/ref3.tex Fri Mar 16 13:11:11 2007
@@ -219,7 +219,7 @@
\indexii{integer}{representation}
\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
C or Java implementation) for the accepted range and handling of overflow.
Python does not support single-precision floating point numbers; the
@@ -471,7 +471,7 @@
\obindex{function}
\obindex{user-defined function}
-Special attributes:
+Special attributes:
\begin{tableiii}{lll}{member}{Attribute}{Meaning}{}
\lineiii{func_doc}{The function's documentation string, or
@@ -861,12 +861,12 @@
\begin{description}
\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}.
The difference between a code
object and a function object is that the function object contains an
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,
not in the code object (because they represent values calculated at
run-time). Unlike function objects, code objects are immutable and
@@ -1070,7 +1070,7 @@
%=========================================================================
\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
user. The concept of (old-style) class is unrelated to the concept of type: if
@@ -1245,7 +1245,7 @@
string object.
If a class defines \method{__repr__()} but not \method{__str__()},
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
representation is information-rich and unambiguous.
@@ -1403,7 +1403,7 @@
dictionary). \var{name} is the attribute name, \var{value} is the
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
would cause a recursive call to itself. Instead, it should insert the
value in the dictionary of instance attributes, e.g.,
@@ -1426,8 +1426,8 @@
\begin{methoddesc}[object]{__getattribute__}{self, name}
Called unconditionally to implement attribute accesses for instances
-of the class. If the class also defines \method{__getattr__()}, the latter
-will not be called unless \method{__getattribute__()} either calls it
+of the class. If the class also defines \method{__getattr__()}, the latter
+will not be called unless \method{__getattribute__()} either calls it
explicitly or raises an \exception{AttributeError}.
This method should return the (computed) attribute
value or raise an \exception{AttributeError} exception.
@@ -1479,7 +1479,7 @@
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
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.
However, if the looked-up value is an object defining one of the descriptor
@@ -1493,14 +1493,14 @@
How the arguments are assembled depends on \code{a}:
\begin{itemize}
-
+
\item[Direct Call] The simplest and least common call is when user code
directly invokes a descriptor method: \code{x.__get__(a)}.
\item[Instance Binding] If binding to a new-style object instance,
\code{a.x} is transformed into the call:
\code{type(a).__dict__['x'].__get__(a, type(a))}.
-
+
\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)}.
@@ -1509,7 +1509,7 @@
\code{obj.__class__.__mro__} for the base class \code{A} immediately
preceding \code{B} and then invokes the descriptor with the call:
\code{A.__dict__['m'].__get__(obj, A)}.
-
+
\end{itemize}
For instance bindings, the precedence of descriptor invocation depends
@@ -1522,7 +1522,7 @@
Python methods (including \function{staticmethod()} and \function{classmethod()})
are implemented as non-data descriptors. Accordingly, instances can
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.
Accordingly, instances cannot override the behavior of a property.
@@ -1540,14 +1540,14 @@
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
each instance.
-
+
\begin{datadesc}{__slots__}
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,
\var{__slots__} reserves space for the declared variables
and prevents the automatic creation of \var{__dict__} and \var{__weakref__}
for each instance.
-\versionadded{2.2}
+\versionadded{2.2}
\end{datadesc}
\noindent
@@ -1559,23 +1559,23 @@
variables not listed in the \var{__slots__} definition. Attempts to assign
to an unlisted variable name raises \exception{AttributeError}. If dynamic
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__}
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
defining \var{__slots__} do not support weak references to its instances.
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__}
-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
descriptors (\ref{descriptors}) for each variable name. As a result,
class attributes cannot be used to set default values for instance
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
variable defined by the base class slot is inaccessible (except by retrieving
@@ -1584,14 +1584,14 @@
\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__}
-unless they also define \var{__slots__}.
+unless they also define \var{__slots__}.
\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__}.
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
same \var{__slots__}.
@@ -1622,7 +1622,7 @@
This variable can be any callable accepting arguments for \code{name},
\code{bases}, and \code{dict}. Upon class creation, the callable is
used instead of the built-in \function{type()}.
-\versionadded{2.2}
+\versionadded{2.2}
\end{datadesc}
The appropriate metaclass is determined by the following precedence rules:
@@ -1639,7 +1639,7 @@
\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
been explored including logging, interface checking, automatic delegation,
@@ -1672,15 +1672,15 @@
that mappings provide the methods \method{keys()}, \method{values()},
\method{items()}, \method{has_key()}, \method{get()}, \method{clear()},
\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
Python's standard dictionary objects. The \module{UserDict} module
provides a \class{DictMixin} class to help create those methods
from a base set of \method{__getitem__()}, \method{__setitem__()},
-\method{__delitem__()}, and \method{keys()}.
+\method{__delitem__()}, and \method{keys()}.
Mutable sequences should provide
methods \method{append()}, \method{count()}, \method{index()},
-\method{extend()},
+\method{extend()},
\method{insert()}, \method{pop()}, \method{remove()}, \method{reverse()}
and \method{sort()}, like Python standard list objects. Finally,
sequence types should implement addition (meaning concatenation) and
@@ -1703,12 +1703,12 @@
\ttindex{items()}
\ttindex{iterkeys()}
\ttindex{itervalues()}
- \ttindex{iteritems()}
+ \ttindex{iteritems()}
\ttindex{has_key()}
\ttindex{get()}
\ttindex{setdefault()}
- \ttindex{pop()}
- \ttindex{popitem()}
+ \ttindex{pop()}
+ \ttindex{popitem()}
\ttindex{clear()}
\ttindex{copy()}
\ttindex{update()}
@@ -1716,7 +1716,7 @@
\withsubitem{(sequence object method)}{
\ttindex{append()}
\ttindex{count()}
- \ttindex{extend()}
+ \ttindex{extend()}
\ttindex{index()}
\ttindex{insert()}
\ttindex{pop()}
@@ -1730,7 +1730,7 @@
\ttindex{__rmul__()}
\ttindex{__imul__()}
\ttindex{__contains__()}
- \ttindex{__iter__()}}
+ \ttindex{__iter__()}}
\withsubitem{(numeric object method)}{\ttindex{__coerce__()}}
\begin{methoddesc}[container object]{__len__}{self}
@@ -1753,7 +1753,7 @@
(after any special interpretation of negative values),
\exception{IndexError} should be raised.
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
\exception{IndexError} will be raised for illegal indexes to allow
proper detection of the end of the sequence.}
@@ -1952,7 +1952,7 @@
\methodline[numeric object]{__rmul__}{self, other}
\methodline[numeric object]{__rdiv__}{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]{__rdivmod__}{self, other}
\methodline[numeric object]{__rpow__}{self, other}
@@ -1973,7 +1973,7 @@
For operands of the same type, it is assumed that if the
non-reflected method (such as \method{__add__()}) fails the
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},
where \var{y} is an instance of a class that has an
\method{__rsub__()} method, \code{\var{y}.__rsub__(\var{x})}
@@ -1998,7 +1998,7 @@
\methodline[numeric object]{__idiv__}{self, other}
\methodline[numeric object]{__itruediv__}{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]{__ilshift__}{self, other}
\methodline[numeric object]{__irshift__}{self, other}
@@ -2228,6 +2228,3 @@
Python \keyword{with} statement.}
\end{seealso}
-
-
-
More information about the Python-checkins
mailing list