Python history -------------- This file contains the release messages for previous Python releases (slightly edited to adapt them to the format of this file). As you read on you go back to the dark ages of Python's history. =================================== ==> Release 1.1.1 (10 Nov 1994) <== =================================== This is a pure bugfix release again. See the ChangeLog file for details. One exception: a few new features were added to tkinter. ================================= ==> Release 1.1 (11 Oct 1994) <== ================================= This release adds several new features, improved configuration and portability, and fixes more bugs than I can list here (including some memory leaks). The source compiles and runs out of the box on more platforms than ever -- including Windows NT. Makefiles or projects for a variety of non-UNIX platforms are provided. APOLOGY: some new features are badly documented or not at all. I had the choice -- postpone the new release indefinitely, or release it now, with working code but some undocumented areas. The problem with postponing the release is that people continue to suffer from existing bugs, and send me patches based on the previous release -- which I can't apply directly because my own source has changed. Also, some new modules (like signal) have been ready for release for quite some time, and people are anxiously waiting for them. In the case of signal, the interface is simple enough to figure out without documentation (if you're anxious enough :-). In this case it was not simple to release the module on its own, since it relies on many small patches elsewhere in the source. For most new Python modules, the source code contains comments that explain how to use them. Documentation for the Tk interface, written by Matt Conway, is available as tkinter-doc.tar.gz from the Python home and mirror ftp sites (see Misc/FAQ for ftp addresses). For the new operator overloading facilities, have a look at Demo/classes: Complex.py and Rat.py show how to implement a numeric type without and with __coerce__ method. Also have a look at the end of the Tutorial document (Doc/tut.tex). If you're still confused: use the newsgroup or mailing list. New language features: - More flexible operator overloading for user-defined classes (INCOMPATIBLE WITH PREVIOUS VERSIONS!) See end of tutorial. - Classes can define methods named __getattr__, __setattr__ and __delattr__ to trap attribute accesses. See end of tutorial. - Classes can define method __call__ so instances can be called directly. See end of tutorial. New support facilities: - The Makefiles (for the base interpreter as well as for extensions) now support creating dynamically loadable modules if the platform supports shared libraries. - Passing the interpreter a .pyc file as script argument will execute the code in that file. (On the Mac such files can be double-clicked!) - New Freeze script, to create independently distributable "binaries" of Python programs -- look in Demo/freeze - Improved h2py script (in Demo/scripts) follows #includes and supports macros with one argument - New module compileall generates .pyc files for all modules in a directory (tree) without also executing them - Threads should work on more platforms New built-in modules: - tkinter (support for Tcl's Tk widget set) is now part of the base distribution - signal allows catching or ignoring UNIX signals (unfortunately still undocumented -- any taker?) - termios provides portable access to POSIX tty settings - curses provides an interface to the System V curses library - syslog provides an interface to the (BSD?) syslog daemon - 'new' provides interfaces to create new built-in object types (e.g. modules and functions) - sybase provides an interface to SYBASE database New/obsolete built-in methods: - callable(x) tests whether x can be called - sockets now have a setblocking() method - sockets no longer have an allowbroadcast() method - socket methods send() and sendto() return byte count New standard library modules: - types.py defines standard names for built-in types, e.g. StringType - urlparse.py parses URLs according to the latest Internet draft - uu.py does uuencode/uudecode (not the fastest in the world, but quicker than installing uuencode on a non-UNIX machine :-) - New, faster and more powerful profile module.py - mhlib.py provides interface to MH folders and messages New facilities for extension writers (unfortunately still undocumented): - newgetargs() supports optional arguments and improved error messages - O!, O& O? formats for getargs allow more versatile type checking of non-standard types - can register pending asynchronous callback, to be called the next time the Python VM begins a new instruction (Py_AddPendingCall) - can register cleanup routines to be called when Python exits (Py_AtExit) - makesetup script understands C++ files in Setup file (use file.C or file.cc) - Make variable OPT is passed on to sub-Makefiles - An init() routine may signal an error by not entering the module in the module table and raising an exception instead - For long module names, instead of foobarbletchmodule.c you can use foobarbletch.c - getintvalue() and getfloatvalue() try to convert any object instead of requiring an "intobject" or "floatobject" - All the [new]getargs() formats that retrieve an integer value will now also work if a float is passed - C function listtuple() converts list to tuple, fast - You should now call sigcheck() instead of intrcheck(); sigcheck() also sets an exception when it returns nonzero ==================================== ==> Release 1.0.3 (14 July 1994) <== ==================================== This release consists entirely of bug fixes to the C sources; see the head of ../ChangeLog for a complete list. Most important bugs fixed: - Sometimes the format operator (string%expr) would drop the last character of the format string - Tokenizer looped when last line did not end in \n - Bug when triple-quoted string ended in quote plus newline - Typo in socketmodule (listen) (== instead of =) - typing vars() at the >>> prompt would cause recursive output ================================== ==> Release 1.0.2 (4 May 1994) <== ================================== Overview of the most visible changes. Bug fixes are not listed. See also ChangeLog. Tokens ------ * String literals follow Standard C rules: they may be continued on the next line using a backslash; adjacent literals are concatenated at compile time. * A new kind of string literals, surrounded by triple quotes (""" or '''), can be continued on the next line without a backslash. Syntax ------ * Function arguments may have a default value, e.g. def f(a, b=1); defaults are evaluated at function definition time. This also applies to lambda. * The try-except statement has an optional else clause, which is executed when no exception occurs in the try clause. Interpreter ----------- * The result of a statement-level expression is no longer printed, except_ for expressions entered interactively. Consequently, the -k command line option is gone. * The result of the last printed interactive expression is assigned to the variable '_'. * Access to implicit global variables has been speeded up by removing an always-failing dictionary lookup in the dictionary of local variables (mod suggested by Steve Makewski and Tim Peters). * There is a new command line option, -u, to force stdout and stderr to be unbuffered. * Incorporated Steve Majewski's mods to import.c for dynamic loading under AIX. * Fewer chances of dumping core when trying to reload or re-import static built-in, dynamically loaded built-in, or frozen modules. * Loops over sequences now don't ask for the sequence's length when they start, but try to access items 0, 1, 2, and so on until they hit an IndexError. This makes it possible to create classes that generate infinite or indefinite sequences a la Steve Majewski. This affects for loops, the (not) in operator, and the built-in functions filter(), map(), max(), min(), reduce(). Changed Built-in operations --------------------------- * The '%' operator on strings (printf-style formatting) supports a new feature (adapted from a patch by Donald Beaudry) to allow '%()' % {...} to take values from a dictionary by name instead of from a tuple by position (see also the new function vars()). * The '%s' formatting operator is changed to accept any type and convert it to a string using str(). * Dictionaries with more than 20,000 entries can now be created (thanks to Steve Kirsch). New Built-in Functions ---------------------- * vars() returns a dictionary containing the local variables; vars(m) returns a dictionary containing the variables of module m. Note: dir(x) is now equivalent to vars(x).keys(). Changed Built-in Functions -------------------------- * open() has an optional third argument to specify the buffer size: 0 for unbuffered, 1 for line buffered, >1 for explicit buffer size, <0 for default. * open()'s second argument is now optional; it defaults to "r". * apply() now checks that its second argument is indeed a tuple. New Built-in Modules -------------------- Changed Built-in Modules ------------------------ The thread module no longer supports exit_prog(). New Python Modules ------------------ * Module addpack contains a standard interface to modify sys.path to find optional packages (groups of related modules). * Module urllib contains a number of functions to access World-Wide-Web files specified by their URL. * Module httplib implements the client side of the HTTP protocol used by World-Wide-Web servers. * Module gopherlib implements the client side of the Gopher protocol. * Module mailbox (by Jack Jansen) contains a parser for UNIX and MMDF style mailbox files. * Module random contains various random distributions, e.g. gauss(). * Module lockfile locks and unlocks open files using fcntl (inspired by a similar module by Andy Bensky). * Module ntpath (by Jaap Vermeulen) implements path operations for Windows/NT. * Module test_thread (in Lib/test) contains a small test set for the thread module. Changed Python Modules ---------------------- * The string module's expandvars() function is now documented and is implemented in Python (using regular expressions) instead of forking off a shell process. * Module rfc822 now supports accessing the header fields using the mapping/dictionary interface, e.g. h['subject']. * Module pdb now makes it possible to set a break on a function (syntax: break , where yields a function object). Changed Demos ------------- * The Demo/scripts/freeze.py script is working again (thanks to Jaap Vermeulen). New Demos --------- * Demo/threads/Generator.py is a proposed interface for restartable functions a la Tim Peters. * Demo/scripts/newslist.py, by Quentin Stafford-Fraser, generates a directory full of HTML pages which between them contain links to all the newsgroups available on your server. * Demo/dns contains a DNS (Domain Name Server) client. * Demo/lutz contains miscellaneous demos by Mark Lutz (e.g. psh.py, a nice enhanced Python shell!!!). * Demo/turing contains a Turing machine by Amrit Prem. Documentation ------------- * Documented new language features mentioned above (but not all new modules). * Added a chapter to the Tutorial describing recent additions to Python. * Clarified some sentences in the reference manual, e.g. break/continue, local/global scope, slice assignment. Source Structure ---------------- * Moved Include/tokenizer.h to Parser/tokenizer.h. * Added Python/getopt.c for systems that don't have it. Emacs mode ---------- * Indentation of continuated lines is done more intelligently; consequently the variable py-continuation-offset is gone. ======================================== ==> Release 1.0.1 (15 February 1994) <== ======================================== * Many portability fixes should make it painless to build Python on several new platforms, e.g. NeXT, SEQUENT, WATCOM, DOS, and Windows. * Fixed test for -- this broke on some platforms. * Fixed test for shared library dynalic loading -- this broke on SunOS 4.x using the GNU loader. * Changed order and number of SVR4 networking libraries (it is now -lsocket -linet -lnsl, if these libraries exist). * Installing the build intermediate stages with "make libainstall" now also installs config.c.in, Setup and makesetup, which are used by the new Extensions mechanism. * Improved README file contains more hints and new troubleshooting section. * The built-in module strop now defines fast versions of three more functions of the standard string module: atoi(), atol() and atof(). The strop versions of atoi() and atol() support an optional second argument to specify the base (default 10). NOTE: you don't have to explicitly import strop to use the faster versions -- the string module contains code to let versions from stop override the default versions. * There is now a working Lib/dospath.py for those who use Python under DOS (or Windows). Thanks, Jaap! * There is now a working Modules/dosmodule.c for DOS (or Windows) system calls. * Lib.os.py has been reorganized (making it ready for more operating systems). * Lib/ospath.py is now obsolete (use os.path instead). * Many fixes to the tutorial to make it match Python 1.0. Thanks, Tim! * Fixed Doc/Makefile, Doc/README and various scripts there. * Added missing description of fdopen to Doc/libposix.tex. * Made cleanup() global, for the benefit of embedded applications. * Added parsing of addresses and dates to Lib/rfc822.py. * Small fixes to Lib/aifc.py, Lib/sunau.py, Lib/tzparse.py to make them usable at all. * New module Lib/wave.py reads RIFF (*.wav) audio files. * Module Lib/filewin.py moved to Lib/stdwin/filewin.py where it belongs. * New options and comments for Modules/makesetup (used by new Extension mechanism). * Misc/HYPE contains text of announcement of 1.0.0 in comp.lang.misc and elsewhere. * Fixed coredump in filter(None, 'abcdefg'). ======================================= ==> Release 1.0.0 (26 January 1994) <== ======================================= As is traditional, so many things have changed that I can't pretend to be complete in these release notes, but I'll try anyway :-) Note that the very last section is labeled "remaining bugs". Source organization and build process ------------------------------------- * The sources have finally been split: instead of a single src subdirectory there are now separate directories Include, Parser, Grammar, Objects, Python and Modules. Other directories also start with a capital letter: Misc, Doc, Lib, Demo. * A few extensions (notably Amoeba and X support) have been moved to a separate subtree Extensions, which is no longer in the core distribution, but separately ftp'able as extensions.tar.Z. (The distribution contains a placeholder Ext-dummy with a description of the Extensions subtree as well as the most recent versions of the scripts used there.) * A few large specialized demos (SGI video and www) have been moved to a separate subdirectory Demo2, which is no longer in the core distribution, but separately ftp'able as demo2.tar.Z. * Parts of the standard library have been moved to subdirectories: there are now standard subdirectories stdwin, test, sgi and sun4. * The configuration process has radically changed: I now use GNU autoconf. This makes it much easier to build on new Unix flavors, as well as fully supporting VPATH (if your Make has it). The scripts Configure.py and Addmodule.sh are no longer needed. Many source files have been adapted in order to work with the symbols that the configure script generated by autoconf defines (or not); the resulting source is much more portable to different C compilers and operating systems, even non Unix systems (a Mac port was done in an afternoon). See the toplevel README file for a description of the new build process. * GNU readline (a slightly newer version) is now a subdirectory of the Python toplevel. It is still not automatically configured (being totally autoconf-unaware :-). One problem has been solved: typing Control-C to a readline prompt will now work. The distribution no longer contains a "super-level" directory (above the python toplevel directory), and dl, dl-dld and GNU dld are no longer part of the Python distribution (you can still ftp them from ftp.cwi.nl:/pub/dynload). * The DOS functions have been taken out of posixmodule.c and moved into a separate file dosmodule.c. * There's now a separate file version.c which contains nothing but the version number. * The actual main program is now contained in config.c (unless NO_MAIN is defined); pythonmain.c now contains a function realmain() which is called from config.c's main(). * All files needed to use the built-in module md5 are now contained in the distribution. The module has been cleaned up considerably. Documentation ------------- * The library manual has been split into many more small latex files, so it is easier to edit Doc/lib.tex file to create a custom library manual, describing only those modules supported on your system. (This is not automated though.) * A fourth manual has been added, titled "Extending and Embedding the Python Interpreter" (Doc/ext.tex), which collects information about the interpreter which was previously spread over several files in the misc subdirectory. * The entire documentation is now also available on-line for those who have a WWW browser (e.g. NCSA Mosaic). Point your browser to the URL "http://www.cwi.nl/~guido/Python.html". Syntax ------ * Strings may now be enclosed in double quotes as well as in single quotes. There is no difference in interpretation. The repr() of string objects will use double quotes if the string contains a single quote and no double quotes. Thanks to Amrit Prem for these changes! * There is a new keyword 'exec'. This replaces the exec() built-in function. If a function contains an exec statement, local variable optimization is not performed for that particular function, thus making assignment to local variables in exec statements less confusing. (As a consequence, os.exec and python.exec have been renamed to execv.) * There is a new keyword 'lambda'. An expression of the form lambda : yields an anonymous function. This is really only syntactic sugar; you can just as well define a local function using def some_temporary_name(): return Lambda expressions are particularly useful in combination with map(), filter() and reduce(), described below. Thanks to Amrit Prem for submitting this code (as well as map(), filter(), reduce() and xrange())! Built-in functions ------------------ * The built-in module containing the built-in functions is called __builtin__ instead of builtin. * New built-in functions map(), filter() and reduce() perform standard functional programming operations (though not lazily): - map(f, seq) returns a new sequence whose items are the items from seq with f() applied to them. - filter(f, seq) returns a subsequence of seq consisting of those items for which f() is true. - reduce(f, seq, initial) returns a value computed as follows: acc = initial for item in seq: acc = f(acc, item) return acc * New function xrange() creates a "range object". Its arguments are the same as those of range(), and when used in a for loop a range objects also behaves identical. The advantage of xrange() over range() is that its representation (if the range contains many elements) is much more compact than that of range(). The disadvantage is that the result cannot be used to initialize a list object or for the "Python idiom" [RED, GREEN, BLUE] = range(3). On some modern architectures, benchmarks have shown that "for i in range(...): ..." actually executes *faster* than "for i in xrange(...): ...", but on memory starved machines like PCs running DOS range(100000) may be just too big to be represented at all... * Built-in function exec() has been replaced by the exec statement -- see above. The interpreter --------------- * Syntax errors are now not printed to stderr by the parser, but rather the offending line and other relevant information are packed up in the SyntaxError exception argument. When the main loop catches a SyntaxError exception it will print the error in the same format as previously, but at the proper position in the stack traceback. * You can now set a maximum to the number of traceback entries printed by assigning to sys.tracebacklimit. The default is 1000. * The version number in .pyc files has changed yet again. * It is now possible to have a .pyc file without a corresponding .py file. (Warning: this may break existing installations if you have an old .pyc file lingering around somewhere on your module search path without a corresponding .py file, when there is a .py file for a module of the same name further down the path -- the new interpreter will find the first .pyc file and complain about it, while the old interpreter would ignore it and use the .py file further down.) * The list sys.builtin_module_names is now sorted and also contains the names of a few hardwired built-in modules (sys, __main__ and __builtin__). * A module can now find its own name by accessing the global variable __name__. Assigning to this variable essentially renames the module (it should also be stored under a different key in sys.modules). A neat hack follows from this: a module that wants to execute a main program when called as a script no longer needs to compare sys.argv[0]; it can simply do "if __name__ == '__main__': main()". * When an object is printed by the print statement, its implementation of str() is used. This means that classes can define __str__(self) to direct how their instances are printed. This is different from __repr__(self), which should define an unambigous string representation of the instance. (If __str__() is not defined, it defaults to __repr__().) * Functions and code objects can now be compared meaningfully. * On systems supporting SunOS or SVR4 style shared libraries, dynamic loading of modules using shared libraries is automatically configured. Thanks to Bill Jansen and Denis Severson for contributing this change! Built-in objects ---------------- * File objects have acquired a new method writelines() which is the reverse of readlines(). (It does not actually write lines, just a list of strings, but the symmetry makes the choice of name OK.) Built-in modules ---------------- * Socket objects no longer support the avail() method. Use the select module instead, or use this function to replace it: def avail(f): import select return f in select.select([f], [], [], 0)[0] * Initialization of stdwin is done differently. It actually modifies sys.argv (taking out the options the X version of stdwin recognizes) the first time it is imported. * A new built-in module parser provides a rudimentary interface to the python parser. Corresponding standard library modules token and symbol defines the numeric values of tokens and non-terminal symbols. * The posix module has aquired new functions setuid(), setgid(), execve(), and exec() has been renamed to execv(). * The array module is extended with 8-byte object swaps, the 'i' format character, and a reverse() method. The read() and write() methods are renamed to fromfile() and tofile(). * The rotor module has freed of portability bugs. This introduces a backward compatibility problem: strings encoded with the old rotor module can't be decoded by the new version. * For select.select(), a timeout (4th) argument of None means the same as leaving the timeout argument out. * Module strop (and hence standard library module string) has aquired a new function: rindex(). Thanks to Amrit Prem! * Module regex defines a new function symcomp() which uses an extended regular expression syntax: parenthesized subexpressions may be labeled using the form "\(...\)", and the group() method can return sub-expressions by name. Thanks to Tracy Tims for these changes! * Multiple threads are now supported on Solaris 2. Thanks to Sjoerd Mullender! Standard library modules ------------------------ * The library is now split in several subdirectories: all stuff using stdwin is in Lib/stdwin, all SGI specific (or SGI Indigo or GL) stuff is in Lib/sgi, all Sun Sparc specific stuff is in Lib/sun4, and all test modules are in Lib/test. The default module search path will include all relevant subdirectories by default. * Module os now knows about trying to import dos. It defines functions execl(), execle(), execlp() and execvp(). * New module dospath (should be attacked by a DOS hacker though). * All modules defining classes now define __init__() constructors instead of init() methods. THIS IS AN INCOMPATIBLE CHANGE! * Some minor changes and bugfixes module ftplib (mostly Steve Majewski's suggestions); the debug() method is renamed to set_debuglevel(). * Some new test modules (not run automatically by testall though): test_audioop, test_md5, test_rgbimg, test_select. * Module string now defines rindex() and rfind() in analogy of index() and find(). It also defines atof() and atol() (and corresponding exceptions) in analogy to atoi(). * Added help() functions to modules profile and pdb. * The wdb debugger (now in Lib/stdwin) now shows class or instance variables on a double click. Thanks to Sjoerd Mullender! * The (undocumented) module lambda has gone -- you couldn't import it any more, and it was basically more a demo than a library module... Multimedia extensions --------------------- * The optional built-in modules audioop and imageop are now standard parts of the interpreter. Thanks to Sjoerd Mullender and Jack Jansen for contributing this code! * There's a new operation in audioop: minmax(). * There's a new built-in module called rgbimg which supports portable efficient reading of SGI RCG image files. Thanks also to Paul Haeberli for the original code! (Who will contribute a GIF reader?) * The module aifc is gone -- you should now always use aifc, which has received a facelift. * There's a new module sunau., for reading Sun (and NeXT) audio files. * There's a new module audiodev which provides a uniform interface to (SGI Indigo and Sun Sparc) audio hardware. * There's a new module sndhdr which recognizes various sound files by looking in their header and checking for various magic words. Optimizations ------------- * Most optimizations below can be configured by compile-time flags. Thanks to Sjoerd Mullender for submitting these optimizations! * Small integers (default -1..99) are shared -- i.e. if two different functions compute the same value it is possible (but not guaranteed!!!) that they return the same *object*. Python programs can detect this but should *never* rely on it. * Empty tuples (which all compare equal) are shared in the same manner. * Tuples of size up to 20 (default) are put in separate free lists when deallocated. * There is a compile-time option to cache a string's hash function, but this appeared to have a negligeable effect, and as it costs 4 bytes per string it is disabled by default. Embedding Python ---------------- * The initialization interface has been simplified somewhat. You now only call "initall()" to initialize the interpreter. * The previously announced renaming of externally visible identifiers has not been carried out. It will happen in a later release. Sorry. Miscellaneous bugs that have been fixed --------------------------------------- * All known portability bugs. * Version 0.9.9 dumped core in .sort() which has been fixed. Thanks to Jaap Vermeulen for fixing this and posting the fix on the mailing list while I was away! * Core dump on a format string ending in '%', e.g. in the expression '%' % None. * The array module yielded a bogus result for concatenation (a+b would yield a+a). * Some serious memory leaks in strop.split() and strop.splitfields(). * Several problems with the nis module. * Subtle problem when copying a class method from another class through assignment (the method could not be called). Remaining bugs -------------- * One problem with 64-bit machines remains -- since .pyc files are portable and use only 4 bytes to represent an integer object, 64-bit integer literals are silently truncated when written into a .pyc file. Work-around: use eval('123456789101112'). * The freeze script doesn't work any more. A new and more portable one can probably be cooked up using tricks from Extensions/mkext.py. * The dos support hasn't been tested yet. (Really Soon Now we should have a PC with a working C compiler!) =================================== ==> Release 0.9.9 (29 Jul 1993) <== =================================== I *believe* these are the main user-visible changes in this release, but there may be others. SGI users may scan the {src,lib}/ChangeLog files for improvements of some SGI specific modules, e.g. aifc and cl. Developers of extension modules should also read src/ChangeLog. Naming of C symbols used by the Python interpreter -------------------------------------------------- * This is the last release using the current naming conventions. New naming conventions are explained in the file misc/NAMING. Summarizing, all externally visible symbols get (at least) a "Py" prefix, and most functions are renamed to the standard form PyModule_FunctionName. * Writers of extensions are urged to start using the new naming conventions. The next release will use the new naming conventions throughout (it will also have a different source directory structure). * As a result of the preliminary work for the great renaming, many functions that were accidentally global have been made static. BETA X11 support ---------------- * There are now modules interfacing to the X11 Toolkit Intrinsics, the Athena widgets, and the Motif 1.1 widget set. These are not yet documented except through the examples and README file in the demo/x11 directory. It is expected that this interface will be replaced by a more powerful and correct one in the future, which may or may not be backward compatible. In other words, this part of the code is at most BETA level software! (Note: the rest of Python is rock solid as ever!) * I understand that the above may be a bit of a disappointment, however my current schedule does not allow me to change this situation before putting the release out of the door. By releasing it undocumented and buggy, at least some of the (working!) demo programs, like itr (my Internet Talk Radio browser) become available to a larger audience. * There are also modules interfacing to SGI's "Glx" widget (a GL window wrapped in a widget) and to NCSA's "HTML" widget (which can format HyperText Markup Language, the document format used by the World Wide Web). * I've experienced some problems when building the X11 support. In particular, the Xm and Xaw widget sets don't go together, and it appears that using X11R5 is better than using X11R4. Also the threads module and its link time options may spoil things. My own strategy is to build two Python binaries: one for use with X11 and one without it, which can contain a richer set of built-in modules. Don't even *think* of loading the X11 modules dynamically... Environmental changes --------------------- * Compiled files (*.pyc files) created by this Python version are incompatible with those created by the previous version. Both versions detect this and silently create a correct version, but it means that it is not a good idea to use the same library directory for an old and a new interpreter, since they will start to "fight" over the *.pyc files... * When a stack trace is printed, the exception is printed last instead of first. This means that if the beginning of the stack trace scrolled out of your window you can still see what exception caused it. * Sometimes interrupting a Python operation does not work because it hangs in a blocking system call. You can now kill the interpreter by interrupting it three times. The second time you interrupt it, a message will be printed telling you that the third interrupt will kill the interpreter. The "sys.exitfunc" feature still makes limited clean-up possible in this case. Changes to the command line interface ------------------------------------- * The python usage message is now much more informative. * New option -i enters interactive mode after executing a script -- useful for debugging. * New option -k raises an exception when an expression statement yields a value other than None. * For each option there is now also a corresponding environment variable. Using Python as an embedded language ------------------------------------ * The distribution now contains (some) documentation on the use of Python as an "embedded language" in other applications, as well as a simple example. See the file misc/EMBEDDING and the directory embed/. Speed improvements ------------------ * Function local variables are now generally stored in an array and accessed using an integer indexing operation, instead of through a dictionary lookup. (This compensates the somewhat slower dictionary lookup caused by the generalization of the dictionary module.) Changes to the syntax --------------------- * Continuation lines can now *sometimes* be written without a backslash: if the continuation is contained within nesting (), [] or {} brackets the \ may be omitted. There's a much improved python-mode.el in the misc directory which knows about this as well. * You can no longer use an empty set of parentheses to define a class without base classes. That is, you no longer write this: class Foo(): # syntax error ... You must write this instead: class Foo: ... This was already the preferred syntax in release 0.9.8 but many people seemed not to have picked it up. There's a Python script that fixes old code: demo/scripts/classfix.py. * There's a new reserved word: "access". The syntax and semantics are still subject of of research and debate (as well as undocumented), but the parser knows about the keyword so you must not use it as a variable, function, or attribute name. Changes to the semantics of the language proper ----------------------------------------------- * The following compatibility hack is removed: if a function was defined with two or more arguments, and called with a single argument that was a tuple with just as many arguments, the items of this tuple would be used as the arguments. This is no longer supported. Changes to the semantics of classes and instances ------------------------------------------------- * Class variables are now also accessible as instance variables for reading (assignment creates an instance variable which overrides the class variable of the same name though). * If a class attribute is a user-defined function, a new kind of object is returned: an "unbound method". This contains a pointer to the class and can only be called with a first argument which is a member of that class (or a derived class). * If a class defines a method __init__(self, arg1, ...) then this method is called when a class instance is created by the classname() construct. Arguments passed to classname() are passed to the __init__() method. The __init__() methods of base classes are not automatically called; the derived __init__() method must call these if necessary (this was done so the derived __init__() method can choose the call order and arguments for the base __init__() methods). * If a class defines a method __del__(self) then this method is called when an instance of the class is about to be destroyed. This makes it possible to implement clean-up of external resources attached to the instance. As with __init__(), the __del__() methods of base classes are not automatically called. If __del__ manages to store a reference to the object somewhere, its destruction is postponed; when the object is again about to be destroyed its __del__() method will be called again. * Classes may define a method __hash__(self) to allow their instances to be used as dictionary keys. This must return a 32-bit integer. Minor improvements ------------------ * Function and class objects now know their name (the name given in the 'def' or 'class' statement that created them). * Class instances now know their class name. Additions to built-in operations -------------------------------- * The % operator with a string left argument implements formatting similar to sprintf() in C. The right argument is either a single value or a tuple of values. All features of Standard C sprintf() are supported except %p. * Dictionaries now support almost any key type, instead of just strings. (The key type must be an immutable type or must be a class instance where the class defines a method __hash__(), in order to avoid losing track of keys whose value may change.) * Built-in methods are now compared properly: when comparing x.meth1 and y.meth2, if x is equal to y and the methods are defined by the same function, x.meth1 compares equal to y.meth2. Additions to built-in functions ------------------------------- * str(x) returns a string version of its argument. If the argument is a string it is returned unchanged, otherwise it returns `x`. * repr(x) returns the same as `x`. (Some users found it easier to have this as a function.) * round(x) returns the floating point number x rounded to an whole number, represented as a floating point number. round(x, n) returns x rounded to n digits. * hasattr(x, name) returns true when x has an attribute with the given name. * hash(x) returns a hash code (32-bit integer) of an arbitrary immutable object's value. * id(x) returns a unique identifier (32-bit integer) of an arbitrary object. * compile() compiles a string to a Python code object. * exec() and eval() now support execution of code objects. Changes to the documented part of the library (standard modules) ---------------------------------------------------------------- * os.path.normpath() (a.k.a. posixpath.normpath()) has been fixed so the border case '/foo/..' returns '/' instead of ''. * A new function string.find() is added with similar semantics to string.index(); however when it does not find the given substring it returns -1 instead of raising string.index_error. Changes to built-in modules --------------------------- * New optional module 'array' implements operations on sequences of integers or floating point numbers of a particular size. This is useful to manipulate large numerical arrays or to read and write binary files consisting of numerical data. * Regular expression objects created by module regex now support a new method named group(), which returns one or more \(...\) groups by number. The number of groups is increased from 10 to 100. * Function compile() in module regex now supports an optional mapping argument; a variable casefold is added to the module which can be used as a standard uppercase to lowercase mapping. * Module time now supports many routines that are defined in the Standard C time interface (): gmtime(), localtime(), asctime(), ctime(), mktime(), as well as these variables (taken from System V): timezone, altzone, daylight and tzname. (The corresponding functions in the undocumented module calendar have been removed; the undocumented and unfinished module tzparse is now obsolete and will disappear in a future release.) * Module strop (the fast built-in version of standard module string) now uses C's definition of whitespace instead of fixing it to space, tab and newline; in practice this usually means that vertical tab, form feed and return are now also considered whitespace. It exports the string of characters that are considered whitespace as well as the characters that are considered lowercase or uppercase. * Module sys now defines the variable builtin_module_names, a list of names of modules built into the current interpreter (including not yet imported, but excluding two special modules that always have to be defined -- sys and builtin). * Objects created by module sunaudiodev now also support flush() and close() methods. * Socket objects created by module socket now support an optional flags argument for their methods sendto() and recvfrom(). * Module marshal now supports dumping to and loading from strings, through the functions dumps() and loads(). * Module stdwin now supports some new functionality. You may have to ftp the latest version: ftp.cwi.nl:/pub/stdwin/stdwinforviews.tar.Z.) Bugs fixed ---------- * Fixed comparison of negative long integers. * The tokenizer no longer botches input lines longer than BUFSIZ. * Fixed several severe memory leaks in module select. * Fixed memory leaks in modules socket and sv. * Fixed memory leak in divmod() for long integers. * Problems with definition of floatsleep() on Suns fixed. * Many portability bugs fixed (and undoubtedly new ones added :-). Changes to the build procedure ------------------------------ * The Makefile supports some new targets: "make default" and "make all". Both are by normally equivalent to "make python". * The Makefile no longer uses $> since it's not supported by all versions of Make. * The header files now all contain #ifdef constructs designed to make it safe to include the same header file twice, as well as support for inclusion from C++ programs (automatic extern "C" { ... } added). Freezing Python scripts ----------------------- * There is now some support for "freezing" a Python script as a stand-alone executable binary file. See the script demo/scripts/freeze.py. It will require some site-specific tailoring of the script to get this working, but is quite worthwhile if you write Python code for other who may not have built and installed Python. MS-DOS ------ * A new MS-DOS port has been done, using MSC 6.0 (I believe). Thanks, Marcel van der Peijl! This requires fewer compatibility hacks in posixmodule.c. The executable is not yet available but will be soon (check the mailing list). * The default PYTHONPATH has changed. Changes for developers of extension modules ------------------------------------------- * Read src/ChangeLog for full details. SGI specific changes -------------------- * Read src/ChangeLog for full details. ================================== ==> Release 0.9.8 (9 Jan 1993) <== ================================== I claim no completeness here, but I've tried my best to scan the log files throughout my source tree for interesting bits of news. A more complete account of the changes is to be found in the various ChangeLog files. See also "News for release 0.9.7beta" below if you're still using release 0.9.6, and the file HISTORY if you have an even older release. --Guido Changes to the language proper ------------------------------ There's only one big change: the conformance checking for function argument lists (of user-defined functions only) is stricter. Earlier, you could get away with the following: (a) define a function of one argument and call it with any number of arguments; if the actual argument count wasn't one, the function would receive a tuple containing the arguments arguments (an empty tuple if there were none). (b) define a function of two arguments, and call it with more than two arguments; if there were more than two arguments, the second argument would be passed as a tuple containing the second and further actual arguments. (Note that an argument (formal or actual) that is a tuple is counted as one; these rules don't apply inside such tuples, only at the top level of the argument list.) Case (a) was needed to accommodate variable-length argument lists; there is now an explicit "varargs" feature (precede the last argument with a '*'). Case (b) was needed for compatibility with old class definitions: up to release 0.9.4 a method with more than one argument had to be declared as "def meth(self, (arg1, arg2, ...)): ...". Version 0.9.6 provide better ways to handle both casees, bot provided backward compatibility; version 0.9.8 retracts the compatibility hacks since they also cause confusing behavior if a function is called with the wrong number of arguments. There's a script that helps converting classes that still rely on (b), provided their methods' first argument is called "self": demo/scripts/methfix.py. If this change breaks lots of code you have developed locally, try #defining COMPAT_HACKS in ceval.c. (There's a third compatibility hack, which is the reverse of (a): if a function is defined with two or more arguments, and called with a single argument that is a tuple with just as many arguments, the items of this tuple will be used as the arguments. Although this can (and should!) be done using the built-in function apply() instead, it isn't withdrawn yet.) One minor change: comparing instance methods works like expected, so that if x is an instance of a user-defined class and has a method m, then (x.m==x.m) yields 1. The following was already present in 0.9.7beta, but not explicitly mentioned in the NEWS file: user-defined classes can now define types that behave in almost allrespects like numbers. See demo/classes/Rat.py for a simple example. Changes to the build process ---------------------------- The Configure.py script and the Makefile has been made somewhat more bullet-proof, after reports of (minor) trouble on certain platforms. There is now a script to patch Makefile and config.c to add a new optional built-in module: Addmodule.sh. Read the script before using! Useing Addmodule.sh, all optional modules can now be configured at compile time using Configure.py, so there are no modules left that require dynamic loading. The Makefile has been fixed to make it easier to use with the VPATH feature of some Make versions (e.g. SunOS). Changes affecting portability ----------------------------- Several minor portability problems have been solved, e.g. "malloc.h" has been renamed to "mymalloc.h", "strdup.c" is no longer used, and the system now tolerates malloc(0) returning 0. For dynamic loading on the SGI, Jack Jansen's dl 1.6 is now distributed with Python. This solves several minor problems, in particular scripts invoked using #! can now use dynamic loading. Changes to the interpreter interface ------------------------------------ On popular demand, there's finally a "profile" feature for interactive use of the interpreter. If the environment variable $PYTHONSTARTUP is set to the name of an existing file, Python statements in this file are executed when the interpreter is started in interactive mode. There is a new clean-up mechanism, complementing try...finally: if you assign a function object to sys.exitfunc, it will be called when Python exits or receives a SIGTERM or SIGHUP signal. The interpreter is now generally assumed to live in /usr/local/bin/python (as opposed to /usr/local/python). The script demo/scripts/fixps.py will update old scripts in place (you can easily modify it to do other similar changes). Most I/O that uses sys.stdin/stdout/stderr will now use any object assigned to those names as long as the object supports readline() or write() methods. The parser stack has been increased to 500 to accommodate more complicated expressions (7 levels used to be the practical maximum, it's now about 38). The limit on the size of the *run-time* stack has completely been removed -- this means that tuple or list displays can contain any number of elements (formerly more than 50 would crash the interpreter). Changes to existing built-in functions and methods -------------------------------------------------- The built-in functions int(), long(), float(), oct() and hex() now also apply to class instalces that define corresponding methods (__int__ etc.). New built-in functions ---------------------- The new functions str() and repr() convert any object to a string. The function repr(x) is in all respects equivalent to `x` -- some people prefer a function for this. The function str(x) does the same except if x is already a string -- then it returns x unchanged (repr(x) adds quotes and escapes "funny" characters as octal escapes). The new function cmp(x, y) returns -1 if xy. Changes to general built-in modules ----------------------------------- The time module's functions are more general: time() returns a floating point number and sleep() accepts one. Their accuracies depends on the precision of the system clock. Millisleep is no longer needed (although it still exists for now), but millitimer is still needed since on some systems wall clock time is only available with seconds precision, while a source of more precise time exists that isn't synchronized with the wall clock. (On UNIX systems that support the BSD gettimeofday() function, time.time() is as time.millitimer().) The string representation of a file object now includes an address: '' where ###### is a hex number (the object's address) to make it unique. New functions added to posix: nice(), setpgrp(), and if your system supports them: setsid(), setpgid(), tcgetpgrp(), tcsetpgrp(). Improvements to the socket module: socket objects have new methods getpeername() and getsockname(), and the {get,set}sockopt methods can now get/set any kind of option using strings built with the new struct module. And there's a new function fromfd() which creates a socket object given a file descriptor (useful for servers started by inetd, which have a socket connected to stdin and stdout). Changes to SGI-specific built-in modules ---------------------------------------- The FORMS library interface (fl) now requires FORMS 2.1a. Some new functions have been added and some bugs have been fixed. Additions to al (audio library interface): added getname(), getdefault() and getminmax(). The gl modules doesn't call "foreground()" when initialized (this caused some problems) like it dit in 0.9.7beta (but not before). There's a new gl function 'gversion() which returns a version string. The interface to sv (Indigo video interface) has totally changed. (Sorry, still no documentation, but see the examples in demo/sgi/{sv,video}.) Changes to standard library modules ----------------------------------- Most functions in module string are now much faster: they're actually implemented in C. The module containing the C versions is called "strop" but you should still import "string" since strop doesn't provide all the interfaces defined in string (and strop may be renamed to string when it is complete in a future release). string.index() now accepts an optional third argument giving an index where to start searching in the first argument, so you can find second and further occurrences (this is similar to the regular expression functions in regex). The definition of what string.splitfields(anything, '') should return is changed for the last time: it returns a singleton list containing its whole first argument unchanged. This is compatible with regsub.split() which also ignores empty delimiter matches. posixpath, macpath: added dirname() and normpath() (and basename() to macpath). The mainloop module (for use with stdwin) can now demultiplex input from other sources, as long as they can be polled with select(). New built-in modules -------------------- Module struct defines functions to pack/unpack values to/from strings representing binary values in native byte order. Module strop implements C versions of many functions from string (see above). Optional module fcntl defines interfaces to fcntl() and ioctl() -- UNIX only. (Not yet properly documented -- see however src/fcntl.doc.) Optional module mpz defines an interface to an altaernative long integer implementation, the GNU MPZ library. Optional module md5 uses the GNU MPZ library to calculate MD5 signatures of strings. There are also optional new modules specific to SGI machines: imageop defines some simple operations to images represented as strings; sv interfaces to the Indigo video board; cl interfaces to the (yet unreleased) compression library. New standard library modules ---------------------------- (Unfortunately the following modules are not all documented; read the sources to find out more about them!) autotest: run testall without showing any output unless it differs from the expected output bisect: use bisection to insert or find an item in a sorted list colorsys: defines conversions between various color systems (e.g. RGB <-> YUV) nntplib: a client interface to NNTP servers pipes: utility to construct pipeline from templates, e.g. for conversion from one file format to another using several utilities. regsub: contains three functions that are more or less compatible with awk functions of the same name: sub() and gsub() do string substitution, split() splits a string using a regular expression to define how separators are define. test_types: test operations on the built-in types of Python toaiff: convert various audio file formats to AIFF format tzparse: parse the TZ environment parameter (this may be less general than it could be, let me know if you fix it). (Note that the obsolete module "path" no longer exists.) New SGI-specific library modules -------------------------------- CL: constants for use with the built-in compression library interface (cl) Queue: a multi-producer, multi-consumer queue class implemented for use with the built-in thread module SOCKET: constants for use with built-in module socket, e.g. to set/get socket options. This is SGI-specific because the constants to be passed are system-dependent. You can generate a version for your own system by running the script demo/scripts/h2py.py with /usr/include/sys/socket.h as input. cddb: interface to the database used the the CD player torgb: convert various image file types to rgb format (requires pbmplus) New demos --------- There's an experimental interface to define Sun RPC clients and servers in demo/rpc. There's a collection of interfaces to WWW, WAIS and Gopher (both Python classes and program providing a user interface) in demo/www. This includes a program texi2html.py which converts texinfo files to HTML files (the format used hy WWW). The ibrowse demo has moved from demo/stdwin/ibrowse to demo/ibrowse. For SGI systems, there's a whole collection of programs and classes that make use of the Indigo video board in demo/sgi/{sv,video}. This represents a significant amount of work that we're giving away! There are demos "rsa" and "md5test" that exercise the mpz and md5 modules, respectively. The rsa demo is a complete implementation of the RSA public-key cryptosystem! A bunch of games and examples submitted by Stoffel Erasmus have been included in demo/stoffel. There are miscellaneous new files in some existing demo subdirectories: classes/bitvec.py, scripts/{fixps,methfix}.py, sgi/al/cmpaf.py, sockets/{mcast,gopher}.py. There are also many minor changes to existing files, but I'm too lazy to run a diff and note the differences -- you can do this yourself if you save the old distribution's demos. One highlight: the stdwin/python.py demo is much improved! Changes to the documentation ---------------------------- The LaTeX source for the library uses different macros to enable it to be converted to texinfo, and from there to INFO or HTML format so it can be browsed as a hypertext. The net result is that you can now read the Python library documentation in Emacs info mode! Changes to the source code that affect C extension writers ---------------------------------------------------------- The function strdup() no longer exists (it was used only in one places and is somewhat of a a portability problem sice some systems have the same function in their C library. The functions NEW() and RENEW() allocate one spare byte to guard against a NULL return from malloc(0) being taken for an error, but this should not be relied upon. ========================= ==> Release 0.9.7beta <== ========================= Changes to the language proper ------------------------------ User-defined classes can now implement operations invoked through special syntax, such as x[i] or `x` by defining methods named __getitem__(self, i) or __repr__(self), etc. Changes to the build process ---------------------------- Instead of extensive manual editing of the Makefile to select compile-time options, you can now run a Configure.py script. The Makefile as distributed builds a minimal interpreter sufficient to run Configure.py. See also misc/BUILD The Makefile now includes more "utility" targets, e.g. install and tags/TAGS Using the provided strtod.c and strtol.c are now separate options, as on the Sun the provided strtod.c dumps core :-( The regex module is now an option chosen by the Makefile, since some (old) C compilers choke on regexpr.c Changes affecting portability ----------------------------- You need STDWIN version 0.9.7 (released 30 June 1992) for the stdwin interface Dynamic loading is now supported for Sun (and other non-COFF systems) throug dld-3.2.3, as well as for SGI (a new version of Jack Jansen's DL is out, 1.4) The system-dependent code for the use of the select() system call is moved to one file: myselect.h Thanks to Jaap Vermeulen, the code should now port cleanly to the SEQUENT Changes to the interpreter interface ------------------------------------ The interpretation of $PYTHONPATH in the environment is different: it is inserted in front of the default path instead of overriding it Changes to existing built-in functions and methods -------------------------------------------------- List objects now support an optional argument to their sort() method, which is a comparison function similar to qsort(3) in C File objects now have a method fileno(), used by the new select module (see below) New built-in function --------------------- coerce(x, y): take two numbers and return a tuple containing them both converted to a common type Changes to built-in modules --------------------------- sys: fixed core dumps in settrace() and setprofile() socket: added socket methods setsockopt() and getsockopt(); and fileno(), used by the new select module (see below) stdwin: added fileno() == connectionnumber(), in support of new module select (see below) posix: added get{eg,eu,g,u}id(); waitpid() is now a separate function. gl: added qgetfd() fl: added several new functions, fixed several obscure bugs, adapted to FORMS 2.1 Changes to standard modules --------------------------- posixpath: changed implementation of ismount() string: atoi() no longer mistakes leading zero for octal number ... New built-in modules -------------------- Modules marked "dynamic only" are not configured at compile time but can be loaded dynamically. You need to turn on the DL or DLD option in the Makefile for support dynamic loading of modules (this requires external code). select: interfaces to the BSD select() system call dbm: interfaces to the (new) dbm library (dynamic only) nis: interfaces to some NIS functions (aka yellow pages) thread: limited form of multiple threads (sgi only) audioop: operations useful for audio programs, e.g. u-LAW and ADPCM coding (dynamic only) cd: interface to Indigo SCSI CDROM player audio library (sgi only) jpeg: read files in JPEG format (dynamic only, sgi only; needs external code) imgfile: read SGI image files (dynamic only, sgi only) sunaudiodev: interface to sun's /dev/audio (dynamic only, sun only) sv: interface to Indigo video library (sgi only) pc: a minimal set of MS-DOS interfaces (MS-DOS only) rotor: encryption, by Lance Ellinghouse (dynamic only) New standard modules -------------------- Not all these modules are documented. Read the source: lib/.py. Sometimes a file lib/.doc contains additional documentation. imghdr: recognizes image file headers sndhdr: recognizes sound file headers profile: print run-time statistics of Python code readcd, cdplayer: companion modules for built-in module cd (sgi only) emacs: interface to Emacs using py-connect.el (see below). SOCKET: symbolic constant definitions for socket options SUNAUDIODEV: symbolic constant definitions for sunaudiodef (sun only) SV: symbolic constat definitions for sv (sgi only) CD: symbolic constat definitions for cd (sgi only) New demos --------- scripts/pp.py: execute Python as a filter with a Perl-like command line interface classes/: examples using the new class features threads/: examples using the new thread module sgi/cd/: examples using the new cd module Changes to the documentation ---------------------------- The last-minute syntax changes of release 0.9.6 are now reflected everywhere in the manuals The reference manual has a new section (3.2) on implementing new kinds of numbers, sequences or mappings with user classes Classes are now treated extensively in the tutorial (chapter 9) Slightly restructured the system-dependent chapters of the library manual The file misc/EXTENDING incorporates documentation for mkvalue() and a new section on error handling The files misc/CLASSES and misc/ERRORS are no longer necessary The doc/Makefile now creates PostScript files automatically Miscellaneous changes --------------------- Incorporated Tim Peters' changes to python-mode.el, it's now version 1.06 A python/Emacs bridge (provided by Terrence M. Brannon) lets a Python program running in an Emacs buffer execute Emacs lisp code. The necessary Python code is in lib/emacs.py. The Emacs code is misc/py-connect.el (it needs some external Emacs lisp code) Changes to the source code that affect C extension writers ---------------------------------------------------------- New service function mkvalue() to construct a Python object from C values according to a "format" string a la getargs() Most functions from pythonmain.c moved to new pythonrun.c which is in libpython.a. This should make embedded versions of Python easier ceval.h is split in eval.h (which needs compile.h and only declares eval_code) and ceval.h (which doesn't need compile.hand declares the rest) ceval.h defines macros BGN_SAVE / END_SAVE for use with threads (to improve the parallellism of multi-threaded programs by letting other Python code run when a blocking system call or something similar is made) In structmember.[ch], new member types BYTE, CHAR and unsigned variants have been added New file xxmodule.c is a template for new extension modules. ================================== ==> RELEASE 0.9.6 (6 Apr 1992) <== ================================== Misc news in 0.9.6: - Restructured the misc subdirectory - Reference manual completed, library manual much extended (with indexes!) - the GNU Readline library is now distributed standard with Python - the script "../demo/scripts/classfix.py" fixes Python modules using old class syntax - Emacs python-mode.el (was python.el) vastly improved (thanks, Tim!) - Because of the GNU copyleft business I am not using the GNU regular expression implementation but a free re-implementation by Tatu Ylonen that recently appeared in comp.sources.misc (Bravo, Tatu!) New features in 0.9.6: - stricter try stmt syntax: cannot mix except and finally clauses on 1 try - New module 'os' supplants modules 'mac' and 'posix' for most cases; module 'path' is replaced by 'os.path' - os.path.split() return value differs from that of old path.split() - sys.exc_type, sys.exc_value, sys.exc_traceback are set to the exception currently being handled - sys.last_type, sys.last_value, sys.last_traceback remember last unhandled exception - New function string.expandtabs() expands tabs in a string - Added times() interface to posix (user & sys time of process & children) - Added uname() interface to posix (returns OS type, hostname, etc.) - New built-in function execfile() is like exec() but from a file - Functions exec() and eval() are less picky about whitespace/newlines - New built-in functions getattr() and setattr() access arbitrary attributes - More generic argument handling in built-in functions (see "./EXTENDING") - Dynamic loading of modules written in C or C++ (see "./DYNLOAD") - Division and modulo for long and plain integers with negative operands have changed; a/b is now floor(float(a)/float(b)) and a%b is defined as a-(a/b)*b. So now the outcome of divmod(a,b) is the same as (a/b, a%b) for integers. For floats, % is also changed, but of course / is unchanged, and divmod(x,y) does not yield (x/y, x%y)... - A function with explicit variable-length argument list can be declared like this: def f(*args): ...; or even like this: def f(a, b, *rest): ... - Code tracing and profiling features have been added, and two source code debuggers are provided in the library (pdb.py, tty-oriented, and wdb, window-oriented); you can now step through Python programs! See sys.settrace() and sys.setprofile(), and "../lib/pdb.doc" - '==' is now the only equality operator; "../demo/scripts/eqfix.py" is a script that fixes old Python modules - Plain integer right shift now uses sign extension - Long integer shift/mask operations now simulate 2's complement to give more useful results for negative operands - Changed/added range checks for long/plain integer shifts - Options found after "-c command" are now passed to the command in sys.argv (note subtle incompatiblity with "python -c command -- -options"!) - Module stdwin is better protected against touching objects after they've been closed; menus can now also be closed explicitly - Stdwin now uses its own exception (stdwin.error) New features in 0.9.5 (released as Macintosh application only, 2 Jan 1992): - dictionary objects can now be compared properly; e.g., {}=={} is true - new exception SystemExit causes termination if not caught; it is raised by sys.exit() so that 'finally' clauses can clean up, and it may even be caught. It does work interactively! - new module "regex" implements GNU Emacs style regular expressions; module "regexp" is rewritten in Python for backward compatibility - formal parameter lists may contain trailing commas Bugs fixed in 0.9.6: - assigning to or deleting a list item with a negative index dumped core - divmod(-10L,5L) returned (-3L, 5L) instead of (-2L, 0L) Bugs fixed in 0.9.5: - masking operations involving negative long integers gave wrong results =================================== ==> RELEASE 0.9.4 (24 Dec 1991) <== =================================== - new function argument handling (see below) - built-in apply(func, args) means func(args[0], args[1], ...) - new, more refined exceptions - new exception string values (NameError = 'NameError' etc.) - better checking for math exceptions - for sequences (string/tuple/list), x[-i] is now equivalent to x[len(x)-i] - fixed list assignment bug: "a[1:1] = a" now works correctly - new class syntax, without extraneous parentheses - new 'global' statement to assign global variables from within a function New class syntax ---------------- You can now declare a base class as follows: class B: # Was: class B(): def some_method(self): ... ... and a derived class thusly: class D(B): # Was: class D() = B(): def another_method(self, arg): ... Multiple inheritance looks like this: class M(B, D): # Was: class M() = B(), D(): def this_or_that_method(self, arg): ... The old syntax is still accepted by Python 0.9.4, but will disappear in Python 1.0 (to be posted to comp.sources). New 'global' statement ---------------------- Every now and then you have a global variable in a module that you want to change from within a function in that module -- say, a count of calls to a function, or an option flag, etc. Until now this was not directly possible. While several kludges are known that circumvent the problem, and often the need for a global variable can be avoided by rewriting the module as a class, this does not always lead to clearer code. The 'global' statement solves this dilemma. Its occurrence in a function body means that, for the duration of that function, the names listed there refer to global variables. For instance: total = 0.0 count = 0 def add_to_total(amount): global total, count total = total + amount count = count + 1 'global' must be repeated in each function where it is needed. The names listed in a 'global' statement must not be used in the function before the statement is reached. Remember that you don't need to use 'global' if you only want to *use* a global variable in a function; nor do you need ot for assignments to parts of global variables (e.g., list or dictionary items or attributes of class instances). This has not changed; in fact assignment to part of a global variable was the standard workaround. New exceptions -------------- Several new exceptions have been defined, to distinguish more clearly between different types of errors. name meaning was AttributeError reference to non-existing attribute NameError IOError unexpected I/O error RuntimeError ImportError import of non-existing module or name NameError IndexError invalid string, tuple or list index RuntimeError KeyError key not in dictionary RuntimeError OverflowError numeric overflow RuntimeError SyntaxError invalid syntax RuntimeError ValueError invalid argument value RuntimeError ZeroDivisionError division by zero RuntimeError The string value of each exception is now its name -- this makes it easier to experimentally find out which operations raise which exceptions; e.g.: >>> KeyboardInterrupt 'KeyboardInterrupt' >>> New argument passing semantics ------------------------------ Off-line discussions with Steve Majewski and Daniel LaLiberte have convinced me that Python's parameter mechanism could be changed in a way that made both of them happy (I hope), kept me happy, fixed a number of outstanding problems, and, given some backward compatibility provisions, would only break a very small amount of existing code -- probably all mine anyway. In fact I suspect that most Python users will hardly notice the difference. And yet it has cost me at least one sleepless night to decide to make the change... Philosophically, the change is quite radical (to me, anyway): a function is no longer called with either zero or one argument, which is a tuple if there appear to be more arguments. Every function now has an argument list containing 0, 1 or more arguments. This list is always implemented as a tuple, and it is a (run-time) error if a function is called with a different number of arguments than expected. What's the difference? you may ask. The answer is, very little unless you want to write variadic functions -- functions that may be called with a variable number of arguments. Formerly, you could write a function that accepted one or more arguments with little trouble, but writing a function that could be called with either 0 or 1 argument (or more) was next to impossible. This is now a piece of cake: you can simply declare an argument that receives the entire argument tuple, and check its length -- it will be of size 0 if there are no arguments. Another anomaly of the old system was the way multi-argument methods (in classes) had to be declared, e.g.: class Point(): def init(self, (x, y, color)): ... def setcolor(self, color): ... dev moveto(self, (x, y)): ... def draw(self): ... Using the new scheme there is no need to enclose the method arguments in an extra set of parentheses, so the above class could become: class Point: def init(self, x, y, color): ... def setcolor(self, color): ... dev moveto(self, x, y): ... def draw(self): ... That is, the equivalence rule between methods and functions has changed so that now p.moveto(x,y) is equivalent to Point.moveto(p,x,y) while formerly it was equivalent to Point.moveto(p,(x,y)). A special backward compatibility rule makes that the old version also still works: whenever a function with exactly two arguments (at the top level) is called with more than two arguments, the second and further arguments are packed into a tuple and passed as the second argument. This rule is invoked independently of whether the function is actually a method, so there is a slight chance that some erroneous calls of functions expecting two arguments with more than that number of arguments go undetected at first -- when the function tries to use the second argument it may find it is a tuple instead of what was expected. Note that this rule will be removed from future versions of the language; it is a backward compatibility provision *only*. Two other rules and a new built-in function handle conversion between tuples and argument lists: Rule (a): when a function with more than one argument is called with a single argument that is a tuple of the right size, the tuple's items are used as arguments. Rule (b): when a function with exactly one argument receives no arguments or more than one, that one argument will receive a tuple containing the arguments (the tuple will be empty if there were no arguments). A new built-in function, apply(), was added to support functions that need to call other functions with a constructed argument list. The call apply(function, tuple) is equivalent to function(tuple[0], tuple[1], ..., tuple[len(tuple)-1]) While no new argument syntax was added in this phase, it would now be quite sensible to add explicit syntax to Python for default argument values (as in C++ or Modula-3), or a "rest" argument to receive the remaining arguments of a variable-length argument list. ======================================================== ==> Release 0.9.3 (never made available outside CWI) <== ======================================================== - string sys.version shows current version (also printed on interactive entry) - more detailed exceptions, e.g., IOError, ZeroDivisionError, etc. - 'global' statement to declare module-global variables assigned in functions. - new class declaration syntax: class C(Base1, Base2, ...): suite (the old syntax is still accepted -- be sure to convert your classes now!) - C shifting and masking operators: << >> ~ & ^ | (for ints and longs). - C comparison operators: == != (the old = and <> remain valid). - floating point numbers may now start with a period (e.g., .14). - definition of integer division tightened (always truncates towards zero). - new builtins hex(x), oct(x) return hex/octal string from (long) integer. - new list method l.count(x) returns the number of occurrences of x in l. - new SGI module: al (Indigo and 4D/35 audio library). - the FORMS interface (modules fl and FL) now uses FORMS 2.0 - module gl: added lrect{read,write}, rectzoom and pixmode; added (non-GL) functions (un)packrect. - new socket method: s.allowbroadcast(flag). - many objects support __dict__, __methods__ or __members__. - dir() lists anything that has __dict__. - class attributes are no longer read-only. - classes support __bases__, instances support __class__ (and __dict__). - divmod() now also works for floats. - fixed obscure bug in eval('1 '). =================================== ==> Release 0.9.2 (Autumn 1991) <== =================================== Highlights ---------- - tutorial now (almost) complete; library reference reorganized - new syntax: continue statement; semicolons; dictionary constructors; restrictions on blank lines in source files removed - dramatically improved module load time through precompiled modules - arbitrary precision integers: compute 2 to the power 1000 and more... - arithmetic operators now accept mixed type operands, e.g., 3.14/4 - more operations on list: remove, index, reverse; repetition - improved/new file operations: readlines, seek, tell, flush, ... - process management added to the posix module: fork/exec/wait/kill etc. - BSD socket operations (with example servers and clients!) - many new STDWIN features (color, fonts, polygons, ...) - new SGI modules: font manager and FORMS library interface Extended list of changes in 0.9.2 --------------------------------- Here is a summary of the most important user-visible changes in 0.9.2, in somewhat arbitrary order. Changes in later versions are listed in the "highlights" section above. 1. Changes to the interpreter proper - Simple statements can now be separated by semicolons. If you write "if t: s1; s2", both s1 and s2 are executed conditionally. - The 'continue' statement was added, with semantics as in C. - Dictionary displays are now allowed on input: {key: value, ...}. - Blank lines and lines bearing only a comment no longer need to be indented properly. (A completely empty line still ends a multi- line statement interactively.) - Mixed arithmetic is supported, 1 compares equal to 1.0, etc. - Option "-c command" to execute statements from the command line - Compiled versions of modules are cached in ".pyc" files, giving a dramatic improvement of start-up time - Other, smaller speed improvements, e.g., extracting characters from strings, looking up single-character keys, and looking up global variables - Interrupting a print operation raises KeyboardInterrupt instead of only cancelling the print operation - Fixed various portability problems (it now passes gcc with only warnings -- more Standard C compatibility will be provided in later versions) - Source is prepared for porting to MS-DOS - Numeric constants are now checked for overflow (this requires standard-conforming strtol() and strtod() functions; a correct strtol() implementation is provided, but the strtod() provided relies on atof() for everything, including error checking 2. Changes to the built-in types, functions and modules - New module socket: interface to BSD socket primitives - New modules pwd and grp: access the UNIX password and group databases - (SGI only:) New module "fm" interfaces to the SGI IRIX Font Manager - (SGI only:) New module "fl" interfaces to Mark Overmars' FORMS library - New numeric type: long integer, for unlimited precision - integer constants suffixed with 'L' or 'l' are long integers - new built-in function long(x) converts int or float to long - int() and float() now also convert from long integers - New built-in function: - pow(x, y) returns x to the power y - New operation and methods for lists: - l*n returns a new list consisting of n concatenated copies of l - l.remove(x) removes the first occurrence of the value x from l - l.index(x) returns the index of the first occurrence of x in l - l.reverse() reverses l in place - New operation for tuples: - t*n returns a tuple consisting of n concatenated copies of t - Improved file handling: - f.readline() no longer restricts the line length, is faster, and isn't confused by null bytes; same for raw_input() - f.read() without arguments reads the entire (rest of the) file - mixing of print and sys.stdout.write() has different effect - New methods for files: - f.readlines() returns a list containing the lines of the file, as read with f.readline() - f.flush(), f.tell(), f.seek() call their stdio counterparts - f.isatty() tests for "tty-ness" - New posix functions: - _exit(), exec(), fork(), getpid(), getppid(), kill(), wait() - popen() returns a file object connected to a pipe - utime() replaces utimes() (the latter is not a POSIX name) - New stdwin features, including: - font handling - color drawing - scroll bars made optional - polygons - filled and xor shapes - text editing objects now have a 'settext' method 3. Changes to the standard library - Name change: the functions path.cat and macpath.cat are now called path.join and macpath.join - Added new modules: formatter, mutex, persist, sched, mainloop - Added some modules and functionality to the "widget set" (which is still under development, so please bear with me): DirList, FormSplit, TextEdit, WindowSched - Fixed module testall to work non-interactively - Module string: - added functions join() and joinfields() - fixed center() to work correct and make it "transitive" - Obsolete modules were removed: util, minmax - Some modules were moved to the demo directory 4. Changes to the demonstration programs - Added new useful scipts: byteyears, eptags, fact, from, lfact, objgraph, pdeps, pi, primes, ptags, which - Added a bunch of socket demos - Doubled the speed of ptags - Added new stdwin demos: microedit, miniedit - Added a windowing interface to the Python interpreter: python (most useful on the Mac) - Added a browser for Emacs info files: demo/stdwin/ibrowse (yes, I plan to put all STDWIN and Python documentation in texinfo form in the future) 5. Other changes to the distribution - An Emacs Lisp file "python.el" is provided to facilitate editing Python programs in GNU Emacs (slightly improved since posted to gnu.emacs.sources) - Some info on writing an extension in C is provided - Some info on building Python on non-UNIX platforms is provided ===================================== ==> Release 0.9.1 (February 1991) <== ===================================== - Micro changes only - Added file "patchlevel.h" ===================================== ==> Release 0.9.0 (February 1991) <== ===================================== Original posting to alt.sources.