Changeset 388 for python/vendor/current/Doc/faq

python/vendor/current/Doc/faq/design.rst

-              r2
+              r388
 Guido van Rossum believes that using indentation for grouping is extremely
 elegant and contributes a lot to the clarity of the average Python program.
 Most people learn to love this feature after awhile.
+Most people learn to love this feature after a while.
 Since there are no begin/end brackets there cannot be a disagreement between
 …
 least slightly uneasy when reading (or being required to write) another style.
 Many coding styles place begin/end brackets on a line by themself.  This makes
+Many coding styles place begin/end brackets on a line by themselves.  This makes
 programs considerably longer and wastes valuable screen space, making it harder
 to get a good overview of a program.  Ideally, a function should fit on one
 …
 People are often very surprised by results like this::
    >>> 1.2-1.0
+   >>> 1.2 - 1.0
 .199999999999999996
 …
 that was probably intended::
    >>> 0.2
 .20000000000000001
    >>> print 0.2
+   >>> 1.1 - 0.9
+.20000000000000007
+   >>> print 1.1 - 0.9
 .2
 …
 numbers is less than a certain threshold::
    epsilon = 0.0000000000001 # Tiny allowed error
+   epsilon = 0.0000000000001  # Tiny allowed error
    expected_result = 0.4
 …
 reference or call the method from a particular class.  In C++, if you want to
 use a method from a base class which is overridden in a derived class, you have
+to use the ``::`` operator -- in Python you can write baseclass.methodname(self,
+<argument list>).  This is particularly useful for :meth:`__init__` methods, and
+in general in cases where a derived class method wants to extend the base class
+method of the same name and thus has to call the base class method somehow.
+to use the ``::`` operator -- in Python you can write
+``baseclass.methodname(self, <argument list>)``.  This is particularly useful
+for :meth:`__init__` methods, and in general in cases where a derived class
+method wants to extend the base class method of the same name and thus has to
+call the base class method somehow.
 Finally, for instance variables it solves a syntactic problem with assignment:
 since local variables in Python are (by definition!) those variables to which a
 value assigned in a function body (and that aren't explicitly declared global),
+there has to be some way to tell the interpreter that an assignment was meant to
+assign to an instance variable instead of to a local variable, and it should
 preferably be syntactic (for efficiency reasons).  C++ does this through
+value is assigned in a function body (and that aren't explicitly declared
+global), there has to be some way to tell the interpreter that an assignment was
+meant to assign to an instance variable instead of to a local variable, and it
+should preferably be syntactic (for efficiency reasons).  C++ does this through
 declarations, but Python doesn't have declarations and it would be a pity having
 to introduce them just for this purpose.  Using the explicit "self.var" solves
+to introduce them just for this purpose.  Using the explicit ``self.var`` solves
 this nicely.  Similarly, for using instance variables, having to write
+"self.var" means that references to unqualified names inside a method don't have
+to search the instance's directories.  To put it another way, local variables
+and instance variables live in two different namespaces, and you need to tell
 Python which namespace to use.
+``self.var`` means that references to unqualified names inside a method don't
+have to search the instance's directories.  To put it another way, local
+variables and instance variables live in two different namespaces, and you need
+to tell Python which namespace to use.
 …
 that didn't have methods at all (e.g. tuples).  It is also convenient to have a
 function that can readily be applied to an amorphous collection of objects when
 you use the functional features of Python (``map()``, ``apply()`` et al).
+you use the functional features of Python (``map()``, ``zip()`` et al).
 In fact, implementing ``len()``, ``max()``, ``min()`` as a built-in function is
 …
 .. XXX talk about protocols?
+Note that for string operations Python has moved from external functions (the
+``string`` module) to methods.  However, ``len()`` is still a function.
+.. note::
+   For string operations, Python has moved from external functions (the
+   ``string`` module) to methods.  However, ``len()`` is still a function.
 …
 ------------------------
+A try/except block is extremely efficient.  Actually catching an exception is
+expensive.  In versions of Python prior to 2.0 it was common to use this idiom::
+A try/except block is extremely efficient if no exceptions are raised.  Actually
+catching an exception is expensive.  In versions of Python prior to 2.0 it was
+common to use this idiom::
    try:
        value = dict[key]
+       value = mydict[key]
    except KeyError:
        dict[key] = getvalue(key)
        value = dict[key]
+       mydict[key] = getvalue(key)
+       value = mydict[key]
 This only made sense when you expected the dict to have the key almost all the
 time.  If that wasn't the case, you coded it like this::
    if dict.has_key(key):
        value = dict[key]
+   if key in mydict:
+       value = mydict[key]
    else:
+       dict[key] = getvalue(key)
+       value = dict[key]
+(In Python 2.0 and higher, you can code this as ``value = dict.setdefault(key,
+getvalue(key))``.)
+       value = mydict[key] = getvalue(key)
+.. note::
+   In Python 2.0 and higher, you can code this as ``value =
+   mydict.setdefault(key, getvalue(key))``.
 …
 Answer 2: Fortunately, there is `Stackless Python <http://www.stackless.com>`_,
 which has a completely redesigned interpreter loop that avoids the C stack.
+It's still experimental but looks very promising.  Although it is binary
+compatible with standard Python, it's still unclear whether Stackless will make
+it into the core -- maybe it's just too revolutionary.
+Why can't lambda forms contain statements?
+------------------------------------------
+Python lambda forms cannot contain statements because Python's syntactic
+Why can't lambda expressions contain statements?
+------------------------------------------------
+Python lambda expressions cannot contain statements because Python's syntactic
 framework can't handle statements nested inside expressions.  However, in
 Python, this is not a serious problem.  Unlike lambda forms in other languages,
 …
 Functions are already first class objects in Python, and can be declared in a
 local scope.  Therefore the only advantage of using a lambda form instead of a
+local scope.  Therefore the only advantage of using a lambda instead of a
 locally-defined function is that you don't need to invent a name for the
 function -- but that's just a local variable to which the function object (which
 is exactly the same type of object that a lambda form yields) is assigned!
+is exactly the same type of object that a lambda expression yields) is assigned!
 …
 <http://pyinline.sourceforge.net/>`_, `Py2Cmod
 <http://sourceforge.net/projects/py2cmod/>`_, and `Weave
 <http://www.scipy.org/site_content/weave>`_.
+<http://www.scipy.org/Weave>`_.
 …
 the behavior of the reference counting implementation.
+.. XXX relevant for Python 2.6?
 Sometimes objects get stuck in tracebacks temporarily and hence are not
 deallocated when you might expect.  Clear the tracebacks with::
 …
 handling of an exception (usually the most recent exception).
 In the absence of circularities and tracebacks, Python programs need not
 explicitly manage memory.
+In the absence of circularities and tracebacks, Python programs do not need to
+manage memory explicitly.
 Why doesn't Python use a more traditional garbage collection scheme?  For one
 …
 of file descriptors long before it runs out of memory::
    for file in <very long list of files>:
+   for file in very_long_list_of_files:
        f = open(file)
        c = f.read(1)
 …
 to f closes the previous file.  Using GC, this is not guaranteed.  If you want
 to write code that will work with any Python implementation, you should
 explicitly close the file; this will work regardless of GC::
+   for file in <very long list of files>:
        f = open(file)
        c = f.read(1)
        f.close()
+explicitly close the file or use the :keyword:`with` statement; this will work
+regardless of GC::
+   for file in very_long_list_of_files:
+       with open(file) as f:
+           c = f.read(1)
 …
   construct a new list with the same value it won't be found; e.g.::
      d = {[1,2]: '12'}
      print d[[1,2]]
   would raise a KeyError exception because the id of the ``[1,2]`` used in the
+     mydict = {[1, 2]: '12'}
+     print mydict[[1, 2]]
+  would raise a KeyError exception because the id of the ``[1, 2]`` used in the
   second line differs from that in the first line.  In other words, dictionary
   keys should be compared using ``==``, not using :keyword:`is`.
 …
 There is a trick to get around this if you need to, but use it at your own risk:
 You can wrap a mutable structure inside a class instance which has both a
 :meth:`__cmp_` and a :meth:`__hash__` method.  You must then make sure that the
