Filled out the "Core Changes" section.

This commit is contained in:
Andrew M. Kuchling 2000-05-31 03:28:42 +00:00
parent d8dfb4c4b8
commit 5b8311e3c1
1 changed files with 74 additions and 17 deletions

View File

@ -118,33 +118,91 @@ formatting precision than \function{str()}. \function{repr()} uses
\function{str()} uses ``%.12g'' as before. The effect is that
\function{repr()} may occasionally show more decimal places than
\function{str()}, for numbers
XXX need example value here.
XXX need example value here to demonstrate problem.
% ======================================================================
\section{Core Changes}
Deleting objects is safe even for deeply nested data structures.
Comparing recursive objects is now safe (doesn't dump core).
Various minor changes have been made to Python's syntax and built-in
functions. None of the changes are very far-reaching, but they're
handy conveniences.
Builds on NT Alpha, and work on Win64 (NT Itanium -- sys.platform is
still 'win32') is ongoing. Supports Windows CE (confirm with Mark
Hammond)
A change to syntax makes it more convenient to call a given function
with a tuple of arguments and/or a dictionary of keyword arguments.
In Python 1.5 and earlier, you do this with the \builtin{apply()}
built-in function: \code{apply(f, \var{args}, \var{kw})} calls the
function \function{f()} with the argument tuple \var{args} and the
keyword arguments in the dictionary \var{kw}. Thanks to a patch from
Greg Ewing, 1.6 adds \code{f(*\var{args}, **\var{kw})} as a shorter
and clearer way to achieve the same effect. This syntax is
symmetrical with the syntax for defining functions:
UnboundLocalError is raised when a local variable is undefined
long, int take optional "base" parameter
\begin{verbatim}
def f(*args, **kw):
# args is a tuple of positional args,
# kw is a dictionary of keyword args
...
\end{verbatim}
string objects now have methods (though they are still immutable)
A new format style is available when using the \operator{\%} operator.
'\%r' will insert the \function{repr()} of its argument. This was
also added from symmetry considerations, this time for symmetry with
the existing '\%s' format style which inserts the \function{str()} of
its argument. For example, \code{'%r %s' % ('abc', 'abc')} returns a
string containing \verb|'abc' abc|.
sys.version_info is a tuple: (major, minor, micro, level, serial); level
is a string "a2", "b1", "c1", or '' for a final release.
The \builtin{int()} and \builtin{long()} functions now accept an
optional ``base'' parameter when the first argument is a string.
\code{int('123', 10)} returns 123, while \code{int('123', 16)} returns
291. \code{int(123, 16)} raises a \exception{TypeError} exception
with the message ``can't convert non-string with explicit base''.
New format style '%r' inserts repr(arg) instead of str(arg).
Previously there was no way to implement a class that overrode
Python's built-in \operator{in} operator and implemented a custom
version. \code{\var{obj} in \var{seq}} returns true if \var{obj} is
present in the sequence \var{seq}; Python computes this by simply
trying every index of the sequence until either \var{obj} is found or
an \exception{IndexError} is encountered. Moshe Zadka contributed a
patch which adds a \method{__contains__} magic method for providing a
custom implementation for \operator{in}.
"in" operator can now be overriden in user-defined classes to mean anything:
it calls the magic method __contains__
Earlier versions of Python used a recursive algorithm for deleting
objects. Deeply nested data structures could cause the interpreter to
fill up the C stack and crash; Christian Tismer rewrote the deletion
logic to fix this problem. On a related note, comparing recursive
objects recursed infinitely and crashed; Jeremy Hylton rewrote the
code to no longer crash, producing a useful result instead. For
example, after this code:
New calling syntax: f(*args, **kw) equivalent to apply(f, args, kw)
\begin{verbatim}
a = []
b = []
a.append(a)
b.append(b)
\end{verbatim}
The comparison \code{a==b} returns true, because the two recursive
data structures are isomorphic.
\footnote{See the thread ``trashcan and PR\#7'' in the April 2000 archives of the python-dev mailing list for the discussion leading up to this implementation, and some useful relevant links.
%http://www.python.org/pipermail/python-dev/2000-April/004834.html
}
Work has been done on porting Python to 64-bit Windows on the Itanium
processor, mostly by Trent Mick of ActiveState. (Confusingly, for
complicated reasons \code{sys.platform} is still \code{'win32'} on
Win64.) PythonWin also supports Windows CE; see the Python CE page at
\url{http://www.python.net/crew/mhammond/ce/} for more information.
XXX UnboundLocalError is raised when a local variable is undefined
A new variable holding more detailed version information has been
added to the \module{sys} module. \code{sys.version_info} is a tuple
\code{(\var{major}, \var{minor}, \var{micro}, \var{level},
\var{serial})} For example, in 1.6a2 \code{sys.version_info} is
\code{(1, 6, 0, 'alpha', 2)}. \var{level} is a string such as
"alpha", "beta", or '' for a final release.
% ======================================================================
\section{Extending/embedding Changes}
@ -152,8 +210,7 @@ New calling syntax: f(*args, **kw) equivalent to apply(f, args, kw)
Some of the changes are under the covers, and will only be apparent to
people writing C extension modules, or embedding a Python interpreter
in a larger application. If you aren't dealing with Python's C API,
you can safely skip this section since it won't contain anything of
interest to you.
you can safely skip this section.
Users of Jim Fulton's ExtensionClass module will be pleased to find
out that hooks have been added so that ExtensionClasses are now