+:meth:`__eq__` and a :meth:`__hash__` method.  You must then make sure that the
 hash value for all such wrapper objects that reside in a dictionary (or other
 hash based structure), remain fixed while the object is in the dictionary (or
 …
        def __init__(self, the_list):
            self.the_list = the_list
        def __cmp__(self, other):
+       def __eq__(self, other):
            return self.the_list == other.the_list
        def __hash__(self):
            l = self.the_list
            result = 98767 - len(l)*555
            for i in range(len(l)):
+           for i, el in enumerate(l):
                try:
                    result = result + (hash(l[i]) % 9999999) * 1001 + i
                except:
+                   result = result + (hash(el) % 9999999) * 1001 + i
+               except Exception:
                    result = (result % 7777777) + i * 333
            return result
 …
 overflow.
 Furthermore it must always be the case that if ``o1 == o2`` (ie ``o1.__cmp__(o2)
 == 0``) then ``hash(o1) == hash(o2)`` (ie, ``o1.__hash__() == o2.__hash__()``),
+Furthermore it must always be the case that if ``o1 == o2`` (ie ``o1.__eq__(o2)
+is True``) then ``hash(o1) == hash(o2)`` (ie, ``o1.__hash__() == o2.__hash__()``),
 regardless of whether the object is in a dictionary or not.  If you fail to meet
 these restrictions dictionaries and other hash based structures will misbehave.
 …
 order::
    for key in sorted(dict.iterkeys()):
        ... # do whatever with dict[key]...
+   for key in sorted(mydict):
+       ... # do whatever with mydict[key]...
 …
 (ABCs).  You can then use :func:`isinstance` and :func:`issubclass` to check
 whether an instance or a class implements a particular ABC.  The
+:mod:`collections` modules defines a set of useful ABCs such as
+:class:`Iterable`, :class:`Container`, and :class:`MutableMapping`.
+:mod:`collections` module defines a set of useful ABCs such as
+:class:`~collections.Iterable`, :class:`~collections.Container`, and
+:class:`~collections.MutableMapping`.
 For Python, many of the advantages of interface specifications can be obtained
 …
 This type of bug commonly bites neophyte programmers.  Consider this function::
    def foo(D={}):  # Danger: shared reference to one dict for all calls
+   def foo(mydict={}):  # Danger: shared reference to one dict for all calls
        ... compute something ...
        D[key] = value
        return D
 The first time you call this function, ``D`` contains a single item.  The second
+time, ``D`` contains two items because when ``foo()`` begins executing, ``D``
 starts out with an item already in it.
+       mydict[key] = value
+       return mydict
+The first time you call this function, ``mydict`` contains a single item.  The
+second time, ``mydict`` contains two items because when ``foo()`` begins
+executing, ``mydict`` starts out with an item already in it.
 It is often expected that a function call creates new objects for default
 …
 list/dictionary/whatever if it is.  For example, don't write::
    def foo(dict={}):
+   def foo(mydict={}):
        ...
 but::
    def foo(dict=None):
        if dict is None:
            dict = {} # create a new dict for local namespace
+   def foo(mydict=None):
+       if mydict is None:
+           mydict = {}  # create a new dict for local namespace
 This feature can be useful.  When you have a function that's time-consuming to
 …
    # Callers will never provide a third parameter for this function.
    def expensive (arg1, arg2, _cache={}):
        if _cache.has_key((arg1, arg2)):
+   def expensive(arg1, arg2, _cache={}):
+       if (arg1, arg2) in _cache:
            return _cache[(arg1, arg2)]
 …
 languages.  For example::
    class label: pass # declare a label
+   class label: pass  # declare a label
    try:
         ...
         if (condition): raise label() # goto label
+        if condition: raise label()  # goto label
         ...
    except label: # where to goto
+   except label:  # where to goto
         pass
    ...
 …
 accept forward slashes too::
    f = open("/mydir/file.txt") # works fine!
+   f = open("/mydir/file.txt")  # works fine!
 If you're trying to build a pathname for a DOS command, try e.g. one of ::
 …
    with obj:
        a = 1    # equivalent to obj.a = 1
+       a = 1               # equivalent to obj.a = 1
        total = total + 1   # obj.total = obj.total + 1
 …
 volume) can, however, easily be achieved in Python by assignment.  Instead of::
    function(args).dict[index][index].a = 21
    function(args).dict[index][index].b = 42
    function(args).dict[index][index].c = 63
+   function(args).mydict[index][index].a = 21
+   function(args).mydict[index][index].b = 42
+   function(args).mydict[index][index].c = 63
 write this::
    ref = function(args).dict[index][index]
+   ref = function(args).mydict[index][index]
    ref.a = 21
    ref.b = 42
 …
 This also has the side-effect of increasing execution speed because name
 bindings are resolved at run-time in Python, and the second version only needs
+to perform the resolution once.  If the referenced object does not have a, b and
+c attributes, of course, the end result is still a run-time exception.
+to perform the resolution once.
 …
 When you have a literal value for a list, tuple, or dictionary spread across
 multiple lines, it's easier to add more elements because you don't have to
 remember to add a comma to the previous line.  The lines can also be sorted in
 your editor without creating a syntax error.
+remember to add a comma to the previous line.  The lines can also be reordered
+without creating a syntax error.
 Accidentally omitting the comma can lead to errors that are hard to diagnose.

python/vendor/current/Doc/faq/extending.rst

-              r2
+              r388
 =======================
+.. contents::
+.. only:: html
+   .. contents::
 .. highlight:: c
 …
 C++ objects with constructors are probably not a good idea.
+.. _c-wrapper-software:
 Writing C is hard; are there any alternatives?
 …
 <http://cxx.sourceforge.net/>`_ `Boost
 <http://www.boost.org/libs/python/doc/index.html>`_, or `Weave
 <http://www.scipy.org/site_content/weave>`_ are also alternatives for wrapping
+<http://www.scipy.org/Weave>`_ are also alternatives for wrapping
 C++ libraries.
 …
 -----------------------------------------------------
 The highest-level function to do this is :cfunc:`PyRun_SimpleString` which takes
+The highest-level function to do this is :c:func:`PyRun_SimpleString` which takes
 a single string argument to be executed in the context of the module
 ``__main__`` and returns 0 for success and -1 when an exception occurred
 (including ``SyntaxError``).  If you want more control, use
 :cfunc:`PyRun_String`; see the source for :cfunc:`PyRun_SimpleString` in
+:c:func:`PyRun_String`; see the source for :c:func:`PyRun_SimpleString` in
 ``Python/pythonrun.c``.
 …
 ---------------------------------------------------------
 Call the function :cfunc:`PyRun_String` from the previous question with the
 start symbol :cdata:`Py_eval_input`; it parses an expression, evaluates it and
+Call the function :c:func:`PyRun_String` from the previous question with the
+start symbol :c:data:`Py_eval_input`; it parses an expression, evaluates it and
 returns its value.
 …
 -----------------------------------------------
 That depends on the object's type.  If it's a tuple, :cfunc:`PyTuple_Size`
 returns its length and :cfunc:`PyTuple_GetItem` returns the item at a specified
 index.  Lists have similar functions, :cfunc:`PyListSize` and
 :cfunc:`PyList_GetItem`.
 For strings, :cfunc:`PyString_Size` returns its length and
 :cfunc:`PyString_AsString` a pointer to its value.  Note that Python strings may
 contain null bytes so C's :cfunc:`strlen` should not be used.
+That depends on the object's type.  If it's a tuple, :c:func:`PyTuple_Size`
+returns its length and :c:func:`PyTuple_GetItem` returns the item at a specified
+index.  Lists have similar functions, :c:func:`PyListSize` and
+:c:func:`PyList_GetItem`.
+For strings, :c:func:`PyString_Size` returns its length and
+:c:func:`PyString_AsString` a pointer to its value.  Note that Python strings may
+contain null bytes so C's :c:func:`strlen` should not be used.
 To test the type of an object, first make sure it isn't *NULL*, and then use
 :cfunc:`PyString_Check`, :cfunc:`PyTuple_Check`, :cfunc:`PyList_Check`, etc.
+:c:func:`PyString_Check`, :c:func:`PyTuple_Check`, :c:func:`PyList_Check`, etc.
 There is also a high-level API to Python objects which is provided by the
 so-called 'abstract' interface -- read ``Include/abstract.h`` for further
 details.  It allows interfacing with any kind of Python sequence using calls
 like :cfunc:`PySequence_Length`, :cfunc:`PySequence_GetItem`, etc.)  as well as
+like :c:func:`PySequence_Length`, :c:func:`PySequence_GetItem`, etc.)  as well as
 many other useful protocols.
 …
 You can't.  Use ``t = PyTuple_New(n)`` instead, and fill it with objects using
 ``PyTuple_SetItem(t, i, o)`` -- note that this "eats" a reference count of
 ``o``, so you have to :cfunc:`Py_INCREF` it.  Lists have similar functions
+``o``, so you have to :c:func:`Py_INCREF` it.  Lists have similar functions
 ``PyList_New(n)`` and ``PyList_SetItem(l, i, o)``.  Note that you *must* set all
 the tuple items to some value before you pass the tuple to Python code --
 …
 ----------------------------------------
 The :cfunc:`PyObject_CallMethod` function can be used to call an arbitrary
+The :c:func:`PyObject_CallMethod` function can be used to call an arbitrary
 method of an object.  The parameters are the object, the name of the method to
 call, a format string like that used with :cfunc:`Py_BuildValue`, and the
+call, a format string like that used with :c:func:`Py_BuildValue`, and the
 argument values::
 …
 This works for any object that has methods -- whether built-in or user-defined.
 You are responsible for eventually :cfunc:`Py_DECREF`\ 'ing the return value.
+You are responsible for eventually :c:func:`Py_DECREF`\ 'ing the return value.
 To call, e.g., a file object's "seek" method with arguments 10, 0 (assuming the
 …
+   }
 Note that since :cfunc:`PyObject_CallObject` *always* wants a tuple for the
+Note that since :c:func:`PyObject_CallObject` *always* wants a tuple for the
 argument list, to call a function without arguments, pass "()" for the format,
 and to call a function with one argument, surround the argument in parentheses,
 …
    attr = PyObject_GetAttrString(module, "<attrname>");
 Calling :cfunc:`PyObject_SetAttrString` to assign to variables in the module
+Calling :c:func:`PyObject_SetAttrString` to assign to variables in the module
 also works.
 …
 Python type around a C structure (pointer) type will also work for C++ objects.
+For C++ libraries, you can look at `SIP
+<http://www.riverbankcomputing.co.uk/sip/>`_, `CXX
+<http://cxx.sourceforge.net/>`_, `Boost
+<http://www.boost.org/libs/python/doc/index.html>`_, `Weave
+<http://www.scipy.org/site_content/weave>`_ or `SWIG <http://www.swig.org>`_
+For C++ libraries, see :ref:`c-wrapper-software`.
 …
 behavior sufficiently.  IDLE uses this, for example.
 The easiest way to do it in C is to call :cfunc:`PyRun_InteractiveLoop` (perhaps
+The easiest way to do it in C is to call :c:func:`PyRun_InteractiveLoop` (perhaps
 in a separate thread) and let the Python interpreter handle the input for
 you. You can also set the :cfunc:`PyOS_ReadlineFunctionPointer` to point at your
+you. You can also set the :c:func:`PyOS_ReadlineFunctionPointer` to point at your
 custom input function. See ``Modules/readline.c`` and ``Parser/myreadline.c``
 for more hints.
 …
 However sometimes you have to run the embedded Python interpreter in the same
 thread as your rest application and you can't allow the
 :cfunc:`PyRun_InteractiveLoop` to stop while waiting for user input.  The one
 solution then is to call :cfunc:`PyParser_ParseString` and test for ``e.error``
+:c:func:`PyRun_InteractiveLoop` to stop while waiting for user input.  The one
+solution then is to call :c:func:`PyParser_ParseString` and test for ``e.error``
 equal to ``E_EOF``, which means the input is incomplete).  Here's a sample code
 fragment, untested, inspired by code from Alex Farber::
 …
 Another solution is trying to compile the received string with
 :cfunc:`Py_CompileString`. If it compiles without errors, try to execute the
 returned code object by calling :cfunc:`PyEval_EvalCode`. Otherwise save the
+:c:func:`Py_CompileString`. If it compiles without errors, try to execute the
+returned code object by calling :c:func:`PyEval_EvalCode`. Otherwise save the
 input for later. If the compilation fails, find out if it's an error or just
 more input is required - by extracting the message string from the exception
 …
 Unicode.  This only causes the link failure if the extension uses any of the
 ``PyUnicode_*()`` functions.  It is also a problem if an extension uses any of
 the Unicode-related format specifiers for :cfunc:`Py_BuildValue` (or similar) or
 parameter specifications for :cfunc:`PyArg_ParseTuple`.
+the Unicode-related format specifiers for :c:func:`Py_BuildValue` (or similar) or
+parameter specifications for :c:func:`PyArg_ParseTuple`.
 You can check the size of the Unicode character a Python interpreter is using by

python/vendor/current/Doc/faq/general.rst

-              r2
+              r388
 ==================
+.. contents::
+.. only:: html
+   .. contents::
 General Information
 …
 The latest Python source distribution is always available from python.org, at
 http://www.python.org/download/.  The latest development sources can be obtained
 via anonymous Subversion at http://svn.python.org/projects/python/trunk.
+via anonymous Mercurial access at http://hg.python.org/cpython.
 The source distribution is a gzipped tar file containing the complete C source,
 …
 and run out of the box on most UNIX platforms.
+.. XXX update link once the dev faq is relocated
+Consult the `Developer FAQ <http://www.python.org/dev/faq/>`__ for more
+Consult the `Developer FAQ <http://docs.python.org/devguide/faq>`__ for more
 information on getting the source code and compiling it.
 …
 news is available.
-.. XXX update link once the dev faq is relocated
 You can also access the development version of Python through Subversion.  See
 http://www.python.org/dev/faq/ for details.
+http://docs.python.org/devguide/faq for details.
 …
 `password reset procedure <http://bugs.python.org/user?@template=forgotten>`_.
-.. XXX adapt link to dev guide
 For more information on how Python is developed, consult `the Python Developer's
 Guide <http://python.org/dev/>`_.
+Guide <http://docs.python.org/devguide/>`_.

python/vendor/current/Doc/faq/gui.rst

-              r2
+              r388
 ==========================
 .. contents::
+.. only:: html
+General GUI Questions
+=====================
+   .. contents::
 What platform-independent GUI toolkits exist for Python?
+--------------------------------------------------------
+========================================================
 Depending on what platform(s) you are aiming at, there are several.
 …
 Tkinter
+'''''''
+-------
 Standard builds of Python include an object-oriented interface to the Tcl/Tk
 …
 wxWidgets
+'''''''''
+---------
+wxWidgets is a GUI class library written in C++ that's a portable
+interface to various platform-specific libraries, and that has a
+Python interface called `wxPython <http://www.wxpython.org>`__.
+wxWidgets (http://www.wxwidgets.org) is a free, portable GUI class
+library written in C++ that provides a native look and feel on a
+number of platforms, with Windows, MacOS X, GTK, X11, all listed as
+current stable targets.  Language bindings are available for a number
+of languages including Python, Perl, Ruby, etc.
+wxWidgets preserves the look and feel of the
+underlying graphics toolkit, and has a large set of widgets and
+collection of GDI classes.  See `the wxWidgets page
+<http://www.wxwidgets.org>`_ for more details.
+wxPython (http://www.wxpython.org) is the Python binding for
+wxwidgets.  While it often lags slightly behind the official wxWidgets
+releases, it also offers a number of features via pure Python
+extensions that are not available in other language bindings.  There
+is an active wxPython user and developer community.
+wxWidgets supports Windows and MacOS; on Unix variants,
+it supports both GTk+ and Motif toolkits.
+Both wxWidgets and wxPython are free, open source, software with
+permissive licences that allow their use in commercial products as
+well as in freeware or shareware.
 Qt
+'''
+---
+There are bindings available for the Qt toolkit (`PyQt
+<http://www.riverbankcomputing.co.uk/software/pyqt/>`_) and for KDE (`PyKDE <http://www.riverbankcomputing.co.uk/software/pykde/intro>`__).  If
+you're writing open source software, you don't need to pay for PyQt, but if you
+want to write proprietary applications, you must buy a PyQt license from
+`Riverbank Computing <http://www.riverbankcomputing.co.uk>`_ and (up to Qt 4.4;
+Qt 4.5 upwards is licensed under the LGPL license) a Qt license from `Trolltech
+<http://www.trolltech.com>`_.
+There are bindings available for the Qt toolkit (using either `PyQt
+<http://www.riverbankcomputing.co.uk/software/pyqt/>`_ or `PySide
+<http://www.pyside.org/>`_) and for KDE (`PyKDE <http://www.riverbankcomputing.co.uk/software/pykde/intro>`_).
+PyQt is currently more mature than PySide, but you must buy a PyQt license from
+`Riverbank Computing <http://www.riverbankcomputing.co.uk/software/pyqt/license>`_
+if you want to write proprietary applications.  PySide is free for all applications.
+Qt 4.5 upwards is licensed under the LGPL license; also, commercial licenses
+are available from `Nokia <http://qt.nokia.com/>`_.
 Gtk+
+''''
+----
 PyGtk bindings for the `Gtk+ toolkit <http://www.gtk.org>`_ have been
 …
 FLTK
+''''
+----
 Python bindings for `the FLTK toolkit <http://www.fltk.org>`_, a simple yet
 …
 FOX
+'''
+----
 A wrapper for `the FOX toolkit <http://www.fox-toolkit.org/>`_ called `FXpy
 …
 OpenGL
+''''''
+------
 For OpenGL bindings, see `PyOpenGL <http://pyopengl.sourceforge.net>`_.
 …
 What platform-specific GUI toolkits exist for Python?
+-----------------------------------------------------
+========================================================
 `The Mac port <http://python.org/download/mac>`_ by Jack Jansen has a rich and
 …
 Build Tix with SAM enabled, perform the appropriate call to
 :cfunc:`Tclsam_init`, etc. inside Python's
+:c:func:`Tclsam_init`, etc. inside Python's
 :file:`Modules/tkappinit.c`, and link with libtclsam and libtksam (you
 might include the Tix libraries as well).
 …
 Yes, and you don't even need threads!  But you'll have to restructure your I/O
 code a bit.  Tk has the equivalent of Xt's :cfunc:`XtAddInput()` call, which allows you
+code a bit.  Tk has the equivalent of Xt's :c:func:`XtAddInput()` call, which allows you
 to register a callback function which will be called from the Tk mainloop when
 I/O is possible on a file descriptor.  Here's what you need::

python/vendor/current/Doc/faq/index.rst

-              r2
+              r388
+.. _faq-index:
 ###################################
   Python Frequently Asked Questions
 ###################################
-:Release: |version|
-:Date: |today|
 .. toctree::

python/vendor/current/Doc/faq/library.rst

-              r2
+              r388
 =========================
+.. contents::
+.. only:: html
+   .. contents::
 General Library Questions
 …
 Check :ref:`the Library Reference <library-index>` to see if there's a relevant
 standard library module.  (Eventually you'll learn what's in the standard
 library and will able to skip this step.)
+library and will be able to skip this step.)
 For third-party packages, search the `Python Package Index
 …
 dynamically loaded module implemented in C, C++ or other compiled language.
 In this case you may not have the source file or it may be something like
 mathmodule.c, somewhere in a C source directory (not on the Python Path).
+:file:`mathmodule.c`, somewhere in a C source directory (not on the Python Path).
 There are (at least) three kinds of modules in Python:
 …
 If you would like the script to be independent of where the Python interpreter
 lives, you can use the "env" program.  Almost all Unix variants support the
 following, assuming the Python interpreter is in a directory on the user's
 $PATH::
+lives, you can use the :program:`env` program.  Almost all Unix variants support
+the following, assuming the Python interpreter is in a directory on the user's
+:envvar:`PATH`::
   #!/usr/bin/env python
 *Don't* do this for CGI scripts.  The $PATH variable for CGI scripts is often
 very minimal, so you need to use the actual absolute pathname of the
+*Don't* do this for CGI scripts.  The :envvar:`PATH` variable for CGI scripts is
+often very minimal, so you need to use the actual absolute pathname of the
 interpreter.
 Occasionally, a user's environment is so full that the /usr/bin/env program
 fails; or there's no env program at all.  In that case, you can try the
+Occasionally, a user's environment is so full that the :program:`/usr/bin/env`
+program fails; or there's no env program at all.  In that case, you can try the
 following hack (due to Alex Rezinsky)::
 …
 .. XXX curses *is* built by default, isn't it?
 For Unix variants: The standard Python source distribution comes with a curses
 module in the ``Modules/`` subdirectory, though it's not compiled by default
 (note that this is not available in the Windows distribution -- there is no
 curses module for Windows).
 The curses module supports basic curses features as well as many additional
+For Unix variants the standard Python source distribution comes with a curses
+module in the :source:`Modules` subdirectory, though it's not compiled by default.
+(Note that this is not available in the Windows distribution -- there is no
+curses module for Windows.)
+The :mod:`curses` module supports basic curses features as well as many additional
 functions from ncurses and SYSV curses such as colour, alternative character set
 support, pads, and mouse support. This means the module isn't compatible with
 …
 The :mod:`atexit` module provides a register function that is similar to C's
 onexit.
+:c:func:`onexit`.
 …
 Smalltalk testing frameworks.
+For testing, it helps to write the program so that it may be easily tested by
 using good modular design.  Your program should have almost all functionality
+To make testing easier, you should use good modular design in your program.
+Your program should have almost all functionality
 encapsulated in either functions or class methods -- and this sometimes has the
 surprising and delightful effect of making the program run faster (because local
 …
 Once your program is organized as a tractable collection of functions and class
 behaviours you should write test functions that exercise the behaviours.  A test
 suite can be associated with each module which automates a sequence of tests.
+suite that automates a sequence of tests can be associated with each module.
 This sounds like a lot of work, but since Python is so terse and flexible it's
 surprisingly easy.  You can make coding much more pleasant and fun by writing
 …
 -----------------------------------------
 For Unix variants: There are several solutions.  It's straightforward to do this
+For Unix variants there are several solutions.  It's straightforward to do this
 using curses, but curses is a fairly large module to learn.  Here's a solution
 without curses::
 …
            try:
                c = sys.stdin.read(1)
                print "Got character", `c`
+               print "Got character", repr(c)
            except IOError: pass
    finally:
 …
    time.sleep(10)
 Instead of trying to guess how long a :func:`time.sleep` delay will be enough,
+Instead of trying to guess a good delay value for :func:`time.sleep`,
 it's better to use some kind of semaphore mechanism.  One idea is to use the
 :mod:`Queue` module to create a queue object, let each thread append a token to
 …
 Use the :mod:`Queue` module to create a queue containing a list of jobs.  The
 :class:`~Queue.Queue` class maintains a list of objects with ``.put(obj)`` to
+add an item to the queue and ``.get()`` to return an item.  The class will take
+care of the locking necessary to ensure that each job is handed out exactly
 once.
+:class:`~Queue.Queue` class maintains a list of objects and has a ``.put(obj)``
+method that adds items to the queue and a ``.get()`` method to return them.
+The class will take care of the locking necessary to ensure that each job is
+handed out exactly once.
 Here's a trivial example::
 …
    # assumes there will be no more work and exits.
    # (Realistically workers will run until terminated.)
    def worker ():
+   def worker():
        print 'Running worker'
        time.sleep(0.1)
 …
 When run, this will produce the following output:
+.. code-block:: none
    Running worker
    Running worker
 …
    ...
 Consult the module's documentation for more details; the ``Queue`` class
 provides a featureful interface.
+Consult the module's documentation for more details; the :class:`~Queue.Queue`
+class provides a featureful interface.
 …
 ----------------------------------------------------
 A global interpreter lock (GIL) is used internally to ensure that only one
 thread runs in the Python VM at a time.  In general, Python offers to switch
+A :term:`global interpreter lock` (GIL) is used internally to ensure that only
+one thread runs in the Python VM at a time.  In general, Python offers to switch
 among threads only between bytecode instructions; how frequently it switches can
 be set via :func:`sys.setcheckinterval`.  Each bytecode instruction and
 …
 .. XXX link to dbeazley's talk about GIL?
 The Global Interpreter Lock (GIL) is often seen as a hindrance to Python's
+The :term:`global interpreter lock` (GIL) is often seen as a hindrance to Python's
 deployment on high-end multiprocessor server machines, because a multi-threaded
 Python program effectively only uses one CPU, due to the insistence that
 …
 Since then, the idea of getting rid of the GIL has occasionally come up but
 nobody has found a way to deal with the expected slowdown, and users who don't
 use threads would not be happy if their code ran at half at the speed.  Greg's
+use threads would not be happy if their code ran at half the speed.  Greg's
 free threading patch set has not been kept up-to-date for later Python versions.
 …
 To truncate a file, open it using ``f = open(filename, "r+")``, and use
 ``f.truncate(offset)``; offset defaults to the current seek position.  There's
 also ```os.ftruncate(fd, offset)`` for files opened with :func:`os.open`, where
 ``fd`` is the file descriptor (a small integer).
+also ``os.ftruncate(fd, offset)`` for files opened with :func:`os.open`, where
+*fd* is the file descriptor (a small integer).
 The :mod:`shutil` module also contains a number of functions to work on files
 …
 string.
 For data that is more regular (e.g. a homogeneous list of ints or thefloats),
+For data that is more regular (e.g. a homogeneous list of ints or floats),
 you can also use the :mod:`array` module.
 …
 integer representing the opened file.  :func:`os.popen` creates a high-level
 file object, the same type returned by the built-in :func:`open` function.
 Thus, to read n bytes from a pipe p created with :func:`os.popen`, you need to
+Thus, to read *n* bytes from a pipe *p* created with :func:`os.popen`, you need to
 use ``p.read(n)``.
 …
 Warning: in general it is unwise to do this because you can easily cause a
 deadlock where your process is blocked waiting for output from the child while
 the child is blocked waiting for input from you.  This can be caused because the
 parent expects the child to output more text than it does, or it can be caused
 by data being stuck in stdio buffers due to lack of flushing.  The Python parent
+the child is blocked waiting for input from you.  This can be caused by the
+parent expecting the child to output more text than it does or by data being
+stuck in stdio buffers due to lack of flushing.  The Python parent
 can of course explicitly flush the data it sends to the child before it reads
 any output, but if the child is a naive C program it may have been written to
 …
 the result back.  Unless the amount of data is very large, the easiest way to do
 this is to write it to a temporary file and run the command with that temporary
 file as input.  The standard module :mod:`tempfile` exports a ``mktemp()``
 function to generate unique temporary file names. ::
+file as input.  The standard module :mod:`tempfile` exports a
+:func:`~tempfile.mktemp` function to generate unique temporary file names. ::
    import tempfile
 …
        sys.stdout.write(httpobj.getfile().read())
+Note that in general for URL-encoded POST operations, query strings must be
+quoted by using :func:`urllib.quote`.  For example to send name="Guy Steele,
+Jr."::
+   >>> from urllib import quote
+   >>> x = quote("Guy Steele, Jr.")
+   >>> x
+   'Guy%20Steele,%20Jr.'
+   >>> query_string = "name="+x
+   >>> query_string
+   'name=Guy%20Steele,%20Jr.'
+Note that in general for percent-encoded POST operations, query strings must be
+quoted using :func:`urllib.urlencode`.  For example, to send
+``name=Guy Steele, Jr.``::
+   >>> import urllib
+   >>> urllib.urlencode({'name': 'Guy Steele, Jr.'})
+   'name=Guy+Steele%2C+Jr.'
 …
 .. XXX add modern template languages
+There are many different modules available:
+* HTMLgen is a class library of objects corresponding to all the HTML 3.2 markup
+  tags. It's used when you are writing in Python and wish to synthesize HTML
+  pages for generating a web or for CGI forms, etc.
+* DocumentTemplate and Zope Page Templates are two different systems that are
+  part of Zope.
+* Quixote's PTL uses Python syntax to assemble strings of text.
+Consult the `Web Programming wiki pages
+<http://wiki.python.org/moin/WebProgramming>`_ for more links.
+You can find a collection of useful links on the `Web Programming wiki page
+<http://wiki.python.org/moin/WebProgramming>`_.
 …
 A Unix-only alternative uses sendmail.  The location of the sendmail program
 varies between systems; sometimes it is ``/usr/lib/sendmail``, sometime
+varies between systems; sometimes it is ``/usr/lib/sendmail``, sometimes
 ``/usr/sbin/sendmail``.  The sendmail manual page will help you out.  Here's
 some sample code::
 …
 Python types to files and strings, and back again.  Although marshal does not do
 fancy things like store instances or handle shared references properly, it does
 run extremely fast.  For example loading a half megabyte of data may take less
+run extremely fast.  For example, loading a half megabyte of data may take less
 than a third of a second.  This often beats doing something more complex and
 general such as using gdbm with pickle/shelve.
 …
 .. XXX update this, default protocol is 2/3
+The default format used by the pickle module is a slow one that results in
+readable pickles.  Making it the default, but it would break backward
 compatibility::
+By default :mod:`pickle` uses a relatively old and slow format for backward
+compatibility.  You can however specify other protocol versions that are
+faster::
     largeString = 'z' * (100 * 1024)

python/vendor/current/Doc/faq/programming.rst

-              r2
+              r388
 ===============
+.. contents::
+.. only:: html
+   .. contents::
 General Questions
 …
    L2 = []
    for i in range[3]:
+   for i in range(3):
        L2.append(L1[i])
 it is much shorter and far faster to use ::
    L2 = list(L1[:3]) # "list" is redundant if L1 is a list.
+   L2 = list(L1[:3])  # "list" is redundant if L1 is a list.
 Note that the functionally-oriented built-in functions such as :func:`map`,
 …
 together::
    >>> zip([1,2,3], [4,5,6])
+   >>> zip([1, 2, 3], [4, 5, 6])
    [(1, 4), (2, 5), (3, 6)]
 or to compute a number of sines::
    >>> map( math.sin, (1,2,3,4))
    [0.841470984808, 0.909297426826, 0.14112000806,   -0.756802495308]
+   >>> map(math.sin, (1, 2, 3, 4))
+   [0.841470984808, 0.909297426826, 0.14112000806, -0.756802495308]
 The operation completes very quickly in such cases.
+Other examples include the ``join()`` and ``split()`` methods of string objects.
+Other examples include the ``join()`` and ``split()`` :ref:`methods
+of string objects <string-methods>`.
 For example if s1..s7 are large (10K+) strings then
 ``"".join([s1,s2,s3,s4,s5,s6,s7])`` may be far faster than the more obvious
 ``s1+s2+s3+s4+s5+s6+s7``, since the "summation" will compute many
 subexpressions, whereas ``join()`` does all the copying in one pass.  For
 manipulating strings, use the ``replace()`` method on string objects. Use
+regular expressions only when you're not dealing with constant string patterns.
+Consider using the string formatting operations ``string % tuple`` and ``string
 % dictionary``.
+manipulating strings, use the ``replace()`` and the ``format()`` :ref:`methods
+on string objects <string-methods>`.  Use regular expressions only when you're
+not dealing with constant string patterns.  You may still use :ref:`the old %
+operations <string-formatting>` ``string % tuple`` and ``string % dictionary``.
 Be sure to use the :meth:`list.sort` built-in method to do sorting, and see the
 …
 suppose you have a program that runs slowly and you use the profiler to
 determine that a Python function ``ff()`` is being called lots of times.  If you
 notice that ``ff ()``::
+notice that ``ff()``::
    def ff(x):
 …
-In Python3, you can do a similar thing in a nested scope using the
-:keyword:`nonlocal` keyword:
-.. doctest::
-   :options: +SKIP
-   >>> def foo():
-   ...    x = 10
-   ...    def bar():
-   ...        nonlocal x
-   ...        print x
-   ...        x += 1
-   ...    bar()
-   ...    print x
-   >>> foo()
 What are the rules for local and global variables in Python?
 …
+Why do lambdas defined in a loop with different values all return the same result?
+----------------------------------------------------------------------------------
+Assume you use a for loop to define a few different lambdas (or even plain
+functions), e.g.::
+   >>> squares = []
+   >>> for x in range(5):
+   ...    squares.append(lambda: x**2)
+This gives you a list that contains 5 lambdas that calculate ``x**2``.  You
+might expect that, when called, they would return, respectively, ``0``, ``1``,
+``4``, ``9``, and ``16``.  However, when you actually try you will see that
+they all return ``16``::
+   >>> squares[2]()
+   >>> squares[4]()
+This happens because ``x`` is not local to the lambdas, but is defined in
+the outer scope, and it is accessed when the lambda is called --- not when it
+is defined.  At the end of the loop, the value of ``x`` is ``4``, so all the
+functions now return ``4**2``, i.e. ``16``.  You can also verify this by
+changing the value of ``x`` and see how the results of the lambdas change::
+   >>> x = 8
+   >>> squares[2]()
+In order to avoid this, you need to save the values in variables local to the
+lambdas, so that they don't rely on the value of the global ``x``::
+   >>> squares = []
+   >>> for x in range(5):
+   ...    squares.append(lambda n=x: n**2)
+Here, ``n=x`` creates a new variable ``n`` local to the lambda and computed
+when the lambda is defined so that it has the same value that ``x`` had at
+that point in the loop.  This means that the value of ``n`` will be ``0``
+in the first lambda, ``1`` in the second, ``2`` in the third, and so on.
+Therefore each lambda will now return the correct result::
+   >>> squares[2]()
+   >>> squares[4]()
+Note that this behaviour is not peculiar to lambdas, but applies to regular
+functions too.
 How do I share global variables across modules?
 ------------------------------------------------
 …
 It's good practice if you import modules in the following order:
 . standard library modules -- e.g. ``sys``, ``os``, ``getopt``, ``re``)
+. standard library modules -- e.g. ``sys``, ``os``, ``getopt``, ``re``
 . third-party library modules (anything installed in Python's site-packages
    directory) -- e.g. mx.DateTime, ZODB, PIL.Image, etc.
 …
 write ``import m2``, even though it's legal.  Write ``from package.sub import
 m2`` instead.  Relative imports can lead to a module being initialized twice,
 leading to confusing bugs.
+leading to confusing bugs.  See :pep:`328` for details.
 It is sometimes necessary to move imports to a function or class to avoid
 …
+.. index::
+   single: argument; difference from parameter
+   single: parameter; difference from argument
+.. _faq-argument-vs-parameter:
+What is the difference between arguments and parameters?
+--------------------------------------------------------
+:term:`Parameters <parameter>` are defined by the names that appear in a
+function definition, whereas :term:`arguments <argument>` are the values
+actually passed to a function when calling it.  Parameters define what types of
+arguments a function can accept.  For example, given the function definition::
+   def func(foo, bar=None, **kwargs):
+       pass
+*foo*, *bar* and *kwargs* are parameters of ``func``.  However, when calling
+``func``, for example::
+   func(42, bar=314, extra=somevar)
+the values ``42``, ``314``, and ``somevar`` are arguments.
 How do I write a function with output parameters (call by reference)?
 ---------------------------------------------------------------------
 …
    b = a
    print b
    <__main__.A instance at 016D07CC>
+   <__main__.A instance at 0x16D07CC>
    print a
    <__main__.A instance at 016D07CC>
+   <__main__.A instance at 0x16D07CC>
 Arguably the class has a name: even though it is bound to two names and invoked
 …
     >>> "a" in "b", "a"
     (False, '1')
+    (False, 'a')
 Since the comma is not an operator, but a separator between expressions the
 above is evaluated as if you had entered::
     >>> ("a" in "b"), "a"
+    ("a" in "b"), "a"
 not::
     >>> "a" in ("5", "a")
+    "a" in ("b", "a")
 The same is true of the various assignment operators (``=``, ``+=`` etc).  They
 …
 For versions previous to 2.5 the answer would be 'No'.
-.. XXX remove rest?
-In many cases you can mimic ``a ? b : c`` with ``a and b or c``, but there's a
-flaw: if *b* is zero (or empty, or ``None`` -- anything that tests false) then
-*c* will be selected instead.  In many cases you can prove by looking at the
-code that this can't happen (e.g. because *b* is a constant or has a type that
-can never be false), but in general this can be a problem.
-Tim Peters (who wishes it was Steve Majewski) suggested the following solution:
-``(a and [b] or [c])[0]``.  Because ``[b]`` is a singleton list it is never
-false, so the wrong path is never taken; then applying ``[0]`` to the whole
-thing gets the *b* or *c* that you really wanted.  Ugly, but it gets you there
-in the rare cases where it is really inconvenient to rewrite your code using
-'if'.
-The best course is usually to write a simple ``if...else`` statement.  Another
-solution is to implement the ``?:`` operator as a function::
-   def q(cond, on_true, on_false):
-       if cond:
-           if not isfunction(on_true):
-               return on_true
-           else:
-               return apply(on_true)
-       else:
-           if not isfunction(on_false):
-               return on_false
-           else:
-               return apply(on_false)
-In most cases you'll pass b and c directly: ``q(a, b, c)``.  To avoid evaluating
-b or c when they shouldn't be, encapsulate them within a lambda function, e.g.:
-``q(a, lambda: b, lambda: c)``.
-It has been asked *why* Python has no if-then-else expression.  There are
-several answers: many languages do just fine without one; it can easily lead to
-less readable code; no sufficiently "Pythonic" syntax has been discovered; a
-search of the standard library found remarkably few places where using an
-if-then-else expression would make the code more understandable.
-In 2002, :pep:`308` was written proposing several possible syntaxes and the
-community was asked to vote on the issue.  The vote was inconclusive.  Most
-people liked one of the syntaxes, but also hated other syntaxes; many votes
-implied that people preferred no ternary operator rather than having a syntax
-they hated.
 …
    # First 10 Fibonacci numbers
    print map(lambda x,f=lambda x,f:(x<=1) or (f(x-1,f)+f(x-2,f)): f(x,f),
+   print map(lambda x,f=lambda x,f:(f(x-1,f)+f(x-2,f)) if x>1 else 1: f(x,f),
    range(10))
 …
 ------------------------------------------------
+To specify an octal digit, precede the octal value with a zero.  For example, to
+set the variable "a" to the octal value "10" (8 in decimal), type::
+   >>> a = 010
+To specify an octal digit, precede the octal value with a zero, and then a lower
+or uppercase "o".  For example, to set the variable "a" to the octal value "10"
+(8 in decimal), type::
+   >>> a = 0o10
    >>> a
 …
 Why does -22 / 10 return -3?
 ----------------------------
+Why does -22 // 10 return -3?
+-----------------------------
 It's primarily driven by the desire that ``i % j`` have the same sign as ``j``.
 If you want that, and also want::
     i == (i / j) * j + (i % j)
+    i == (i // j) * j + (i % j)
 then integer division has to return the floor.  C also requires that identity to
 hold, and then compilers that truncate ``i / j`` need to make ``i % j`` have the
 same sign as ``i``.
+hold, and then compilers that truncate ``i // j`` need to make ``i % j`` have
+the same sign as ``i``.
 There are few real use cases for ``i % j`` when ``j`` is negative.  When ``j``
 …
 ago?  ``-190 % 12 == 2`` is useful; ``-190 % 12 == -10`` is a bug waiting to
 bite.
+.. note::
+   On Python 2, ``a / b`` returns the same as ``a // b`` if
+   ``__future__.division`` is not in effect.  This is also known as "classic"
+   division.
 …
 To convert, e.g., the number 144 to the string '144', use the built-in type
 constructor :func:`str`.  If you want a hexadecimal or octal representation, use
+the built-in functions ``hex()`` or ``oct()``.  For fancy formatting, use
+:ref:`the % operator <string-formatting>` on strings, e.g. ``"%04d" % 144``
+yields ``'0144'`` and ``"%.3f" % (1/3.0)`` yields ``'0.333'``.  See the library
+reference manual for details.
+the built-in functions :func:`hex` or :func:`oct`.  For fancy formatting, see
+the :ref:`formatstrings` section, e.g. ``"{:04d}".format(144)`` yields
+``'0144'`` and ``"{:.3f}".format(1/3)`` yields ``'0.333'``.  You may also use
+:ref:`the % operator <string-formatting>` on strings.  See the library reference
+manual for details.
 …
 ability, try converting the string to a list or use the array module::
+   >>> import io
    >>> s = "Hello, world"
    >>> a = list(s)
 …
    array('c', 'Hello, world')
    >>> a[0] = 'y' ; print a
    array('c', 'yello world')
+   array('c', 'yello, world')
    >>> a.tostring()
    'yello, world'
 …
 Starting with Python 2.2, you can use ``S.rstrip("\r\n")`` to remove all
 occurences of any line terminator from the end of the string ``S`` without
+occurrences of any line terminator from the end of the string ``S`` without
 removing other trailing whitespace.  If the string ``S`` represents more than
 one line, with several empty lines at the end, the line terminators for all the
 …
    ...          "\r\n")
    >>> lines.rstrip("\n\r")
    "line 1 "
+   'line 1 '
 Since this is typically only desired when reading text one line at a time, using
 ``S.rstrip()`` this way works well.
 For older versions of Python, There are two partial substitutes:
+For older versions of Python, there are two partial substitutes:
 - If you want to remove all trailing whitespace, use the ``rstrip()`` method of
 …
 if the line uses something other than whitespace as a separator.
 For more complicated input parsing, regular expressions more powerful than C's
 :cfunc:`sscanf` and better suited for the task.
+For more complicated input parsing, regular expressions are more powerful
+than C's :c:func:`sscanf` and better suited for the task.
 …
 list, deleting duplicates as you go::
    if List:
        List.sort()
        last = List[-1]
        for i in range(len(List)-2, -1, -1):
            if last == List[i]:
                del List[i]
+   if mylist:
+       mylist.sort()
+       last = mylist[-1]
+       for i in range(len(mylist)-2, -1, -1):
+           if last == mylist[i]:
+               del mylist[i]
            else:
                last = List[i]
+               last = mylist[i]
 If all elements of the list may be used as dictionary keys (i.e. they are all
 …
    d = {}
    for x in List:
        d[x] = x
    List = d.values()
+   for x in mylist:
+       d[x] = 1
+   mylist = list(d.keys())
 In Python 2.5 and later, the following is possible instead::
    List = list(set(List))
+   mylist = list(set(mylist))
 This converts the list into a set, thereby removing duplicates, and then back
 …
 You probably tried to make a multidimensional array like this::
    A = [[None] * 2] * 3
+   >>> A = [[None] * 2] * 3
 This looks correct if you print it::
 …
 Or, you can use an extension that provides a matrix datatype; `Numeric Python
 <http://numpy.scipy.org/>`_ is the best known.
+<http://www.numpy.org/>`_ is the best known.
 …
 Use a list comprehension::
    result = [obj.method() for obj in List]
+   result = [obj.method() for obj in mylist]
 More generically, you can try the following function::
 …
+Why does a_tuple[i] += ['item'] raise an exception when the addition works?
+---------------------------------------------------------------------------
+This is because of a combination of the fact that augmented assignment
+operators are *assignment* operators, and the difference between mutable and
+immutable objects in Python.
+This discussion applies in general when augmented assignment operators are
+applied to elements of a tuple that point to mutable objects, but we'll use
+a ``list`` and ``+=`` as our exemplar.
+If you wrote::
+   >>> a_tuple = (1, 2)
+   >>> a_tuple[0] += 1
+   Traceback (most recent call last):
+      ...
+   TypeError: 'tuple' object does not support item assignment
+The reason for the exception should be immediately clear: ``1`` is added to the
+object ``a_tuple[0]`` points to (``1``), producing the result object, ``2``,
+but when we attempt to assign the result of the computation, ``2``, to element
+``0`` of the tuple, we get an error because we can't change what an element of
+a tuple points to.
+Under the covers, what this augmented assignment statement is doing is
+approximately this::
+   >>> result = a_tuple[0] + 1
+   >>> a_tuple[0] = result
+   Traceback (most recent call last):
+     ...
+   TypeError: 'tuple' object does not support item assignment
+It is the assignment part of the operation that produces the error, since a
+tuple is immutable.
+When you write something like::
+   >>> a_tuple = (['foo'], 'bar')
+   >>> a_tuple[0] += ['item']
+   Traceback (most recent call last):
+     ...
+   TypeError: 'tuple' object does not support item assignment
+The exception is a bit more surprising, and even more surprising is the fact
+that even though there was an error, the append worked::
+    >>> a_tuple[0]
+    ['foo', 'item']
+To see why this happens, you need to know that (a) if an object implements an
+``__iadd__`` magic method, it gets called when the ``+=`` augmented assignment
+is executed, and its return value is what gets used in the assignment statement;
+and (b) for lists, ``__iadd__`` is equivalent to calling ``extend`` on the list
+and returning the list.  That's why we say that for lists, ``+=`` is a
+"shorthand" for ``list.extend``::
+    >>> a_list = []
+    >>> a_list += [1]
+    >>> a_list
+    [1]
+This is equivalent to::
+    >>> result = a_list.__iadd__([1])
+    >>> a_list = result
+The object pointed to by a_list has been mutated, and the pointer to the
+mutated object is assigned back to ``a_list``.  The end result of the
+assignment is a no-op, since it is a pointer to the same object that ``a_list``
+was previously pointing to, but the assignment still happens.
+Thus, in our tuple example what is happening is equivalent to::
+   >>> result = a_tuple[0].__iadd__(['item'])
+   >>> a_tuple[0] = result
+   Traceback (most recent call last):
+     ...
+   TypeError: 'tuple' object does not support item assignment
+The ``__iadd__`` succeeds, and thus the list is extended, but even though
+``result`` points to the same object that ``a_tuple[0]`` already points to,
+that final assignment still results in an error, because tuples are immutable.
 Dictionaries
 ============
 …
 be presented in order sorted by the key.
 A more complicated solution is to subclass ``UserDict.UserDict`` to create a
+A more complicated solution is to subclass ``dict`` to create a
 ``SortedDict`` class that prints itself in a predictable order.  Here's one
 simpleminded implementation of such a class::
+   import UserDict, string
+   class SortedDict(UserDict.UserDict):
+   class SortedDict(dict):
        def __repr__(self):
+           result = []
+           append = result.append
+           keys = self.data.keys()
+           keys.sort()
+           for k in keys:
+               append("%s: %s" % (`k`, `self.data[k]`))
+           return "{%s}" % string.join(result, ", ")
+     __str__ = __repr__
+           keys = sorted(self.keys())
+           result = ("{!r}: {!r}".format(k, self[k]) for k in keys)
+           return "{{{}}}".format(", ".join(result))
+       __str__ = __repr__
 This will work for many common situations you might encounter, though it's far
 …
 strings by their uppercase values::
   tmp1 = [(x.upper(), x) for x in L] # Schwartzian transform
+  tmp1 = [(x.upper(), x) for x in L]  # Schwartzian transform
   tmp1.sort()
   Usorted = [x[1] for x in tmp1]
 …
 each string::
   tmp2 = [(int(s[10:15]), s) for s in L] # Schwartzian transform
+  tmp2 = [(int(s[10:15]), s) for s in L]  # Schwartzian transform
   tmp2.sort()
   Isorted = [x[1] for x in tmp2]
 …
 An alternative for the last step is::
    result = []
    for p in pairs: result.append(p[1])
+   >>> result = []
+   >>> for p in pairs: result.append(p[1])
 If you find this more legible, you might prefer to use this instead of the final
 …
 that does something::
    def search (obj):
+   def search(obj):
        if isinstance(obj, Mailbox):
            # ... code to search a mailbox
 …
 -----------------------------------------------------------
+Static data (in the sense of C++ or Java) is easy; static methods (again in the
 sense of C++ or Java) are not supported directly.
+Both static data and static methods (in the sense of C++ or Java) are supported
+in Python.
 For static data, simply define a class attribute.  To assign a new value to the
 …
 Caution: within a method of C, an assignment like ``self.count = 42`` creates a
 new and unrelated instance vrbl named "count" in ``self``'s own dict.  Rebinding
+of a class-static data name must always specify the class whether inside a
 method or not::
+new and unrelated instance named "count" in ``self``'s own dict.  Rebinding of a
+class-static data name must always specify the class whether inside a method or
+not::
    C.count = 314
 …
+Why does the result of ``id()`` appear to be not unique?
+--------------------------------------------------------
+The :func:`id` builtin returns an integer that is guaranteed to be unique during
+the lifetime of the object.  Since in CPython, this is the object's memory
+address, it happens frequently that after an object is deleted from memory, the
+next freshly created object is allocated at the same position in memory.  This
+is illustrated by this example:
+>>> id(1000)
+13901272
+>>> id(2000)
+13901272
+The two ids belong to different integer objects that are created before, and
+deleted immediately after execution of the ``id()`` call.  To be sure that
+objects whose id you want to examine are still alive, create another reference
+to the object:
+>>> a = 1000; b = 2000
+>>> id(a)
+13901272
+>>> id(b)
+13891296
 Modules
 =======
 …
 directory.
 Running Python on a top level script is not considered an import and no ``.pyc``
+will be created.  For example, if you have a top-level module ``abc.py`` that
+imports another module ``xyz.py``, when you run abc, ``xyz.pyc`` will be created
+since xyz is imported, but no ``abc.pyc`` file will be created since ``abc.py``
 isn't being imported.
 If you need to create abc.pyc -- that is, to create a .pyc file for a module
+Running Python on a top level script is not considered an import and no
+``.pyc`` will be created.  For example, if you have a top-level module
+``foo.py`` that imports another module ``xyz.py``, when you run ``foo``,
+``xyz.pyc`` will be created since ``xyz`` is imported, but no ``foo.pyc`` file
+will be created since ``foo.py`` isn't being imported.
+If you need to create ``foo.pyc`` -- that is, to create a ``.pyc`` file for a module
 that is not imported -- you can, using the :mod:`py_compile` and
 :mod:`compileall` modules.
 …
    >>> import py_compile
    >>> py_compile.compile('abc.py')
 This will write the ``.pyc`` to the same location as ``abc.py`` (or you can
+   >>> py_compile.compile('foo.py')                 # doctest: +SKIP
+This will write the ``.pyc`` to the same location as ``foo.py`` (or you can
 override that with the optional parameter ``cfile``).

python/vendor/current/Doc/faq/windows.rst

-              r2
+              r388
 =====================
+.. contents::
+.. only:: html
+   .. contents::
 How do I run a Python program under Windows?
 …
 This is not necessarily a straightforward question. If you are already familiar
 with running programs from the Windows command line then everything will seem
+obvious; otherwise, you might need a little more guidance.  There are also
+differences between Windows 95, 98, NT, ME, 2000 and XP which can add to the
+confusion.
+obvious; otherwise, you might need a little more guidance.
 .. sidebar:: |Python Development on XP|_
 …
 *typing* Windows commands into what is variously referred to as a "DOS window"
 or "Command prompt window".  Usually you can create such a window from your
 Start menu; under Windows 2000 the menu selection is :menuselection:`Start -->
+Start menu; under Windows 7 the menu selection is :menuselection:`Start -->
 Programs --> Accessories --> Command Prompt`.  You should be able to recognize
 when you have started such a window because you will see a Windows "command
 …
 might just as easily see something like::
    D:\Steve\Projects\Python>
+   D:\YourName\Projects\Python>
 depending on how your computer has been set up and what else you have recently
 …
 You need to realize that your Python scripts have to be processed by another
 program called the Python interpreter.  The interpreter reads your script,
+program called the Python *interpreter*.  The interpreter reads your script,
 compiles it into bytecodes, and then executes the bytecodes to run your
 program. So, how do you arrange for the interpreter to handle your Python?
 …
 "python" as an instruction to start the interpreter.  If you have opened a
 command window, you should try entering the command ``python`` and hitting
+return.  You should then see something like::
+   Python 2.2 (#28, Dec 21 2001, 12:21:22) [MSC 32 bit (Intel)] on win32
+return.::
+   C:\Users\YourName> python
+You should then see something like::
+   Python 2.7.3 (default, Apr 10 2012, 22.71:26) [MSC v.1500 32 bit (Intel)] on win32
    Type "help", "copyright", "credits" or "license" for more information.
    >>>
 …
 You may also find that you have a Start-menu entry such as :menuselection:`Start
 --> Programs --> Python 2.2 --> Python (command line)` that results in you
+--> Programs --> Python 2.7 --> Python (command line)` that results in you
 seeing the ``>>>`` prompt in a new window.  If so, the window will disappear
 after you enter the Ctrl-Z character; Windows is running a single "python"
 …
 gives you a message like::
+   'python' is not recognized as an internal or external command,
+   operable program or batch file.
+   'python' is not recognized as an internal or external command, operable program or batch file.
 .. sidebar:: |Adding Python to DOS Path|_
 …
 will probably tell you where it is installed; the usual location is something
 like ``C:\Python23``.  Otherwise you will be reduced to a search of your whole
+like ``C:\Python27``.  Otherwise you will be reduced to a search of your whole
 disk ... use :menuselection:`Tools --> Find` or hit the :guilabel:`Search`
 button and look for "python.exe".  Supposing you discover that Python is
 installed in the ``C:\Python23`` directory (the default at the time of writing),
+installed in the ``C:\Python27`` directory (the default at the time of writing),
 you should make sure that entering the command ::
    c:\Python23\python
+   c:\Python27\python
 starts up the interpreter as above (and don't forget you'll need a "CTRL-Z" and
+an "Enter" to get out of it). Once you have verified the directory, you need to
+add it to the start-up routines your computer goes through.  For older versions
+of Windows the easiest way to do this is to edit the ``C:\AUTOEXEC.BAT``
+file. You would want to add a line like the following to ``AUTOEXEC.BAT``::
+   PATH C:\Python23;%PATH%
+For Windows NT, 2000 and (I assume) XP, you will need to add a string such as ::
+   ;C:\Python23
+to the current setting for the PATH environment variable, which you will find in
+the properties window of "My Computer" under the "Advanced" tab.  Note that if
+you have sufficient privilege you might get a choice of installing the settings
+either for the Current User or for System.  The latter is preferred if you want
+everybody to be able to run Python on the machine.
+If you aren't confident doing any of these manipulations yourself, ask for help!
+At this stage you may want to reboot your system to make absolutely sure the new
+setting has taken effect.  You probably won't need to reboot for Windows NT, XP
+or 2000.  You can also avoid it in earlier versions by editing the file
+``C:\WINDOWS\COMMAND\CMDINIT.BAT`` instead of ``AUTOEXEC.BAT``.
+You should now be able to start a new command window, enter ``python`` at the
+``C:\>`` (or whatever) prompt, and see the ``>>>`` prompt that indicates the
+Python interpreter is reading interactive commands.
+Let's suppose you have a program called ``pytest.py`` in directory
+``C:\Steve\Projects\Python``.  A session to run that program might look like
+this::
+   C:\> cd \Steve\Projects\Python
+   C:\Steve\Projects\Python> python pytest.py
+Because you added a file name to the command to start the interpreter, when it
+starts up it reads the Python script in the named file, compiles it, executes
+it, and terminates, so you see another ``C:\>`` prompt.  You might also have
+entered ::
+   C:\> python \Steve\Projects\Python\pytest.py
+if you hadn't wanted to change your current directory.
+Under NT, 2000 and XP you may well find that the installation process has also
+arranged that the command ``pytest.py`` (or, if the file isn't in the current
+directory, ``C:\Steve\Projects\Python\pytest.py``) will automatically recognize
+the ".py" extension and run the Python interpreter on the named file. Using this
+feature is fine, but *some* versions of Windows have bugs which mean that this
+form isn't exactly equivalent to using the interpreter explicitly, so be
+careful.
+The important things to remember are:
+. Start Python from the Start Menu, or make sure the PATH is set correctly so
+   Windows can find the Python interpreter. ::
+      python
+   should give you a '>>>' prompt from the Python interpreter. Don't forget the
+   CTRL-Z and ENTER to terminate the interpreter (and, if you started the window
+   from the Start Menu, make the window disappear).
+. Once this works, you run programs with commands::
+      python {program-file}
+. When you know the commands to use you can build Windows shortcuts to run the
+   Python interpreter on any of your scripts, naming particular working
+   directories, and adding them to your menus.  Take a look at ::
+      python --help
+   if your needs are complex.
+. Interactive mode (where you see the ``>>>`` prompt) is best used for checking
+   that individual statements and expressions do what you think they will, and
+   for developing code by experiment.
+an "Enter" to get out of it). Once you have verified the directory, you can
+add it to the system path to make it easier to start Python by just running
+the ``python`` command. This is currently an option in the installer as of
+CPython 2.7.
+More information about environment variables can be found on the
+:ref:`Using Python on Windows <setting-envvars>` page.
 How do I make Python scripts executable?
 ----------------------------------------
 On Windows 2000, the standard Python installer already associates the .py
+On Windows, the standard Python installer already associates the .py
 extension with a file type (Python.File) and gives that file type an open
 command that runs the interpreter (``D:\Program Files\Python\python.exe "%1"
 …
 'foo.py'.  If you'd rather be able to execute the script by simple typing 'foo'
 with no extension you need to add .py to the PATHEXT environment variable.
-On Windows NT, the steps taken by the installer as described above allow you to
-run a script with 'foo.py', but a longtime bug in the NT command processor
-prevents you from redirecting the input or output of any script executed in this
-way.  This is often important.
-The incantation for making a Python script executable under WinNT is to give the
-file an extension of .cmd and add the following as the first line::
-   @setlocal enableextensions & python -x %~f0 %* & goto :EOF
 Why does Python sometimes take so long to start?
 …
+Where is Freeze for Windows?
+----------------------------
+"Freeze" is a program that allows you to ship a Python program as a single
+stand-alone executable file.  It is *not* a compiler; your programs don't run
+any faster, but they are more easily distributable, at least to platforms with
+the same OS and CPU.  Read the README file of the freeze program for more
+disclaimers.
+You can use freeze on Windows, but you must download the source tree (see
+http://www.python.org/download/source).  The freeze program is in the
+``Tools\freeze`` subdirectory of the source tree.
+You need the Microsoft VC++ compiler, and you probably need to build Python.
+The required project files are in the PCbuild directory.
+How do I make an executable from a Python script?
+-------------------------------------------------
+See http://www.py2exe.org/ for a distutils extension that allows you
+to create console and GUI executables from Python code.
 Is a ``*.pyd`` file the same as a DLL?
 …
 . Do _not_ build Python into your .exe file directly.  On Windows, Python must
    be a DLL to handle importing modules that are themselves DLL's.  (This is the
+   first key undocumented fact.) Instead, link to :file:`python{NN}.dll`; it is
+   typically installed in ``C:\Windows\System``.  NN is the Python version, a
+   number such as "23" for Python 2.3.
+   You can link to Python statically or dynamically.  Linking statically means
+   linking against :file:`python{NN}.lib`, while dynamically linking means
+   linking against :file:`python{NN}.dll`.  The drawback to dynamic linking is
+   that your app won't run if :file:`python{NN}.dll` does not exist on your
+   system.  (General note: :file:`python{NN}.lib` is the so-called "import lib"
+   corresponding to :file:`python.dll`.  It merely defines symbols for the
+   linker.)
+   Linking dynamically greatly simplifies link options; everything happens at
+   run time.  Your code must load :file:`python{NN}.dll` using the Windows
+   first key undocumented fact.)  Instead, link to :file:`python{NN}.dll`; it is
+   typically installed in ``C:\Windows\System``.  *NN* is the Python version, a
+   number such as "27" for Python 2.7.
+   You can link to Python in two different ways.  Load-time linking means
+   linking against :file:`python{NN}.lib`, while run-time linking means linking
+   against :file:`python{NN}.dll`.  (General note: :file:`python{NN}.lib` is the
+   so-called "import lib" corresponding to :file:`python{NN}.dll`.  It merely
+   defines symbols for the linker.)
+   Run-time linking greatly simplifies link options; everything happens at run
+   time.  Your code must load :file:`python{NN}.dll` using the Windows
    ``LoadLibraryEx()`` routine.  The code must also use access routines and data
    in :file:`python{NN}.dll` (that is, Python's C API's) using pointers obtained
 …
    Borland note: convert :file:`python{NN}.lib` to OMF format using Coff2Omf.exe
    first.
+   .. XXX what about static linking?
 . If you use SWIG, it is easy to create a Python "extension module" that will
 …
    (defined in your extension module) that contains read() and write() methods.
-How do I use Python for CGI?
-----------------------------
-On the Microsoft IIS server or on the Win95 MS Personal Web Server you set up
-Python in the same way that you would set up any other scripting engine.
-Run regedt32 and go to::
-    HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\W3SVC\Parameters\ScriptMap
-and enter the following line (making any specific changes that your system may
-need)::
-    .py :REG_SZ: c:\<path to python>\python.exe -u %s %s
-This line will allow you to call your script with a simple reference like:
-``http://yourserver/scripts/yourscript.py`` provided "scripts" is an
-"executable" directory for your server (which it usually is by default).  The
-:option:`-u` flag specifies unbuffered and binary mode for stdin - needed when
-working with binary data.
-In addition, it is recommended that using ".py" may not be a good idea for the
-file extensions when used in this context (you might want to reserve ``*.py``
-for support modules and use ``*.cgi`` or ``*.cgp`` for "main program" scripts).
-In order to set up Internet Information Services 5 to use Python for CGI
-processing, please see the following links:
-   http://www.e-coli.net/pyiis_server.html (for Win2k Server)
-   http://www.e-coli.net/pyiis.html (for Win2k pro)
-Configuring Apache is much simpler.  In the Apache configuration file
-``httpd.conf``, add the following line at the end of the file::
-    ScriptInterpreterSource Registry
-Then, give your Python CGI-scripts the extension .py and put them in the cgi-bin
-directory.
 How do I keep editors from inserting tabs into my Python source?
 ----------------------------------------------------------------
 …
 --------------------------------------
+Use win32api::
+Prior to Python 2.7 and 3.2, to terminate a process, you can use :mod:`ctypes`::
+   import ctypes
    def kill(pid):
        """kill function for Win32"""
+       import win32api
+       handle = win32api.OpenProcess(1, 0, pid)
+       return (0 != win32api.TerminateProcess(handle, 0))
+Why does os.path.isdir() fail on NT shared directories?
+-------------------------------------------------------
+The solution appears to be always append the "\\" on the end of shared
+drives.
+   >>> import os
+   >>> os.path.isdir( '\\\\rorschach\\public')
+   >>> os.path.isdir( '\\\\rorschach\\public\\')
+It helps to think of share points as being like drive letters.  Example::
+   k: is not a directory
+   k:\ is a directory
+   k:\media is a directory
+   k:\media\ is not a directory
+The same rules apply if you substitute "k:" with "\\conky\foo"::
+   \\conky\foo  is not a directory
+   \\conky\foo\ is a directory
+   \\conky\foo\media is a directory
+   \\conky\foo\media\ is not a directory
+cgi.py (or other CGI programming) doesn't work sometimes on NT or win95!
+------------------------------------------------------------------------
+Be sure you have the latest python.exe, that you are using python.exe rather
+than a GUI version of Python and that you have configured the server to execute
+::
+   "...\python.exe -u ..."
+for the CGI execution.  The :option:`-u` (unbuffered) option on NT and Win95
+prevents the interpreter from altering newlines in the standard input and
+output.  Without it post/multipart requests will seem to have the wrong length
+and binary (e.g. GIF) responses may get garbled (resulting in broken images, PDF
+files, and other binary downloads failing).
+Why doesn't os.popen() work in PythonWin on NT?
+-----------------------------------------------
+The reason that os.popen() doesn't work from within PythonWin is due to a bug in
+Microsoft's C Runtime Library (CRT). The CRT assumes you have a Win32 console
+attached to the process.
+You should use the win32pipe module's popen() instead which doesn't depend on
+having an attached Win32 console.
+Example::
+   import win32pipe
+   f = win32pipe.popen('dir /c c:\\')
+   print f.readlines()
+   f.close()
+Why doesn't os.popen()/win32pipe.popen() work on Win9x?
+-------------------------------------------------------
+There is a bug in Win9x that prevents os.popen/win32pipe.popen* from
+working. The good news is there is a way to work around this problem.  The
+Microsoft Knowledge Base article that you need to lookup is: Q150956. You will
+find links to the knowledge base at: http://support.microsoft.com/.
+PyRun_SimpleFile() crashes on Windows but not on Unix; why?
+-----------------------------------------------------------
+This is very sensitive to the compiler vendor, version and (perhaps) even
+options.  If the FILE* structure in your embedding program isn't the same as is
+assumed by the Python interpreter it won't work.
+The Python 1.5.* DLLs (``python15.dll``) are all compiled with MS VC++ 5.0 and
+with multithreading-DLL options (``/MD``).
+If you can't change compilers or flags, try using :cfunc:`Py_RunSimpleString`.
+A trick to get it to run an arbitrary file is to construct a call to
+:func:`execfile` with the name of your file as argument.
+Also note that you can not mix-and-match Debug and Release versions.  If you
+wish to use the Debug Multithreaded DLL, then your module *must* have an "_d"
+appended to the base name.
+Importing _tkinter fails on Windows 95/98: why?
+------------------------------------------------
+Sometimes, the import of _tkinter fails on Windows 95 or 98, complaining with a
+message like the following::
+   ImportError: DLL load failed: One of the library files needed
+   to run this application cannot be found.
+It could be that you haven't installed Tcl/Tk, but if you did install Tcl/Tk,
+and the Wish application works correctly, the problem may be that its installer
+didn't manage to edit the autoexec.bat file correctly.  It tries to add a
+statement that changes the PATH environment variable to include the Tcl/Tk 'bin'
+subdirectory, but sometimes this edit doesn't quite work.  Opening it with
+notepad usually reveals what the problem is.
+(One additional hint, noted by David Szafranski: you can't use long filenames
+here; e.g. use ``C:\PROGRA~1\Tcl\bin`` instead of ``C:\Program Files\Tcl\bin``.)
+       kernel32 = ctypes.windll.kernel32
+       handle = kernel32.OpenProcess(1, 0, pid)
+       return (0 != kernel32.TerminateProcess(handle, 0))
+In 2.7 and 3.2, :func:`os.kill` is implemented similar to the above function,
+with the additional feature of being able to send CTRL+C and CTRL+BREAK
+to console subprocesses which are designed to handle those signals. See
+:func:`os.kill` for further details.
 How do I extract the downloaded documentation on Windows?
 …
 http://www.winzip.com.)
-Missing cw3215mt.dll (or missing cw3215.dll)
---------------------------------------------
-Sometimes, when using Tkinter on Windows, you get an error that cw3215mt.dll or
-cw3215.dll is missing.
-Cause: you have an old Tcl/Tk DLL built with cygwin in your path (probably
-``C:\Windows``).  You must use the Tcl/Tk DLLs from the standard Tcl/Tk
-installation (Python 1.5.2 comes with one).
-Warning about CTL3D32 version from installer
---------------------------------------------
-The Python installer issues a warning like this::
-   This version uses ``CTL3D32.DLL`` which is not the correct version.
-   This version is used for windows NT applications only.
-Tim Peters:
-   This is a Microsoft DLL, and a notorious source of problems.  The message
-   means what it says: you have the wrong version of this DLL for your operating
-   system.  The Python installation did not cause this -- something else you
-   installed previous to this overwrote the DLL that came with your OS (probably
-   older shareware of some sort, but there's no way to tell now).  If you search
-   for "CTL3D32" using any search engine (AltaVista, for example), you'll find
-   hundreds and hundreds of web pages complaining about the same problem with
-   all sorts of installation programs.  They'll point you to ways to get the
-   correct version reinstalled on your system (since Python doesn't cause this,
-   we can't fix it).
-David A Burton has written a little program to fix this.  Go to
-http://www.burtonsys.com/downloads.html and click on "ctl3dfix.zip".

Context Navigation

Legend:

python/vendor/current/Doc/faq/design.rst

python/vendor/current/Doc/faq/extending.rst

python/vendor/current/Doc/faq/general.rst

python/vendor/current/Doc/faq/gui.rst

python/vendor/current/Doc/faq/index.rst

python/vendor/current/Doc/faq/library.rst

python/vendor/current/Doc/faq/programming.rst

python/vendor/current/Doc/faq/windows.rst

Download in other formats: