Remove trailing whitespace.
This commit is contained in:
parent
e92818f58c
commit
c62ef8b4d9
|
@ -30,7 +30,7 @@ returning data from the target object.
|
|||
|
||||
.. index:: single: PyBufferProcs
|
||||
|
||||
More information on the buffer interface is provided in the section
|
||||
More information on the buffer interface is provided in the section
|
||||
:ref:`buffer-structs`, under the description for :ctype:`PyBufferProcs`.
|
||||
|
||||
A "buffer object" is defined in the :file:`bufferobject.h` header (included by
|
||||
|
|
|
@ -77,7 +77,7 @@ The following functions provide locale-independent string to number conversions.
|
|||
|
||||
.. versionadded:: 2.4
|
||||
|
||||
|
||||
|
||||
.. cfunction:: double PyOS_ascii_atof(const char *nptr)
|
||||
|
||||
Convert a string to a :ctype:`double` in a locale-independent way.
|
||||
|
@ -86,7 +86,7 @@ The following functions provide locale-independent string to number conversions.
|
|||
|
||||
See the Unix man page :manpage:`atof(2)` for details.
|
||||
|
||||
|
||||
|
||||
.. cfunction:: char * PyOS_stricmp(char *s1, char *s2)
|
||||
|
||||
Case insensitive comparison of strings. The function works almost
|
||||
|
|
|
@ -902,7 +902,7 @@ in previous versions.
|
|||
|
||||
Return a tuple of function call counts. There are constants defined for the
|
||||
positions within the tuple:
|
||||
|
||||
|
||||
+-------------------------------+-------+
|
||||
| Name | Value |
|
||||
+===============================+=======+
|
||||
|
@ -928,7 +928,7 @@ in previous versions.
|
|||
+-------------------------------+-------+
|
||||
| :const:`PCALL_POP` | 10 |
|
||||
+-------------------------------+-------+
|
||||
|
||||
|
||||
:const:`PCALL_FAST_FUNCTION` means no argument tuple needs to be created.
|
||||
:const:`PCALL_FASTER_FUNCTION` means that the fast-path frame setup code is used.
|
||||
|
||||
|
|
|
@ -126,7 +126,7 @@ Long Integer Objects
|
|||
|
||||
Return a C :ctype:`long` representation of the contents of *pylong*. If
|
||||
*pylong* is greater than :const:`LONG_MAX`, an :exc:`OverflowError` is raised
|
||||
and ``-1`` will be returned.
|
||||
and ``-1`` will be returned.
|
||||
|
||||
|
||||
.. cfunction:: Py_ssize_t PyLong_AsSsize_t(PyObject *pylong)
|
||||
|
|
|
@ -106,7 +106,7 @@ There are only a few functions special to module objects.
|
|||
|
||||
.. cfunction:: int PyModule_AddIntMacro(PyObject *module, macro)
|
||||
|
||||
Add an int constant to *module*. The name and the value are taken from
|
||||
Add an int constant to *module*. The name and the value are taken from
|
||||
*macro*. For example ``PyModule_AddConstant(module, AF_INET)`` adds the int
|
||||
constant *AF_INET* with the value of *AF_INET* to *module*.
|
||||
Return ``-1`` on error, ``0`` on success.
|
||||
|
|
|
@ -15,7 +15,7 @@ Reflection
|
|||
|
||||
Return a dictionary of the local variables in the current execution frame,
|
||||
or *NULL* if no frame is currently executing.
|
||||
|
||||
|
||||
|
||||
.. cfunction:: PyObject* PyEval_GetGlobals()
|
||||
|
||||
|
|
|
@ -143,9 +143,9 @@ Sequence Protocol
|
|||
|
||||
Return the underlying array of PyObject pointers. Assumes that *o* was returned
|
||||
by :cfunc:`PySequence_Fast` and *o* is not *NULL*.
|
||||
|
||||
|
||||
Note, if a list gets resized, the reallocation may relocate the items array.
|
||||
So, only use the underlying array pointer in contexts where the sequence
|
||||
So, only use the underlying array pointer in contexts where the sequence
|
||||
cannot change.
|
||||
|
||||
.. versionadded:: 2.4
|
||||
|
|
|
@ -101,7 +101,7 @@ the constructor functions work with any iterable Python object.
|
|||
|
||||
.. versionchanged:: 2.6
|
||||
Now guaranteed to return a brand-new :class:`frozenset`. Formerly,
|
||||
frozensets of zero-length were a singleton. This got in the way of
|
||||
frozensets of zero-length were a singleton. This got in the way of
|
||||
building-up new frozensets with :meth:`PySet_Add`.
|
||||
|
||||
The following functions and macros are available for instances of :class:`set`
|
||||
|
|
|
@ -265,7 +265,7 @@ definition with the same method name.
|
|||
read-only access. Using :cmacro:`T_STRING` for :attr:`type` implies
|
||||
:cmacro:`READONLY`. Only :cmacro:`T_OBJECT` and :cmacro:`T_OBJECT_EX` can be
|
||||
deleted. (They are set to *NULL*).
|
||||
|
||||
|
||||
|
||||
|
||||
.. cfunction:: PyObject* Py_FindMethod(PyMethodDef table[], PyObject *ob, char *name)
|
||||
|
|
|
@ -104,7 +104,7 @@ setup script). Indirectly provides the :class:`distutils.dist.Distribution` and
|
|||
| *package_dir* | A mapping of package to | a dictionary |
|
||||
| | directory names | |
|
||||
+--------------------+--------------------------------+-------------------------------------------------------------+
|
||||
|
||||
|
||||
|
||||
|
||||
.. function:: run_setup(script_name[, script_args=None, stop_after='run'])
|
||||
|
@ -755,7 +755,7 @@ This module provides the following functions.
|
|||
standard output, otherwise do nothing.
|
||||
|
||||
.. % \subsection{Compiler-specific modules}
|
||||
.. %
|
||||
.. %
|
||||
.. % The following modules implement concrete subclasses of the abstract
|
||||
.. % \class{CCompiler} class. They should not be instantiated directly, but should
|
||||
.. % be created using \function{distutils.ccompiler.new_compiler()} factory
|
||||
|
@ -859,7 +859,7 @@ Contains :class:`MWerksCompiler`, an implementation of the abstract
|
|||
Macintosh. Needs work to support CW on Windows or Mac OS X.
|
||||
|
||||
.. % \subsection{Utility modules}
|
||||
.. %
|
||||
.. %
|
||||
.. % The following modules all provide general utility functions. They haven't
|
||||
.. % all been documented yet.
|
||||
|
||||
|
@ -1110,13 +1110,13 @@ other utility module.
|
|||
|
||||
For MacOS X systems the OS version reflects the minimal version on which
|
||||
binaries will run (that is, the value of ``MACOSX_DEPLOYMENT_TARGET``
|
||||
during the build of Python), not the OS version of the current system.
|
||||
during the build of Python), not the OS version of the current system.
|
||||
|
||||
For universal binary builds on MacOS X the architecture value reflects
|
||||
the univeral binary status instead of the architecture of the current
|
||||
processor. For 32-bit universal binaries the architecture is ``fat``,
|
||||
for 64-bit universal binaries the architecture is ``fat64``, and
|
||||
for 4-way universal binaries the architecture is ``universal``.
|
||||
processor. For 32-bit universal binaries the architecture is ``fat``,
|
||||
for 64-bit universal binaries the architecture is ``fat64``, and
|
||||
for 4-way universal binaries the architecture is ``universal``.
|
||||
|
||||
Examples of returned values on MacOS X:
|
||||
|
||||
|
@ -1693,7 +1693,7 @@ lines, and joining lines with backslashes.
|
|||
|
||||
.. % todo
|
||||
.. % \section{Distutils Commands}
|
||||
.. %
|
||||
.. %
|
||||
.. % This part of Distutils implements the various Distutils commands, such
|
||||
.. % as \code{build}, \code{install} \&c. Each command is implemented as a
|
||||
.. % separate module, with the command name as the name of the module.
|
||||
|
|
|
@ -268,13 +268,13 @@ file winds up deep in the "build tree," in a temporary directory created by
|
|||
.. % \longprogramopt{spec-file} option; used in conjunction with
|
||||
.. % \longprogramopt{spec-only}, this gives you an opportunity to customize
|
||||
.. % the \file{.spec} file manually:
|
||||
.. %
|
||||
.. %
|
||||
.. % \ begin{verbatim}
|
||||
.. % > python setup.py bdist_rpm --spec-only
|
||||
.. % # ...edit dist/FooBar-1.0.spec
|
||||
.. % > python setup.py bdist_rpm --spec-file=dist/FooBar-1.0.spec
|
||||
.. % \ end{verbatim}
|
||||
.. %
|
||||
.. %
|
||||
.. % (Although a better way to do this is probably to override the standard
|
||||
.. % \command{bdist\_rpm} command with one that writes whatever else you want
|
||||
.. % to the \file{.spec} file.)
|
||||
|
@ -334,31 +334,31 @@ The installer file will be written to the "distribution directory" --- normally
|
|||
Cross-compiling on Windows
|
||||
==========================
|
||||
|
||||
Starting with Python 2.6, distutils is capable of cross-compiling between
|
||||
Windows platforms. In practice, this means that with the correct tools
|
||||
Starting with Python 2.6, distutils is capable of cross-compiling between
|
||||
Windows platforms. In practice, this means that with the correct tools
|
||||
installed, you can use a 32bit version of Windows to create 64bit extensions
|
||||
and vice-versa.
|
||||
|
||||
To build for an alternate platform, specify the :option:`--plat-name` option
|
||||
to the build command. Valid values are currently 'win32', 'win-amd64' and
|
||||
To build for an alternate platform, specify the :option:`--plat-name` option
|
||||
to the build command. Valid values are currently 'win32', 'win-amd64' and
|
||||
'win-ia64'. For example, on a 32bit version of Windows, you could execute::
|
||||
|
||||
python setup.py build --plat-name=win-amd64
|
||||
|
||||
to build a 64bit version of your extension. The Windows Installers also
|
||||
to build a 64bit version of your extension. The Windows Installers also
|
||||
support this option, so the command::
|
||||
|
||||
python setup.py build --plat-name=win-amd64 bdist_wininst
|
||||
|
||||
would create a 64bit installation executable on your 32bit version of Windows.
|
||||
|
||||
To cross-compile, you must download the Python source code and cross-compile
|
||||
To cross-compile, you must download the Python source code and cross-compile
|
||||
Python itself for the platform you are targetting - it is not possible from a
|
||||
binary installtion of Python (as the .lib etc file for other platforms are
|
||||
not included.) In practice, this means the user of a 32 bit operating
|
||||
system will need to use Visual Studio 2008 to open the
|
||||
:file:`PCBuild/PCbuild.sln` solution in the Python source tree and build the
|
||||
"x64" configuration of the 'pythoncore' project before cross-compiling
|
||||
not included.) In practice, this means the user of a 32 bit operating
|
||||
system will need to use Visual Studio 2008 to open the
|
||||
:file:`PCBuild/PCbuild.sln` solution in the Python source tree and build the
|
||||
"x64" configuration of the 'pythoncore' project before cross-compiling
|
||||
extensions is possible.
|
||||
|
||||
Note that by default, Visual Studio 2008 does not install 64bit compilers or
|
||||
|
|
|
@ -63,7 +63,7 @@ universal :option:`--help` option, e.g. ::
|
|||
--include-dirs (-I) list of directories to search for header files
|
||||
--define (-D) C preprocessor macros to define
|
||||
--undef (-U) C preprocessor macros to undefine
|
||||
--swig-opts list of SWIG command line options
|
||||
--swig-opts list of SWIG command line options
|
||||
[...]
|
||||
|
||||
Note that an option spelled :option:`--foo-bar` on the command-line is spelled
|
||||
|
|
|
@ -72,7 +72,7 @@ If you want to define another server a new section can be created::
|
|||
index-servers =
|
||||
pypi
|
||||
other
|
||||
|
||||
|
||||
[pypi]
|
||||
repository: <repository-url>
|
||||
username: <username>
|
||||
|
@ -91,4 +91,4 @@ Or even with the section name::
|
|||
|
||||
python setup.py register -r other
|
||||
|
||||
|
||||
|
||||
|
|
|
@ -213,7 +213,7 @@ This warning notwithstanding, options to SWIG can be currently passed like
|
|||
this::
|
||||
|
||||
setup(...,
|
||||
ext_modules=[Extension('_foo', ['foo.i'],
|
||||
ext_modules=[Extension('_foo', ['foo.i'],
|
||||
swig_opts=['-modern', '-I../include'])],
|
||||
py_modules=['foo'],
|
||||
)
|
||||
|
|
|
@ -508,7 +508,7 @@ in a different style:
|
|||
curly braces to indicate a "variable" part, as in ``:file:``.
|
||||
|
||||
If you don't need the "variable part" indication, use the standard
|
||||
````code```` instead.
|
||||
````code```` instead.
|
||||
|
||||
.. describe:: var
|
||||
|
||||
|
@ -767,7 +767,7 @@ the definition of the symbol. There is this directive:
|
|||
don't have to escape ``*`` or ``|`` characters.
|
||||
|
||||
|
||||
.. XXX describe optional first parameter
|
||||
.. XXX describe optional first parameter
|
||||
|
||||
The following is an example taken from the Python Reference Manual::
|
||||
|
||||
|
|
|
@ -39,7 +39,7 @@ Python file, which, in the most simple case, could look like this::
|
|||
|
||||
With this :file:`setup.py`, and a file :file:`demo.c`, running ::
|
||||
|
||||
python setup.py build
|
||||
python setup.py build
|
||||
|
||||
will compile :file:`demo.c`, and produce an extension module named ``demo`` in
|
||||
the :file:`build` directory. Depending on the system, the module file will end
|
||||
|
|
|
@ -471,7 +471,7 @@ Later, when it is time to call the function, you call the C function
|
|||
:cfunc:`PyEval_CallObject`. This function has two arguments, both pointers to
|
||||
arbitrary Python objects: the Python function, and the argument list. The
|
||||
argument list must always be a tuple object, whose length is the number of
|
||||
arguments. To call the Python function with no arguments, pass in NULL, or
|
||||
arguments. To call the Python function with no arguments, pass in NULL, or
|
||||
an empty tuple; to call it with one argument, pass a singleton tuple.
|
||||
:cfunc:`Py_BuildValue` returns a tuple when its format string consists of zero
|
||||
or more format codes between parentheses. For example::
|
||||
|
@ -510,7 +510,7 @@ If this is not possible or desirable, the exception should be cleared by calling
|
|||
if (result == NULL)
|
||||
return NULL; /* Pass error back */
|
||||
...use result...
|
||||
Py_DECREF(result);
|
||||
Py_DECREF(result);
|
||||
|
||||
Depending on the desired interface to the Python callback function, you may also
|
||||
have to provide an argument list to :cfunc:`PyEval_CallObject`. In some cases
|
||||
|
@ -535,7 +535,7 @@ Note the placement of ``Py_DECREF(arglist)`` immediately after the call, before
|
|||
the error check! Also note that strictly speaking this code is not complete:
|
||||
:cfunc:`Py_BuildValue` may run out of memory, and this should be checked.
|
||||
|
||||
You may also call a function with keyword arguments by using
|
||||
You may also call a function with keyword arguments by using
|
||||
:cfunc:`PyEval_CallObjectWithKeywords`. As in the above example, we use
|
||||
:cfunc:`Py_BuildValue` to construct the dictionary. ::
|
||||
|
||||
|
@ -671,7 +671,7 @@ Philbrick (philbrick@hks.com)::
|
|||
|
||||
static PyObject *
|
||||
keywdarg_parrot(PyObject *self, PyObject *args, PyObject *keywds)
|
||||
{
|
||||
{
|
||||
int voltage;
|
||||
char *state = "a stiff";
|
||||
char *action = "voom";
|
||||
|
@ -679,11 +679,11 @@ Philbrick (philbrick@hks.com)::
|
|||
|
||||
static char *kwlist[] = {"voltage", "state", "action", "type", NULL};
|
||||
|
||||
if (!PyArg_ParseTupleAndKeywords(args, keywds, "i|sss", kwlist,
|
||||
if (!PyArg_ParseTupleAndKeywords(args, keywds, "i|sss", kwlist,
|
||||
&voltage, &state, &action, &type))
|
||||
return NULL;
|
||||
return NULL;
|
||||
|
||||
printf("-- This parrot wouldn't %s if you put %i Volts through it.\n",
|
||||
printf("-- This parrot wouldn't %s if you put %i Volts through it.\n",
|
||||
action, voltage);
|
||||
printf("-- Lovely plumage, the %s -- It's %s!\n", type, state);
|
||||
|
||||
|
|
|
@ -1234,7 +1234,7 @@ As with the :attr:`tp_methods` table, a sentinel entry with a :attr:`name` value
|
|||
of *NULL* is required.
|
||||
|
||||
.. XXX Descriptors need to be explained in more detail somewhere, but not here.
|
||||
|
||||
|
||||
Descriptor objects have two handler functions which correspond to the
|
||||
\member{tp_getattro} and \member{tp_setattro} handlers. The
|
||||
\method{__get__()} handler is a function which is passed the descriptor,
|
||||
|
|
|
@ -102,7 +102,7 @@ described here are distributed with the Python sources in the
|
|||
and it should call :cfunc:`Py_InitModule` with the string ``"spam"`` as its
|
||||
first argument (use the minimal :file:`example.c` in this directory as a guide).
|
||||
By convention, it lives in a file called :file:`spam.c` or :file:`spammodule.c`.
|
||||
The output file should be called :file:`spam.pyd` (in Release mode) or
|
||||
The output file should be called :file:`spam.pyd` (in Release mode) or
|
||||
:file:`spam_d.pyd` (in Debug mode). The extension :file:`.pyd` was chosen
|
||||
to avoid confusion with a system library :file:`spam.dll` to which your module
|
||||
could be a Python interface.
|
||||
|
|
|
@ -11,7 +11,7 @@ Glossary
|
|||
``>>>``
|
||||
The default Python prompt of the interactive shell. Often seen for code
|
||||
examples which can be executed interactively in the interpreter.
|
||||
|
||||
|
||||
``...``
|
||||
The default Python prompt of the interactive shell when entering code for
|
||||
an indented code block or within a pair of matching left and right
|
||||
|
@ -50,11 +50,11 @@ Glossary
|
|||
A value associated with an object which is referenced by name using
|
||||
dotted expressions. For example, if an object *o* has an attribute
|
||||
*a* it would be referenced as *o.a*.
|
||||
|
||||
|
||||
BDFL
|
||||
Benevolent Dictator For Life, a.k.a. `Guido van Rossum
|
||||
<http://www.python.org/~guido/>`_, Python's creator.
|
||||
|
||||
|
||||
bytecode
|
||||
Python source code is compiled into bytecode, the internal representation
|
||||
of a Python program in the interpreter. The bytecode is also cached in
|
||||
|
@ -67,11 +67,11 @@ Glossary
|
|||
A template for creating user-defined objects. Class definitions
|
||||
normally contain method definitions which operate on instances of the
|
||||
class.
|
||||
|
||||
|
||||
classic class
|
||||
Any class which does not inherit from :class:`object`. See
|
||||
:term:`new-style class`. Classic classes will be removed in Python 3.0.
|
||||
|
||||
|
||||
coercion
|
||||
The implicit conversion of an instance of one type to another during an
|
||||
operation which involves two arguments of the same type. For example,
|
||||
|
@ -84,7 +84,7 @@ Glossary
|
|||
``operator.add(3.0, 4.5)``. Without coercion, all arguments of even
|
||||
compatible types would have to be normalized to the same value by the
|
||||
programmer, e.g., ``float(3)+4.5`` rather than just ``3+4.5``.
|
||||
|
||||
|
||||
complex number
|
||||
An extension of the familiar real number system in which all numbers are
|
||||
expressed as a sum of a real part and an imaginary part. Imaginary
|
||||
|
@ -96,7 +96,7 @@ Glossary
|
|||
:mod:`math` module, use :mod:`cmath`. Use of complex numbers is a fairly
|
||||
advanced mathematical feature. If you're not aware of a need for them,
|
||||
it's almost certain you can safely ignore them.
|
||||
|
||||
|
||||
context manager
|
||||
An object which controls the environment seen in a :keyword:`with`
|
||||
statement by defining :meth:`__enter__` and :meth:`__exit__` methods.
|
||||
|
@ -138,7 +138,7 @@ Glossary
|
|||
class methods, static methods, and reference to super classes.
|
||||
|
||||
For more information about descriptors' methods, see :ref:`descriptors`.
|
||||
|
||||
|
||||
dictionary
|
||||
An associative array, where arbitrary keys are mapped to values. The use
|
||||
of :class:`dict` closely resembles that for :class:`list`, but the keys can
|
||||
|
@ -152,8 +152,8 @@ Glossary
|
|||
of the enclosing class, function or module. Since it is available via
|
||||
introspection, it is the canonical place for documentation of the
|
||||
object.
|
||||
|
||||
duck-typing
|
||||
|
||||
duck-typing
|
||||
A pythonic programming style which determines an object's type by inspection
|
||||
of its method or attribute signature rather than by explicit relationship
|
||||
to some type object ("If it looks like a duck and quacks like a duck, it
|
||||
|
@ -163,13 +163,13 @@ Glossary
|
|||
:func:`isinstance`. (Note, however, that duck-typing can be complemented
|
||||
with abstract base classes.) Instead, it typically employs :func:`hasattr`
|
||||
tests or :term:`EAFP` programming.
|
||||
|
||||
|
||||
EAFP
|
||||
Easier to ask for forgiveness than permission. This common Python coding
|
||||
style assumes the existence of valid keys or attributes and catches
|
||||
exceptions if the assumption proves false. This clean and fast style is
|
||||
characterized by the presence of many :keyword:`try` and :keyword:`except`
|
||||
statements. The technique contrasts with the :term:`LBYL` style
|
||||
statements. The technique contrasts with the :term:`LBYL` style
|
||||
common to many other languages such as C.
|
||||
|
||||
expression
|
||||
|
@ -195,14 +195,14 @@ Glossary
|
|||
which are not compatible with the current interpreter. For example, the
|
||||
expression ``11/4`` currently evaluates to ``2``. If the module in which
|
||||
it is executed had enabled *true division* by executing::
|
||||
|
||||
|
||||
from __future__ import division
|
||||
|
||||
|
||||
the expression ``11/4`` would evaluate to ``2.75``. By importing the
|
||||
:mod:`__future__` module and evaluating its variables, you can see when a
|
||||
new feature was first added to the language and when it will become the
|
||||
default::
|
||||
|
||||
|
||||
>>> import __future__
|
||||
>>> __future__.division
|
||||
_Feature((2, 2, 0, 'alpha', 2), (3, 0, 0, 'alpha', 0), 8192)
|
||||
|
@ -211,7 +211,7 @@ Glossary
|
|||
The process of freeing memory when it is not used anymore. Python
|
||||
performs garbage collection via reference counting and a cyclic garbage
|
||||
collector that is able to detect and break reference cycles.
|
||||
|
||||
|
||||
generator
|
||||
A function which returns an iterator. It looks like a normal function
|
||||
except that values are returned to the caller using a :keyword:`yield`
|
||||
|
@ -221,21 +221,21 @@ Glossary
|
|||
stopped at the :keyword:`yield` keyword (returning the result) and is
|
||||
resumed there when the next element is requested by calling the
|
||||
:meth:`next` method of the returned iterator.
|
||||
|
||||
|
||||
.. index:: single: generator expression
|
||||
|
||||
|
||||
generator expression
|
||||
An expression that returns a generator. It looks like a normal expression
|
||||
followed by a :keyword:`for` expression defining a loop variable, range,
|
||||
and an optional :keyword:`if` expression. The combined expression
|
||||
generates values for an enclosing function::
|
||||
|
||||
|
||||
>>> sum(i*i for i in range(10)) # sum of squares 0, 1, 4, ... 81
|
||||
285
|
||||
|
||||
|
||||
GIL
|
||||
See :term:`global interpreter lock`.
|
||||
|
||||
|
||||
global interpreter lock
|
||||
The lock used by Python threads to assure that only one thread
|
||||
executes in the :term:`CPython` :term:`virtual machine` at a time.
|
||||
|
@ -261,21 +261,21 @@ Glossary
|
|||
containers (such as lists or dictionaries) are. Objects which are
|
||||
instances of user-defined classes are hashable by default; they all
|
||||
compare unequal, and their hash value is their :func:`id`.
|
||||
|
||||
|
||||
IDLE
|
||||
An Integrated Development Environment for Python. IDLE is a basic editor
|
||||
and interpreter environment which ships with the standard distribution of
|
||||
Python. Good for beginners, it also serves as clear example code for
|
||||
those wanting to implement a moderately sophisticated, multi-platform GUI
|
||||
application.
|
||||
|
||||
|
||||
immutable
|
||||
An object with a fixed value. Immutable objects include numbers, strings and
|
||||
tuples. Such an object cannot be altered. A new object has to
|
||||
be created if a different value has to be stored. They play an important
|
||||
role in places where a constant hash value is needed, for example as a key
|
||||
in a dictionary.
|
||||
|
||||
|
||||
integer division
|
||||
Mathematical division discarding any remainder. For example, the
|
||||
expression ``11/4`` currently evaluates to ``2`` in contrast to the
|
||||
|
@ -287,7 +287,7 @@ Glossary
|
|||
divided by a float will result in a float value, possibly with a decimal
|
||||
fraction. Integer division can be forced by using the ``//`` operator
|
||||
instead of the ``/`` operator. See also :term:`__future__`.
|
||||
|
||||
|
||||
interactive
|
||||
Python has an interactive interpreter which means you can enter
|
||||
statements and expressions at the interpreter prompt, immediately
|
||||
|
@ -295,7 +295,7 @@ Glossary
|
|||
arguments (possibly by selecting it from your computer's main
|
||||
menu). It is a very powerful way to test out new ideas or inspect
|
||||
modules and packages (remember ``help(x)``).
|
||||
|
||||
|
||||
interpreted
|
||||
Python is an interpreted language, as opposed to a compiled one,
|
||||
though the distinction can be blurry because of the presence of the
|
||||
|
@ -304,7 +304,7 @@ Glossary
|
|||
Interpreted languages typically have a shorter development/debug cycle
|
||||
than compiled ones, though their programs generally also run more
|
||||
slowly. See also :term:`interactive`.
|
||||
|
||||
|
||||
iterable
|
||||
A container object capable of returning its members one at a
|
||||
time. Examples of iterables include all sequence types (such as
|
||||
|
@ -320,7 +320,7 @@ Glossary
|
|||
statement does that automatically for you, creating a temporary unnamed
|
||||
variable to hold the iterator for the duration of the loop. See also
|
||||
:term:`iterator`, :term:`sequence`, and :term:`generator`.
|
||||
|
||||
|
||||
iterator
|
||||
An object representing a stream of data. Repeated calls to the iterator's
|
||||
:meth:`next` method return successive items in the stream. When no more
|
||||
|
@ -335,7 +335,7 @@ Glossary
|
|||
:func:`iter` function or use it in a :keyword:`for` loop. Attempting this
|
||||
with an iterator will just return the same exhausted iterator object used
|
||||
in the previous iteration pass, making it appear like an empty container.
|
||||
|
||||
|
||||
More information can be found in :ref:`typeiter`.
|
||||
|
||||
keyword argument
|
||||
|
@ -359,7 +359,7 @@ Glossary
|
|||
A built-in Python :term:`sequence`. Despite its name it is more akin
|
||||
to an array in other languages than to a linked list since access to
|
||||
elements are O(1).
|
||||
|
||||
|
||||
list comprehension
|
||||
A compact way to process all or part of the elements in a sequence and
|
||||
return a list with the results. ``result = ["0x%02x" % x for x in
|
||||
|
@ -367,11 +367,11 @@ Glossary
|
|||
even hex numbers (0x..) in the range from 0 to 255. The :keyword:`if`
|
||||
clause is optional. If omitted, all elements in ``range(256)`` are
|
||||
processed.
|
||||
|
||||
|
||||
mapping
|
||||
A container object (such as :class:`dict`) which supports arbitrary key
|
||||
lookups using the special method :meth:`__getitem__`.
|
||||
|
||||
|
||||
metaclass
|
||||
The class of a class. Class definitions create a class name, a class
|
||||
dictionary, and a list of base classes. The metaclass is responsible for
|
||||
|
@ -390,7 +390,7 @@ Glossary
|
|||
of an instance of that class, the method will get the instance object as
|
||||
its first :term:`argument` (which is usually called ``self``).
|
||||
See :term:`function` and :term:`nested scope`.
|
||||
|
||||
|
||||
mutable
|
||||
Mutable objects can change their value but keep their :func:`id`. See
|
||||
also :term:`immutable`.
|
||||
|
@ -407,7 +407,7 @@ Glossary
|
|||
:func:`collections.namedtuple`. The latter approach automatically
|
||||
provides extra features such as a self-documenting representation like
|
||||
``Employee(name='jones', title='programmer')``.
|
||||
|
||||
|
||||
namespace
|
||||
The place where a variable is stored. Namespaces are implemented as
|
||||
dictionaries. There are the local, global and builtin namespaces as well
|
||||
|
@ -419,7 +419,7 @@ Glossary
|
|||
:func:`random.seed` or :func:`itertools.izip` makes it clear that those
|
||||
functions are implemented by the :mod:`random` and :mod:`itertools`
|
||||
modules, respectively.
|
||||
|
||||
|
||||
nested scope
|
||||
The ability to refer to a variable in an enclosing definition. For
|
||||
instance, a function defined inside another function can refer to
|
||||
|
@ -427,7 +427,7 @@ Glossary
|
|||
reference and not for assignment which will always write to the innermost
|
||||
scope. In contrast, local variables both read and write in the innermost
|
||||
scope. Likewise, global variables read and write to the global namespace.
|
||||
|
||||
|
||||
new-style class
|
||||
Any class which inherits from :class:`object`. This includes all built-in
|
||||
types like :class:`list` and :class:`dict`. Only new-style classes can
|
||||
|
@ -440,7 +440,7 @@ Glossary
|
|||
Any data with state (attributes or value) and defined behavior
|
||||
(methods). Also the ultimate base class of any :term:`new-style
|
||||
class`.
|
||||
|
||||
|
||||
positional argument
|
||||
The arguments assigned to local names inside a function or method,
|
||||
determined by the order in which they were given in the call. ``*`` is
|
||||
|
@ -448,7 +448,7 @@ Glossary
|
|||
definition), or pass several arguments as a list to a function. See
|
||||
:term:`argument`.
|
||||
|
||||
Python 3000
|
||||
Python 3000
|
||||
Nickname for the next major Python version, 3.0 (coined long ago
|
||||
when the release of version 3 was something in the distant future.) This
|
||||
is also abbreviated "Py3k".
|
||||
|
@ -460,7 +460,7 @@ Glossary
|
|||
to loop over all elements of an iterable using a :keyword:`for`
|
||||
statement. Many other languages don't have this type of construct, so
|
||||
people unfamiliar with Python sometimes use a numerical counter instead::
|
||||
|
||||
|
||||
for i in range(len(food)):
|
||||
print food[i]
|
||||
|
||||
|
@ -483,7 +483,7 @@ Glossary
|
|||
dictionaries. Though popular, the technique is somewhat tricky to get
|
||||
right and is best reserved for rare cases where there are large numbers of
|
||||
instances in a memory-critical application.
|
||||
|
||||
|
||||
sequence
|
||||
An :term:`iterable` which supports efficient element access using integer
|
||||
indices via the :meth:`__getitem__` special method and defines a
|
||||
|
@ -529,7 +529,7 @@ Glossary
|
|||
virtual machine
|
||||
A computer defined entirely in software. Python's virtual machine
|
||||
executes the :term:`bytecode` emitted by the bytecode compiler.
|
||||
|
||||
|
||||
Zen of Python
|
||||
Listing of Python design principles and philosophies that are helpful in
|
||||
understanding and using the language. The listing can be found by typing
|
||||
|
|
|
@ -399,8 +399,8 @@ string. It can optionally be limited to a fixed number of characters. ::
|
|||
|
||||
curses.echo() # Enable echoing of characters
|
||||
|
||||
# Get a 15-character string, with the cursor on the top line
|
||||
s = stdscr.getstr(0,0, 15)
|
||||
# Get a 15-character string, with the cursor on the top line
|
||||
s = stdscr.getstr(0,0, 15)
|
||||
|
||||
The Python :mod:`curses.textpad` module supplies something better. With it, you
|
||||
can turn a window into a text box that supports an Emacs-like set of
|
||||
|
|
|
@ -1,5 +1,5 @@
|
|||
************************************
|
||||
Idioms and Anti-Idioms in Python
|
||||
Idioms and Anti-Idioms in Python
|
||||
************************************
|
||||
|
||||
:Author: Moshe Zadka
|
||||
|
@ -127,7 +127,7 @@ Bad example::
|
|||
# bar.py
|
||||
from foo import a
|
||||
if something():
|
||||
a = 2 # danger: foo.a != a
|
||||
a = 2 # danger: foo.a != a
|
||||
|
||||
Good example::
|
||||
|
||||
|
@ -303,6 +303,6 @@ It is usually much better to use the implicit continuation inside parenthesis:
|
|||
|
||||
This version is bulletproof::
|
||||
|
||||
value = (foo.bar()['first'][0]*baz.quux(1, 2)[5:9]
|
||||
value = (foo.bar()['first'][0]*baz.quux(1, 2)[5:9]
|
||||
+ calculate_number(10, 20)*forbulate(500, 360))
|
||||
|
||||
|
|
|
@ -145,7 +145,7 @@ than a large function that performs a complicated transformation. Small
|
|||
functions are also easier to read and to check for errors.
|
||||
|
||||
|
||||
Ease of debugging and testing
|
||||
Ease of debugging and testing
|
||||
-----------------------------
|
||||
|
||||
Testing and debugging a functional-style program is easier.
|
||||
|
@ -213,7 +213,7 @@ You can experiment with the iteration interface manually:
|
|||
Traceback (most recent call last):
|
||||
File "<stdin>", line 1, in ?
|
||||
StopIteration
|
||||
>>>
|
||||
>>>
|
||||
|
||||
Python expects iterable objects in several different contexts, the most
|
||||
important being the ``for`` statement. In the statement ``for X in Y``, Y must
|
||||
|
@ -362,7 +362,7 @@ Generator expressions are surrounded by parentheses ("()") and list
|
|||
comprehensions are surrounded by square brackets ("[]"). Generator expressions
|
||||
have the form::
|
||||
|
||||
( expression for expr in sequence1
|
||||
( expression for expr in sequence1
|
||||
if condition1
|
||||
for expr2 in sequence2
|
||||
if condition2
|
||||
|
@ -404,7 +404,7 @@ equivalent to the following Python code::
|
|||
if not (conditionN):
|
||||
continue # Skip this element
|
||||
|
||||
# Output the value of
|
||||
# Output the value of
|
||||
# the expression.
|
||||
|
||||
This means that when there are multiple ``for...in`` clauses but no ``if``
|
||||
|
@ -418,8 +418,8 @@ list is 9 elements long:
|
|||
>>> seq1 = 'abc'
|
||||
>>> seq2 = (1,2,3)
|
||||
>>> [(x,y) for x in seq1 for y in seq2]
|
||||
[('a', 1), ('a', 2), ('a', 3),
|
||||
('b', 1), ('b', 2), ('b', 3),
|
||||
[('a', 1), ('a', 2), ('a', 3),
|
||||
('b', 1), ('b', 2), ('b', 3),
|
||||
('c', 1), ('c', 2), ('c', 3)]
|
||||
|
||||
To avoid introducing an ambiguity into Python's grammar, if ``expression`` is
|
||||
|
@ -759,7 +759,7 @@ values:
|
|||
True
|
||||
>>> all([0,1,0])
|
||||
False
|
||||
>>> all([0,0,0])
|
||||
>>> all([0,0,0])
|
||||
False
|
||||
>>> all([1,1,1])
|
||||
True
|
||||
|
@ -845,7 +845,7 @@ Fredrik Lundh once suggested the following set of rules for refactoring uses of
|
|||
4) Convert the lambda to a def statement, using that name.
|
||||
5) Remove the comment.
|
||||
|
||||
I really like these rules, but you're free to disagree
|
||||
I really like these rules, but you're free to disagree
|
||||
about whether this lambda-free style is better.
|
||||
|
||||
|
||||
|
@ -970,7 +970,7 @@ operators. Some examples are ``operator.add(a, b)`` (adds two values),
|
|||
``itertools.starmap(func, iter)`` assumes that the iterable will return a stream
|
||||
of tuples, and calls ``f()`` using these tuples as the arguments::
|
||||
|
||||
itertools.starmap(os.path.join,
|
||||
itertools.starmap(os.path.join,
|
||||
[('/usr', 'bin', 'java'), ('/bin', 'python'),
|
||||
('/usr', 'bin', 'perl'),('/usr', 'bin', 'ruby')])
|
||||
=>
|
||||
|
@ -1039,9 +1039,9 @@ value and an iterator for the elements with that key.
|
|||
|
||||
::
|
||||
|
||||
city_list = [('Decatur', 'AL'), ('Huntsville', 'AL'), ('Selma', 'AL'),
|
||||
city_list = [('Decatur', 'AL'), ('Huntsville', 'AL'), ('Selma', 'AL'),
|
||||
('Anchorage', 'AK'), ('Nome', 'AK'),
|
||||
('Flagstaff', 'AZ'), ('Phoenix', 'AZ'), ('Tucson', 'AZ'),
|
||||
('Flagstaff', 'AZ'), ('Phoenix', 'AZ'), ('Tucson', 'AZ'),
|
||||
...
|
||||
]
|
||||
|
||||
|
@ -1056,7 +1056,7 @@ value and an iterator for the elements with that key.
|
|||
where
|
||||
iterator-1 =>
|
||||
('Decatur', 'AL'), ('Huntsville', 'AL'), ('Selma', 'AL')
|
||||
iterator-2 =>
|
||||
iterator-2 =>
|
||||
('Anchorage', 'AK'), ('Nome', 'AK')
|
||||
iterator-3 =>
|
||||
('Flagstaff', 'AZ'), ('Phoenix', 'AZ'), ('Tucson', 'AZ')
|
||||
|
@ -1150,7 +1150,7 @@ is equivalent to ::
|
|||
|
||||
>>> double(add(5, 6))
|
||||
22
|
||||
|
||||
|
||||
The ``unpack`` keyword is provided to work around the fact that Python functions
|
||||
are not always `fully curried <http://en.wikipedia.org/wiki/Currying>`__. By
|
||||
default, it is expected that the ``inner`` function will return a single object
|
||||
|
@ -1159,15 +1159,15 @@ and that the ``outer`` function will take a single argument. Setting the
|
|||
will be expanded before being passed to ``outer``. Put simply, ::
|
||||
|
||||
compose(f, g)(5, 6)
|
||||
|
||||
|
||||
is equivalent to::
|
||||
|
||||
f(g(5, 6))
|
||||
|
||||
|
||||
while ::
|
||||
|
||||
compose(f, g, unpack=True)(5, 6)
|
||||
|
||||
|
||||
is equivalent to::
|
||||
|
||||
f(*g(5, 6))
|
||||
|
@ -1178,20 +1178,20 @@ version that will compose any number of functions. We'll use ``reduce()``,
|
|||
``functional`` and ``functools``). ::
|
||||
|
||||
from functional import compose, partial
|
||||
|
||||
|
||||
multi_compose = partial(reduce, compose)
|
||||
|
||||
|
||||
|
||||
|
||||
We can also use ``map()``, ``compose()`` and ``partial()`` to craft a version of
|
||||
``"".join(...)`` that converts its arguments to string::
|
||||
|
||||
from functional import compose, partial
|
||||
|
||||
|
||||
join = compose("".join, partial(map, str))
|
||||
|
||||
|
||||
``flip(func)``
|
||||
|
||||
|
||||
``flip()`` wraps the callable in ``func`` and causes it to receive its
|
||||
non-keyword arguments in reverse order. ::
|
||||
|
||||
|
@ -1206,7 +1206,7 @@ non-keyword arguments in reverse order. ::
|
|||
(7, 6, 5)
|
||||
|
||||
``foldl(func, start, iterable)``
|
||||
|
||||
|
||||
``foldl()`` takes a binary function, a starting value (usually some kind of
|
||||
'zero'), and an iterable. The function is applied to the starting value and the
|
||||
first element of the list, then the result of that and the second element of the
|
||||
|
@ -1220,7 +1220,7 @@ is equivalent to::
|
|||
|
||||
f(f(f(0, 1), 2), 3)
|
||||
|
||||
|
||||
|
||||
``foldl()`` is roughly equivalent to the following recursive function::
|
||||
|
||||
def foldl(func, start, seq):
|
||||
|
@ -1298,7 +1298,7 @@ for text processing, in the section titled "Utilizing Higher-Order Functions in
|
|||
Text Processing".
|
||||
|
||||
Mertz also wrote a 3-part series of articles on functional programming
|
||||
for IBM's DeveloperWorks site; see
|
||||
for IBM's DeveloperWorks site; see
|
||||
`part 1 <http://www-128.ibm.com/developerworks/library/l-prog.html>`__,
|
||||
`part 2 <http://www-128.ibm.com/developerworks/library/l-prog2.html>`__, and
|
||||
`part 3 <http://www-128.ibm.com/developerworks/linux/library/l-prog3.html>`__,
|
||||
|
|
|
@ -1,7 +1,7 @@
|
|||
.. _regex-howto:
|
||||
|
||||
****************************
|
||||
Regular Expression HOWTO
|
||||
Regular Expression HOWTO
|
||||
****************************
|
||||
|
||||
:Author: A.M. Kuchling
|
||||
|
@ -611,7 +611,7 @@ of each one.
|
|||
is to read? ::
|
||||
|
||||
charref = re.compile(r"""
|
||||
&[#] # Start of a numeric entity reference
|
||||
&[#] # Start of a numeric entity reference
|
||||
(
|
||||
0[0-7]+ # Octal form
|
||||
| [0-9]+ # Decimal form
|
||||
|
@ -732,7 +732,7 @@ given location, they can obviously be matched an infinite number of times.
|
|||
>>> p = re.compile('\bclass\b')
|
||||
>>> print p.search('no class at all')
|
||||
None
|
||||
>>> print p.search('\b' + 'class' + '\b')
|
||||
>>> print p.search('\b' + 'class' + '\b')
|
||||
<re.MatchObject instance at 80c3ee0>
|
||||
|
||||
Second, inside a character class, where there's no use for this assertion,
|
||||
|
@ -1236,9 +1236,9 @@ It's important to keep this distinction in mind. Remember, :func:`match` will
|
|||
only report a successful match which will start at 0; if the match wouldn't
|
||||
start at zero, :func:`match` will *not* report it. ::
|
||||
|
||||
>>> print re.match('super', 'superstition').span()
|
||||
>>> print re.match('super', 'superstition').span()
|
||||
(0, 5)
|
||||
>>> print re.match('super', 'insuperable')
|
||||
>>> print re.match('super', 'insuperable')
|
||||
None
|
||||
|
||||
On the other hand, :func:`search` will scan forward through the string,
|
||||
|
|
|
@ -1,5 +1,5 @@
|
|||
****************************
|
||||
Socket Programming HOWTO
|
||||
Socket Programming HOWTO
|
||||
****************************
|
||||
|
||||
:Author: Gordon McMillan
|
||||
|
@ -63,7 +63,7 @@ your browser did something like the following::
|
|||
#create an INET, STREAMing socket
|
||||
s = socket.socket(
|
||||
socket.AF_INET, socket.SOCK_STREAM)
|
||||
#now connect to the web server on port 80
|
||||
#now connect to the web server on port 80
|
||||
# - the normal http port
|
||||
s.connect(("www.mcmillan-inc.com", 80))
|
||||
|
||||
|
@ -78,7 +78,7 @@ creates a "server socket". ::
|
|||
#create an INET, STREAMing socket
|
||||
serversocket = socket.socket(
|
||||
socket.AF_INET, socket.SOCK_STREAM)
|
||||
#bind the socket to a public host,
|
||||
#bind the socket to a public host,
|
||||
# and a well-known port
|
||||
serversocket.bind((socket.gethostname(), 80))
|
||||
#become a server socket
|
||||
|
@ -185,7 +185,7 @@ Assuming you don't want to end the connection, the simplest solution is a fixed
|
|||
length message::
|
||||
|
||||
class mysocket:
|
||||
'''demonstration class only
|
||||
'''demonstration class only
|
||||
- coded for clarity, not efficiency
|
||||
'''
|
||||
|
||||
|
@ -343,9 +343,9 @@ you'll have little trouble with it in C. ::
|
|||
|
||||
ready_to_read, ready_to_write, in_error = \
|
||||
select.select(
|
||||
potential_readers,
|
||||
potential_writers,
|
||||
potential_errs,
|
||||
potential_readers,
|
||||
potential_writers,
|
||||
potential_errs,
|
||||
timeout)
|
||||
|
||||
You pass ``select`` three lists: the first contains all sockets that you might
|
||||
|
|
|
@ -122,8 +122,8 @@ The first encoding you might think of is an array of 32-bit integers. In this
|
|||
representation, the string "Python" would look like this::
|
||||
|
||||
P y t h o n
|
||||
0x50 00 00 00 79 00 00 00 74 00 00 00 68 00 00 00 6f 00 00 00 6e 00 00 00
|
||||
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23
|
||||
0x50 00 00 00 79 00 00 00 74 00 00 00 68 00 00 00 6f 00 00 00 6e 00 00 00
|
||||
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23
|
||||
|
||||
This representation is straightforward but using it presents a number of
|
||||
problems.
|
||||
|
@ -181,7 +181,7 @@ UTF-8.) UTF-8 uses the following rules:
|
|||
between 128 and 255.
|
||||
3. Code points >0x7ff are turned into three- or four-byte sequences, where each
|
||||
byte of the sequence is between 128 and 255.
|
||||
|
||||
|
||||
UTF-8 has several convenient properties:
|
||||
|
||||
1. It can handle any Unicode code point.
|
||||
|
@ -252,7 +252,7 @@ characters greater than 127 will be treated as errors::
|
|||
>>> unicode('abcdef' + chr(255))
|
||||
Traceback (most recent call last):
|
||||
File "<stdin>", line 1, in ?
|
||||
UnicodeDecodeError: 'ascii' codec can't decode byte 0xff in position 6:
|
||||
UnicodeDecodeError: 'ascii' codec can't decode byte 0xff in position 6:
|
||||
ordinal not in range(128)
|
||||
|
||||
The ``errors`` argument specifies the response when the input string can't be
|
||||
|
@ -264,7 +264,7 @@ Unicode result). The following examples show the differences::
|
|||
>>> unicode('\x80abc', errors='strict')
|
||||
Traceback (most recent call last):
|
||||
File "<stdin>", line 1, in ?
|
||||
UnicodeDecodeError: 'ascii' codec can't decode byte 0x80 in position 0:
|
||||
UnicodeDecodeError: 'ascii' codec can't decode byte 0x80 in position 0:
|
||||
ordinal not in range(128)
|
||||
>>> unicode('\x80abc', errors='replace')
|
||||
u'\ufffdabc'
|
||||
|
@ -350,7 +350,7 @@ interprets the string using the given encoding::
|
|||
>>> u2 = utf8_version.decode('utf-8') # Decode using UTF-8
|
||||
>>> u == u2 # The two strings match
|
||||
True
|
||||
|
||||
|
||||
The low-level routines for registering and accessing the available encodings are
|
||||
found in the :mod:`codecs` module. However, the encoding and decoding functions
|
||||
returned by this module are usually more low-level than is comfortable, so I'm
|
||||
|
@ -362,8 +362,8 @@ covered here. Consult the Python documentation to learn more about this module.
|
|||
The most commonly used part of the :mod:`codecs` module is the
|
||||
:func:`codecs.open` function which will be discussed in the section on input and
|
||||
output.
|
||||
|
||||
|
||||
|
||||
|
||||
Unicode Literals in Python Source Code
|
||||
--------------------------------------
|
||||
|
||||
|
@ -381,10 +381,10 @@ arbitrary code point. Octal escapes can go up to U+01ff, which is octal 777.
|
|||
|
||||
>>> s = u"a\xac\u1234\u20ac\U00008000"
|
||||
^^^^ two-digit hex escape
|
||||
^^^^^^ four-digit Unicode escape
|
||||
^^^^^^ four-digit Unicode escape
|
||||
^^^^^^^^^^ eight-digit Unicode escape
|
||||
>>> for c in s: print ord(c),
|
||||
...
|
||||
...
|
||||
97 172 4660 8364 32768
|
||||
|
||||
Using escape sequences for code points greater than 127 is fine in small doses,
|
||||
|
@ -404,10 +404,10 @@ either the first or second line of the source file::
|
|||
|
||||
#!/usr/bin/env python
|
||||
# -*- coding: latin-1 -*-
|
||||
|
||||
|
||||
u = u'abcdé'
|
||||
print ord(u[-1])
|
||||
|
||||
|
||||
The syntax is inspired by Emacs's notation for specifying variables local to a
|
||||
file. Emacs supports many different variables, but Python only supports
|
||||
'coding'. The ``-*-`` symbols indicate to Emacs that the comment is special;
|
||||
|
@ -427,10 +427,10 @@ encoding declaration::
|
|||
When you run it with Python 2.4, it will output the following warning::
|
||||
|
||||
amk:~$ python p263.py
|
||||
sys:1: DeprecationWarning: Non-ASCII character '\xe9'
|
||||
in file p263.py on line 2, but no encoding declared;
|
||||
sys:1: DeprecationWarning: Non-ASCII character '\xe9'
|
||||
in file p263.py on line 2, but no encoding declared;
|
||||
see http://www.python.org/peps/pep-0263.html for details
|
||||
|
||||
|
||||
|
||||
Unicode Properties
|
||||
------------------
|
||||
|
@ -446,13 +446,13 @@ The following program displays some information about several characters, and
|
|||
prints the numeric value of one particular character::
|
||||
|
||||
import unicodedata
|
||||
|
||||
|
||||
u = unichr(233) + unichr(0x0bf2) + unichr(3972) + unichr(6000) + unichr(13231)
|
||||
|
||||
|
||||
for i, c in enumerate(u):
|
||||
print i, '%04x' % ord(c), unicodedata.category(c),
|
||||
print unicodedata.name(c)
|
||||
|
||||
|
||||
# Get numeric value of second character
|
||||
print unicodedata.numeric(u[1])
|
||||
|
||||
|
@ -615,7 +615,7 @@ The first list contains UTF-8-encoded filenames, and the second list contains
|
|||
the Unicode versions.
|
||||
|
||||
|
||||
|
||||
|
||||
Tips for Writing Unicode-aware Programs
|
||||
---------------------------------------
|
||||
|
||||
|
@ -661,7 +661,7 @@ this code::
|
|||
unicode_name = filename.decode(encoding)
|
||||
f = open(unicode_name, 'r')
|
||||
# ... return contents of file ...
|
||||
|
||||
|
||||
However, if an attacker could specify the ``'base64'`` encoding, they could pass
|
||||
``'L2V0Yy9wYXNzd2Q='``, which is the base-64 encoded form of the string
|
||||
``'/etc/passwd'``, to read a system file. The above code looks for ``'/'``
|
||||
|
@ -697,7 +697,7 @@ Version 1.02: posted August 16 2005. Corrects factual errors.
|
|||
.. comment Describe obscure -U switch somewhere?
|
||||
.. comment Describe use of codecs.StreamRecoder and StreamReaderWriter
|
||||
|
||||
.. comment
|
||||
.. comment
|
||||
Original outline:
|
||||
|
||||
- [ ] Unicode introduction
|
||||
|
|
|
@ -10,7 +10,7 @@
|
|||
HOWTO, available at `urllib2 - Le Manuel manquant
|
||||
<http://www.voidspace.org.uk/python/articles/urllib2_francais.shtml>`_.
|
||||
|
||||
|
||||
|
||||
|
||||
Introduction
|
||||
============
|
||||
|
@ -19,9 +19,9 @@ Introduction
|
|||
|
||||
You may also find useful the following article on fetching web resources
|
||||
with Python :
|
||||
|
||||
|
||||
* `Basic Authentication <http://www.voidspace.org.uk/python/articles/authentication.shtml>`_
|
||||
|
||||
|
||||
A tutorial on *Basic Authentication*, with examples in Python.
|
||||
|
||||
**urllib2** is a `Python <http://www.python.org>`_ module for fetching URLs
|
||||
|
@ -98,7 +98,7 @@ argument. The encoding is done using a function from the ``urllib`` library
|
|||
*not* from ``urllib2``. ::
|
||||
|
||||
import urllib
|
||||
import urllib2
|
||||
import urllib2
|
||||
|
||||
url = 'http://www.someserver.com/cgi-bin/register.cgi'
|
||||
values = {'name' : 'Michael Foord',
|
||||
|
@ -161,15 +161,15 @@ request as above, but identifies itself as a version of Internet
|
|||
Explorer [#]_. ::
|
||||
|
||||
import urllib
|
||||
import urllib2
|
||||
|
||||
import urllib2
|
||||
|
||||
url = 'http://www.someserver.com/cgi-bin/register.cgi'
|
||||
user_agent = 'Mozilla/4.0 (compatible; MSIE 5.5; Windows NT)'
|
||||
user_agent = 'Mozilla/4.0 (compatible; MSIE 5.5; Windows NT)'
|
||||
values = {'name' : 'Michael Foord',
|
||||
'location' : 'Northampton',
|
||||
'language' : 'Python' }
|
||||
headers = { 'User-Agent' : user_agent }
|
||||
|
||||
|
||||
data = urllib.urlencode(values)
|
||||
req = urllib2.Request(url, data, headers)
|
||||
response = urllib2.urlopen(req)
|
||||
|
@ -183,7 +183,7 @@ Handling Exceptions
|
|||
===================
|
||||
|
||||
*urlopen* raises :exc:`URLError` when it cannot handle a response (though as usual
|
||||
with Python APIs, builtin exceptions such as
|
||||
with Python APIs, builtin exceptions such as
|
||||
:exc:`ValueError`, :exc:`TypeError` etc. may also
|
||||
be raised).
|
||||
|
||||
|
@ -309,18 +309,18 @@ page returned. This means that as well as the code attribute, it also has read,
|
|||
geturl, and info, methods. ::
|
||||
|
||||
>>> req = urllib2.Request('http://www.python.org/fish.html')
|
||||
>>> try:
|
||||
>>> try:
|
||||
>>> urllib2.urlopen(req)
|
||||
>>> except URLError, e:
|
||||
>>> print e.code
|
||||
>>> print e.read()
|
||||
>>>
|
||||
>>>
|
||||
404
|
||||
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
|
||||
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
|
||||
"http://www.w3.org/TR/html4/loose.dtd">
|
||||
<?xml-stylesheet href="./css/ht2html.css"
|
||||
<?xml-stylesheet href="./css/ht2html.css"
|
||||
type="text/css"?>
|
||||
<html><head><title>Error 404: File Not Found</title>
|
||||
<html><head><title>Error 404: File Not Found</title>
|
||||
...... etc...
|
||||
|
||||
Wrapping it Up
|
||||
|
@ -372,7 +372,7 @@ Number 2
|
|||
print 'Error code: ', e.code
|
||||
else:
|
||||
# everything is fine
|
||||
|
||||
|
||||
|
||||
info and geturl
|
||||
===============
|
||||
|
@ -443,7 +443,7 @@ error code) requesting authentication. This specifies the authentication scheme
|
|||
and a 'realm'. The header looks like : ``Www-authenticate: SCHEME
|
||||
realm="REALM"``.
|
||||
|
||||
e.g. ::
|
||||
e.g. ::
|
||||
|
||||
Www-authenticate: Basic realm="cPanel Users"
|
||||
|
||||
|
@ -467,24 +467,24 @@ The top-level URL is the first URL that requires authentication. URLs "deeper"
|
|||
than the URL you pass to .add_password() will also match. ::
|
||||
|
||||
# create a password manager
|
||||
password_mgr = urllib2.HTTPPasswordMgrWithDefaultRealm()
|
||||
password_mgr = urllib2.HTTPPasswordMgrWithDefaultRealm()
|
||||
|
||||
# Add the username and password.
|
||||
# If we knew the realm, we could use it instead of None.
|
||||
top_level_url = "http://example.com/foo/"
|
||||
password_mgr.add_password(None, top_level_url, username, password)
|
||||
|
||||
handler = urllib2.HTTPBasicAuthHandler(password_mgr)
|
||||
handler = urllib2.HTTPBasicAuthHandler(password_mgr)
|
||||
|
||||
# create "opener" (OpenerDirector instance)
|
||||
opener = urllib2.build_opener(handler)
|
||||
opener = urllib2.build_opener(handler)
|
||||
|
||||
# use the opener to fetch a URL
|
||||
opener.open(a_url)
|
||||
opener.open(a_url)
|
||||
|
||||
# Install the opener.
|
||||
# Now all calls to urllib2.urlopen use our opener.
|
||||
urllib2.install_opener(opener)
|
||||
urllib2.install_opener(opener)
|
||||
|
||||
.. note::
|
||||
|
||||
|
@ -540,7 +540,7 @@ you can set the default timeout globally for all sockets using ::
|
|||
|
||||
# timeout in seconds
|
||||
timeout = 10
|
||||
socket.setdefaulttimeout(timeout)
|
||||
socket.setdefaulttimeout(timeout)
|
||||
|
||||
# this call to urllib2.urlopen now uses the default timeout
|
||||
# we have set in the socket module
|
||||
|
@ -557,7 +557,7 @@ Footnotes
|
|||
This document was reviewed and revised by John Lee.
|
||||
|
||||
.. [#] For an introduction to the CGI protocol see
|
||||
`Writing Web Applications in Python <http://www.pyzine.com/Issue008/Section_Articles/article_CGIOne.html>`_.
|
||||
`Writing Web Applications in Python <http://www.pyzine.com/Issue008/Section_Articles/article_CGIOne.html>`_.
|
||||
.. [#] Like Google for example. The *proper* way to use google from a program
|
||||
is to use `PyGoogle <http://pygoogle.sourceforge.net>`_ of course. See
|
||||
`Voidspace Google <http://www.voidspace.org.uk/python/recipebook.shtml#google>`_
|
||||
|
@ -574,6 +574,6 @@ This document was reviewed and revised by John Lee.
|
|||
is set to use the proxy, which urllib2 picks up on. In order to test
|
||||
scripts with a localhost server, I have to prevent urllib2 from using
|
||||
the proxy.
|
||||
.. [#] urllib2 opener for SSL proxy (CONNECT method): `ASPN Cookbook Recipe
|
||||
.. [#] urllib2 opener for SSL proxy (CONNECT method): `ASPN Cookbook Recipe
|
||||
<http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/456195>`_.
|
||||
|
||||
|
||||
|
|
|
@ -88,7 +88,7 @@ they can be run as CGI if no better option is available.
|
|||
<http://wiki.python.org/moin/CgiScripts>`_ with some additional information
|
||||
about CGI in Python.
|
||||
|
||||
|
||||
|
||||
Simple script for testing CGI
|
||||
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
|
||||
|
@ -386,7 +386,7 @@ compared with other web techniques.
|
|||
|
||||
You might be interested in some WSGI-supporting modules already contained in
|
||||
the standard library, namely:
|
||||
|
||||
|
||||
* :mod:`wsgiref` -- some tiny utilities and servers for WSGI
|
||||
|
||||
|
||||
|
@ -499,7 +499,7 @@ using these is a good idea.
|
|||
time in looking through the most popular ones. Some frameworks have their
|
||||
own template engine or have a recommentation for one. It's wise to use
|
||||
these.
|
||||
|
||||
|
||||
Popular template engines include:
|
||||
|
||||
* Mako
|
||||
|
@ -687,7 +687,7 @@ And that's still not everything. The most up-to-date information can always be
|
|||
found in the Python wiki.
|
||||
|
||||
.. seealso::
|
||||
|
||||
|
||||
The Python wiki contains an extensive list of `web frameworks
|
||||
<http://wiki.python.org/moin/WebFrameworks>`_.
|
||||
|
||||
|
|
|
@ -3,7 +3,7 @@
|
|||
.. _install-index:
|
||||
|
||||
*****************************
|
||||
Installing Python Modules
|
||||
Installing Python Modules
|
||||
*****************************
|
||||
|
||||
:Author: Greg Ward
|
||||
|
@ -18,7 +18,7 @@
|
|||
Thus, I have to be sure to explain the basics at some point:
|
||||
sys.path and PYTHONPATH at least. Should probably give pointers to
|
||||
other docs on "import site", PYTHONSTARTUP, PYTHONHOME, etc.
|
||||
|
||||
|
||||
Finally, it might be useful to include all the material from my "Care
|
||||
and Feeding of a Python Installation" talk in here somewhere. Yow!
|
||||
|
||||
|
@ -268,7 +268,7 @@ at the prompt. For example, on my Linux system, I type the three Python
|
|||
statements shown below, and get the output as shown, to find out my
|
||||
:file:`{prefix}` and :file:`{exec-prefix}`::
|
||||
|
||||
Python 2.4 (#26, Aug 7 2004, 17:19:02)
|
||||
Python 2.4 (#26, Aug 7 2004, 17:19:02)
|
||||
Type "help", "copyright", "credits" or "license" for more information.
|
||||
>>> import sys
|
||||
>>> sys.prefix
|
||||
|
@ -590,8 +590,8 @@ value of ``sys.path``. ::
|
|||
Type "help", "copyright", "credits" or "license" for more information.
|
||||
>>> import sys
|
||||
>>> sys.path
|
||||
['', '/usr/local/lib/python2.3', '/usr/local/lib/python2.3/plat-linux2',
|
||||
'/usr/local/lib/python2.3/lib-tk', '/usr/local/lib/python2.3/lib-dynload',
|
||||
['', '/usr/local/lib/python2.3', '/usr/local/lib/python2.3/plat-linux2',
|
||||
'/usr/local/lib/python2.3/lib-tk', '/usr/local/lib/python2.3/lib-dynload',
|
||||
'/usr/local/lib/python2.3/site-packages']
|
||||
>>>
|
||||
|
||||
|
|
|
@ -130,7 +130,7 @@ It also provides the following decorators:
|
|||
A decorator indicating abstract methods.
|
||||
|
||||
Using this decorator requires that the class's metaclass is :class:`ABCMeta` or
|
||||
is derived from it.
|
||||
is derived from it.
|
||||
A class that has a metaclass derived from :class:`ABCMeta`
|
||||
cannot be instantiated unless all of its abstract methods and
|
||||
properties are overridden.
|
||||
|
@ -166,7 +166,7 @@ It also provides the following decorators:
|
|||
A subclass of the built-in :func:`property`, indicating an abstract property.
|
||||
|
||||
Using this function requires that the class's metaclass is :class:`ABCMeta` or
|
||||
is derived from it.
|
||||
is derived from it.
|
||||
A class that has a metaclass derived from :class:`ABCMeta` cannot be
|
||||
instantiated unless all of its abstract methods and properties are overridden.
|
||||
The abstract properties can be called using any of the normal
|
||||
|
|
|
@ -17,7 +17,7 @@ samples in a file. AIFF-C is a newer version of the format that includes the
|
|||
ability to compress the audio data.
|
||||
|
||||
.. warning::
|
||||
|
||||
|
||||
Some operations may only work under IRIX; these will raise :exc:`ImportError`
|
||||
when attempting to import the :mod:`cl` module, which is only available on IRIX.
|
||||
|
||||
|
|
|
@ -6,7 +6,7 @@
|
|||
:platform: IRIX
|
||||
:synopsis: Audio functions on the SGI.
|
||||
:deprecated:
|
||||
|
||||
|
||||
.. deprecated:: 2.6
|
||||
The :mod:`al` module has been deprecated for removal in Python 3.0.
|
||||
|
||||
|
|
|
@ -127,7 +127,7 @@ and classes for traversing abstract syntax trees:
|
|||
Parse an expression into an AST node. Equivalent to ``compile(expr,
|
||||
filename, mode, ast.PyCF_ONLY_AST)``.
|
||||
|
||||
|
||||
|
||||
.. function:: literal_eval(node_or_string)
|
||||
|
||||
Safely evaluate an expression node or a string containing a Python
|
||||
|
@ -205,7 +205,7 @@ and classes for traversing abstract syntax trees:
|
|||
.. method:: generic_visit(node)
|
||||
|
||||
This visitor calls :meth:`visit` on all children of the node.
|
||||
|
||||
|
||||
Note that child nodes of nodes that have a custom visitor method won't be
|
||||
visited unless the visitor calls :meth:`generic_visit` or visits them
|
||||
itself.
|
||||
|
|
|
@ -265,7 +265,7 @@ sample and subtract the whole output sample from the input sample::
|
|||
in_test = inputdata[pos*2:]
|
||||
ipos, factor = audioop.findfit(in_test, out_test)
|
||||
# Optional (for better cancellation):
|
||||
# factor = audioop.findfactor(in_test[ipos*2:ipos*2+len(out_test)],
|
||||
# factor = audioop.findfactor(in_test[ipos*2:ipos*2+len(out_test)],
|
||||
# out_test)
|
||||
prefill = '\0'*(pos+ipos)*2
|
||||
postfill = '\0'*(len(inputdata)-len(prefill)-len(outputdata))
|
||||
|
|
|
@ -5,10 +5,10 @@
|
|||
.. module:: Bastion
|
||||
:synopsis: Providing restricted access to objects.
|
||||
:deprecated:
|
||||
|
||||
|
||||
.. deprecated:: 2.6
|
||||
The :mod:`Bastion` module has been removed in Python 3.0.
|
||||
|
||||
|
||||
.. moduleauthor:: Barry Warsaw <bwarsaw@python.org>
|
||||
|
||||
|
||||
|
|
|
@ -325,7 +325,7 @@ Finally, the module defines the following functions:
|
|||
|
||||
Check whether we should break here, depending on the way the breakpoint *b*
|
||||
was set.
|
||||
|
||||
|
||||
If it was set via line number, it checks if ``b.line`` is the same as the one
|
||||
in the frame also passed as argument. If the breakpoint was set via function
|
||||
name, we have to check we are in the right frame (the right function) and if
|
||||
|
@ -335,7 +335,7 @@ Finally, the module defines the following functions:
|
|||
|
||||
Determine if there is an effective (active) breakpoint at this line of code.
|
||||
Return breakpoint number or 0 if none.
|
||||
|
||||
|
||||
Called only if we know there is a breakpoint at this location. Returns the
|
||||
breakpoint that was triggered and a flag that indicates if it is ok to delete
|
||||
a temporary breakpoint.
|
||||
|
|
|
@ -172,7 +172,7 @@ Example::
|
|||
>>> import bsddb
|
||||
>>> db = bsddb.btopen('/tmp/spam.db', 'c')
|
||||
>>> for i in range(10): db['%d'%i] = '%d'% (i*i)
|
||||
...
|
||||
...
|
||||
>>> db['3']
|
||||
'9'
|
||||
>>> db.keys()
|
||||
|
@ -185,7 +185,7 @@ Example::
|
|||
('9', '81')
|
||||
>>> db.set_location('2')
|
||||
('2', '4')
|
||||
>>> db.previous()
|
||||
>>> db.previous()
|
||||
('1', '1')
|
||||
>>> for k, v in db.iteritems():
|
||||
... print k, v
|
||||
|
|
|
@ -93,7 +93,7 @@ Handling of compressed files is offered by the :class:`BZ2File` class.
|
|||
performance optimizations previously implemented in the :mod:`xreadlines`
|
||||
module.
|
||||
|
||||
.. deprecated:: 2.3
|
||||
.. deprecated:: 2.3
|
||||
This exists only for compatibility with the method by this name on
|
||||
:class:`file` objects, which is deprecated. Use ``for line in file``
|
||||
instead.
|
||||
|
|
|
@ -6,8 +6,8 @@
|
|||
:platform: IRIX
|
||||
:synopsis: Interface to the CD-ROM on Silicon Graphics systems.
|
||||
:deprecated:
|
||||
|
||||
|
||||
|
||||
|
||||
.. deprecated:: 2.6
|
||||
The :mod:`cd` module has been deprecated for removal in Python 3.0.
|
||||
|
||||
|
|
|
@ -70,9 +70,9 @@ Definition::
|
|||
|
||||
.. function:: polar(x)
|
||||
|
||||
Convert a :class:`complex` from rectangular coordinates to polar
|
||||
Convert a :class:`complex` from rectangular coordinates to polar
|
||||
coordinates. The function returns a tuple with the two elements
|
||||
*r* and *phi*. *r* is the distance from 0 and *phi* the phase
|
||||
*r* and *phi*. *r* is the distance from 0 and *phi* the phase
|
||||
angle.
|
||||
|
||||
.. versionadded:: 2.6
|
||||
|
|
|
@ -43,7 +43,7 @@ To do just the former:
|
|||
other value will cause :exc:`ValueError` to be raised.
|
||||
|
||||
.. warning::
|
||||
|
||||
|
||||
It is possible (but not likely) that the parser stops parsing with a
|
||||
successful outcome before reaching the end of the source; in this case,
|
||||
trailing symbols may be ignored instead of causing an error. For example,
|
||||
|
|
|
@ -55,34 +55,34 @@ ABC Inherits Abstract Methods Mixin
|
|||
:class:`Iterator` :class:`Iterable` ``__next__`` ``__iter__``
|
||||
:class:`Sized` ``__len__``
|
||||
:class:`Callable` ``__call__``
|
||||
|
||||
|
||||
:class:`Sequence` :class:`Sized`, ``__getitem__`` ``__contains__``. ``__iter__``, ``__reversed__``.
|
||||
:class:`Iterable`, and ``__len__`` ``index``, and ``count``
|
||||
:class:`Container`
|
||||
|
||||
:class:`Container`
|
||||
|
||||
:class:`MutableSequence` :class:`Sequence` ``__getitem__`` Inherited Sequence methods and
|
||||
``__delitem__``, ``append``, ``reverse``, ``extend``, ``pop``,
|
||||
``insert``, ``remove``, and ``__iadd__``
|
||||
and ``__len__``
|
||||
|
||||
|
||||
:class:`Set` :class:`Sized`, ``__len__``, ``__le__``, ``__lt__``, ``__eq__``, ``__ne__``,
|
||||
:class:`Iterable`, ``__iter__``, and ``__gt__``, ``__ge__``, ``__and__``, ``__or__``
|
||||
:class:`Container` ``__contains__`` ``__sub__``, ``__xor__``, and ``isdisjoint``
|
||||
|
||||
|
||||
:class:`MutableSet` :class:`Set` ``add`` and Inherited Set methods and
|
||||
``discard`` ``clear``, ``pop``, ``remove``, ``__ior__``,
|
||||
``__iand__``, ``__ixor__``, and ``__isub__``
|
||||
|
||||
|
||||
:class:`Mapping` :class:`Sized`, ``__getitem__``, ``__contains__``, ``keys``, ``items``, ``values``,
|
||||
:class:`Iterable`, ``__len__``. and ``get``, ``__eq__``, and ``__ne__``
|
||||
:class:`Container` ``__iter__``
|
||||
|
||||
|
||||
:class:`MutableMapping` :class:`Mapping` ``__getitem__`` Inherited Mapping methods and
|
||||
``__setitem__``, ``pop``, ``popitem``, ``clear``, ``update``,
|
||||
``__delitem__``, and ``setdefault``
|
||||
``__iter__``, and
|
||||
``__len__``
|
||||
|
||||
|
||||
:class:`MappingView` :class:`Sized` ``__len__``
|
||||
:class:`KeysView` :class:`MappingView`, ``__contains__``,
|
||||
:class:`Set` ``__iter__``
|
||||
|
@ -549,8 +549,8 @@ Example:
|
|||
if kwds:
|
||||
raise ValueError('Got unexpected field names: %r' % kwds.keys())
|
||||
return result
|
||||
<BLANKLINE>
|
||||
def __getnewargs__(self):
|
||||
<BLANKLINE>
|
||||
def __getnewargs__(self):
|
||||
return tuple(self)
|
||||
<BLANKLINE>
|
||||
x = property(itemgetter(0))
|
||||
|
|
|
@ -559,24 +559,24 @@ to create an instance from a repr, you must import the class names from the
|
|||
>>> import compiler
|
||||
>>> mod = compiler.parseFile("/tmp/doublelib.py")
|
||||
>>> mod
|
||||
Module('This is an example module.\n\nThis is the docstring.\n',
|
||||
Module('This is an example module.\n\nThis is the docstring.\n',
|
||||
Stmt([Function(None, 'double', ['x'], [], 0,
|
||||
'Return twice the argument',
|
||||
'Return twice the argument',
|
||||
Stmt([Return(Mul((Name('x'), Const(2))))]))]))
|
||||
>>> from compiler.ast import *
|
||||
>>> Module('This is an example module.\n\nThis is the docstring.\n',
|
||||
>>> Module('This is an example module.\n\nThis is the docstring.\n',
|
||||
... Stmt([Function(None, 'double', ['x'], [], 0,
|
||||
... 'Return twice the argument',
|
||||
... 'Return twice the argument',
|
||||
... Stmt([Return(Mul((Name('x'), Const(2))))]))]))
|
||||
Module('This is an example module.\n\nThis is the docstring.\n',
|
||||
Module('This is an example module.\n\nThis is the docstring.\n',
|
||||
Stmt([Function(None, 'double', ['x'], [], 0,
|
||||
'Return twice the argument',
|
||||
'Return twice the argument',
|
||||
Stmt([Return(Mul((Name('x'), Const(2))))]))]))
|
||||
>>> mod.doc
|
||||
'This is an example module.\n\nThis is the docstring.\n'
|
||||
>>> for node in mod.node.nodes:
|
||||
... print node
|
||||
...
|
||||
...
|
||||
Function(None, 'double', ['x'], [], 0, 'Return twice the argument',
|
||||
Stmt([Return(Mul((Name('x'), Const(2))))]))
|
||||
>>> func = mod.node.nodes[0]
|
||||
|
|
|
@ -51,7 +51,7 @@ A simple example illustrating typical use::
|
|||
username = raw_input('Python login:')
|
||||
cryptedpasswd = pwd.getpwnam(username)[1]
|
||||
if cryptedpasswd:
|
||||
if cryptedpasswd == 'x' or cryptedpasswd == '*':
|
||||
if cryptedpasswd == 'x' or cryptedpasswd == '*':
|
||||
raise "Sorry, currently no support for shadow passwords"
|
||||
cleartext = getpass.getpass()
|
||||
return crypt.crypt(cleartext, cryptedpasswd) == cryptedpasswd
|
||||
|
|
|
@ -76,7 +76,7 @@ The :mod:`csv` module defines the following functions:
|
|||
performed.
|
||||
|
||||
A short usage example::
|
||||
|
||||
|
||||
>>> import csv
|
||||
>>> spamReader = csv.reader(open('eggs.csv'), delimiter=' ', quotechar='|')
|
||||
>>> for row in spamReader:
|
||||
|
|
|
@ -266,10 +266,10 @@ efficient pickling, and in Boolean contexts, a :class:`timedelta` object is
|
|||
considered to be true if and only if it isn't equal to ``timedelta(0)``.
|
||||
|
||||
Example usage:
|
||||
|
||||
|
||||
>>> from datetime import timedelta
|
||||
>>> year = timedelta(days=365)
|
||||
>>> another_year = timedelta(weeks=40, days=84, hours=23,
|
||||
>>> another_year = timedelta(weeks=40, days=84, hours=23,
|
||||
... minutes=50, seconds=600) # adds up to 365 days
|
||||
>>> year == another_year
|
||||
True
|
||||
|
@ -517,10 +517,10 @@ Example of counting days to an event::
|
|||
True
|
||||
>>> my_birthday = date(today.year, 6, 24)
|
||||
>>> if my_birthday < today:
|
||||
... my_birthday = my_birthday.replace(year=today.year + 1)
|
||||
... my_birthday = my_birthday.replace(year=today.year + 1)
|
||||
>>> my_birthday
|
||||
datetime.date(2008, 6, 24)
|
||||
>>> time_to_birthday = abs(my_birthday - today)
|
||||
>>> time_to_birthday = abs(my_birthday - today)
|
||||
>>> time_to_birthday.days
|
||||
202
|
||||
|
||||
|
@ -1015,7 +1015,7 @@ Examples of working with datetime objects:
|
|||
>>> tt = dt.timetuple()
|
||||
>>> for it in tt: # doctest: +SKIP
|
||||
... print it
|
||||
...
|
||||
...
|
||||
2006 # year
|
||||
11 # month
|
||||
21 # day
|
||||
|
@ -1044,23 +1044,23 @@ Using datetime with tzinfo:
|
|||
... def __init__(self): # DST starts last Sunday in March
|
||||
... d = datetime(dt.year, 4, 1) # ends last Sunday in October
|
||||
... self.dston = d - timedelta(days=d.weekday() + 1)
|
||||
... d = datetime(dt.year, 11, 1)
|
||||
... d = datetime(dt.year, 11, 1)
|
||||
... self.dstoff = d - timedelta(days=d.weekday() + 1)
|
||||
... def utcoffset(self, dt):
|
||||
... return timedelta(hours=1) + self.dst(dt)
|
||||
... def dst(self, dt):
|
||||
... def dst(self, dt):
|
||||
... if self.dston <= dt.replace(tzinfo=None) < self.dstoff:
|
||||
... return timedelta(hours=1)
|
||||
... else:
|
||||
... return timedelta(0)
|
||||
... def tzname(self,dt):
|
||||
... return "GMT +1"
|
||||
...
|
||||
...
|
||||
>>> class GMT2(tzinfo):
|
||||
... def __init__(self):
|
||||
... d = datetime(dt.year, 4, 1)
|
||||
... d = datetime(dt.year, 4, 1)
|
||||
... self.dston = d - timedelta(days=d.weekday() + 1)
|
||||
... d = datetime(dt.year, 11, 1)
|
||||
... d = datetime(dt.year, 11, 1)
|
||||
... self.dstoff = d - timedelta(days=d.weekday() + 1)
|
||||
... def utcoffset(self, dt):
|
||||
... return timedelta(hours=1) + self.dst(dt)
|
||||
|
@ -1071,7 +1071,7 @@ Using datetime with tzinfo:
|
|||
... return timedelta(0)
|
||||
... def tzname(self,dt):
|
||||
... return "GMT +2"
|
||||
...
|
||||
...
|
||||
>>> gmt1 = GMT1()
|
||||
>>> # Daylight Saving Time
|
||||
>>> dt1 = datetime(2006, 11, 21, 16, 30, tzinfo=gmt1)
|
||||
|
@ -1092,7 +1092,7 @@ Using datetime with tzinfo:
|
|||
datetime.datetime(2006, 6, 14, 13, 0, tzinfo=<GMT1 object at 0x...>)
|
||||
>>> dt2.utctimetuple() == dt3.utctimetuple()
|
||||
True
|
||||
|
||||
|
||||
|
||||
|
||||
.. _datetime-time:
|
||||
|
@ -1240,12 +1240,12 @@ Instance methods:
|
|||
return ``None`` or a string object.
|
||||
|
||||
Example:
|
||||
|
||||
|
||||
>>> from datetime import time, tzinfo
|
||||
>>> class GMT1(tzinfo):
|
||||
... def utcoffset(self, dt):
|
||||
... return timedelta(hours=1)
|
||||
... def dst(self, dt):
|
||||
... return timedelta(hours=1)
|
||||
... def dst(self, dt):
|
||||
... return timedelta(0)
|
||||
... def tzname(self,dt):
|
||||
... return "Europe/Prague"
|
||||
|
@ -1476,7 +1476,7 @@ Applications that can't bear such ambiguities should avoid using hybrid
|
|||
:class:`tzinfo` subclasses; there are no ambiguities when using UTC, or any
|
||||
other fixed-offset :class:`tzinfo` subclass (such as a class representing only
|
||||
EST (fixed offset -5 hours), or only EDT (fixed offset -4 hours)).
|
||||
|
||||
|
||||
|
||||
.. _strftime-behavior:
|
||||
|
||||
|
@ -1521,7 +1521,7 @@ For an aware object:
|
|||
|
||||
The full set of format codes supported varies across platforms, because Python
|
||||
calls the platform C library's :func:`strftime` function, and platform
|
||||
variations are common.
|
||||
variations are common.
|
||||
|
||||
The following is a list of all the format codes that the C standard (1989
|
||||
version) requires, and these work on all platforms with a standard C
|
||||
|
|
|
@ -328,7 +328,7 @@ Decimal objects
|
|||
infinity ::= 'Infinity' | 'Inf'
|
||||
nan ::= 'NaN' [digits] | 'sNaN' [digits]
|
||||
numeric-value ::= decimal-part [exponent-part] | infinity
|
||||
numeric-string ::= [sign] numeric-value | [sign] nan
|
||||
numeric-string ::= [sign] numeric-value | [sign] nan
|
||||
|
||||
If *value* is a :class:`tuple`, it should have three components, a sign
|
||||
(:const:`0` for positive or :const:`1` for negative), a :class:`tuple` of
|
||||
|
@ -970,7 +970,7 @@ In addition to the three supplied contexts, new contexts can be created with the
|
|||
* :const:`ROUND_HALF_EVEN` (to nearest with ties going to nearest even integer),
|
||||
* :const:`ROUND_HALF_UP` (to nearest with ties going away from zero), or
|
||||
* :const:`ROUND_UP` (away from zero).
|
||||
* :const:`ROUND_05UP` (away from zero if last digit after rounding towards zero
|
||||
* :const:`ROUND_05UP` (away from zero if last digit after rounding towards zero
|
||||
would have been 0 or 5; otherwise towards zero)
|
||||
|
||||
The *traps* and *flags* fields list any signals to be set. Generally, new
|
||||
|
@ -1313,7 +1313,7 @@ In addition to the three supplied contexts, new contexts can be created with the
|
|||
that would be obtained by computing ``(x**y) % modulo`` with unbounded
|
||||
precision, but is computed more efficiently. It is always exact.
|
||||
|
||||
.. versionchanged:: 2.6
|
||||
.. versionchanged:: 2.6
|
||||
``y`` may now be nonintegral in ``x**y``.
|
||||
Stricter requirements for the three-argument version.
|
||||
|
||||
|
@ -1455,7 +1455,7 @@ condition.
|
|||
sqrt(-x) and x > 0
|
||||
0 ** 0
|
||||
x ** (non-integer)
|
||||
x ** Infinity
|
||||
x ** Infinity
|
||||
|
||||
|
||||
.. class:: Overflow
|
||||
|
@ -1558,7 +1558,7 @@ expanding the precision sufficiently to avoid loss of significance:
|
|||
Decimal('9.51111111')
|
||||
>>> u + (v + w)
|
||||
Decimal('9.51111111')
|
||||
>>>
|
||||
>>>
|
||||
>>> u, v, w = Decimal(20000), Decimal(-6), Decimal('6.0000003')
|
||||
>>> (u*v) + (u*w)
|
||||
Decimal('0.0060000')
|
||||
|
@ -1697,7 +1697,7 @@ to work with the :class:`Decimal` class::
|
|||
|
||||
"""
|
||||
q = Decimal(10) ** -places # 2 places --> '0.01'
|
||||
sign, digits, exp = value.quantize(q).as_tuple()
|
||||
sign, digits, exp = value.quantize(q).as_tuple()
|
||||
result = []
|
||||
digits = map(str, digits)
|
||||
build, next = result.append, digits.pop
|
||||
|
@ -1754,12 +1754,12 @@ to work with the :class:`Decimal` class::
|
|||
getcontext().prec += 2
|
||||
i, lasts, s, fact, num = 0, 0, 1, 1, 1
|
||||
while s != lasts:
|
||||
lasts = s
|
||||
lasts = s
|
||||
i += 1
|
||||
fact *= i
|
||||
num *= x
|
||||
s += num / fact
|
||||
getcontext().prec -= 2
|
||||
num *= x
|
||||
s += num / fact
|
||||
getcontext().prec -= 2
|
||||
return +s
|
||||
|
||||
def cos(x):
|
||||
|
@ -1776,13 +1776,13 @@ to work with the :class:`Decimal` class::
|
|||
getcontext().prec += 2
|
||||
i, lasts, s, fact, num, sign = 0, 0, 1, 1, 1, 1
|
||||
while s != lasts:
|
||||
lasts = s
|
||||
lasts = s
|
||||
i += 2
|
||||
fact *= i * (i-1)
|
||||
num *= x * x
|
||||
sign *= -1
|
||||
s += num / fact * sign
|
||||
getcontext().prec -= 2
|
||||
s += num / fact * sign
|
||||
getcontext().prec -= 2
|
||||
return +s
|
||||
|
||||
def sin(x):
|
||||
|
@ -1799,13 +1799,13 @@ to work with the :class:`Decimal` class::
|
|||
getcontext().prec += 2
|
||||
i, lasts, s, fact, num, sign = 1, 0, x, 1, x, 1
|
||||
while s != lasts:
|
||||
lasts = s
|
||||
lasts = s
|
||||
i += 2
|
||||
fact *= i * (i-1)
|
||||
num *= x * x
|
||||
sign *= -1
|
||||
s += num / fact * sign
|
||||
getcontext().prec -= 2
|
||||
s += num / fact * sign
|
||||
getcontext().prec -= 2
|
||||
return +s
|
||||
|
||||
|
||||
|
@ -1839,7 +1839,7 @@ the :const:`Inexact` trap is set, it is also useful for validation:
|
|||
>>> Decimal('3.214').quantize(TWOPLACES)
|
||||
Decimal('3.21')
|
||||
|
||||
>>> # Validate that a number does not exceed two places
|
||||
>>> # Validate that a number does not exceed two places
|
||||
>>> Decimal('3.21').quantize(TWOPLACES, context=Context(traps=[Inexact]))
|
||||
Decimal('3.21')
|
||||
|
||||
|
|
|
@ -428,7 +428,7 @@ The :class:`SequenceMatcher` class has this constructor:
|
|||
|
||||
.. XXX Explain why a dummy is used!
|
||||
|
||||
.. versionchanged:: 2.5
|
||||
.. versionchanged:: 2.5
|
||||
The guarantee that adjacent triples always describe non-adjacent blocks
|
||||
was implemented.
|
||||
|
||||
|
|
|
@ -5,11 +5,11 @@
|
|||
.. module:: dircache
|
||||
:synopsis: Return directory listing, with cache mechanism.
|
||||
:deprecated:
|
||||
|
||||
|
||||
.. deprecated:: 2.6
|
||||
The :mod:`dircache` module has been removed in Python 3.0.
|
||||
|
||||
|
||||
|
||||
|
||||
.. sectionauthor:: Moshe Zadka <moshez@zadka.site.co.il>
|
||||
|
||||
|
||||
|
|
|
@ -79,8 +79,8 @@ The :mod:`dis` module defines the following functions and constants:
|
|||
|
||||
Detect all offsets in the code object *code* which are jump targets, and
|
||||
return a list of these offsets.
|
||||
|
||||
|
||||
|
||||
|
||||
.. data:: opname
|
||||
|
||||
Sequence of operation names, indexable using the bytecode.
|
||||
|
@ -770,7 +770,7 @@ the more significant byte last.
|
|||
opcode finds the keyword parameters first. For each keyword argument, the value
|
||||
is on top of the key. Below the keyword parameters, the positional parameters
|
||||
are on the stack, with the right-most parameter on top. Below the parameters,
|
||||
the function object to call is on the stack. Pops all function arguments, and
|
||||
the function object to call is on the stack. Pops all function arguments, and
|
||||
the function itself off the stack, and pushes the return value.
|
||||
|
||||
|
||||
|
|
|
@ -6,11 +6,11 @@
|
|||
:platform: Unix
|
||||
:synopsis: Call C functions in shared objects.
|
||||
:deprecated:
|
||||
|
||||
|
||||
.. deprecated:: 2.6
|
||||
The :mod:`dl` module has been removed in Python 3.0. Use the :mod:`ctypes`
|
||||
module instead.
|
||||
|
||||
|
||||
.. sectionauthor:: Moshe Zadka <moshez@zadka.site.co.il>
|
||||
|
||||
The :mod:`dl` module defines an interface to the :cfunc:`dlopen` function, which
|
||||
|
@ -91,9 +91,9 @@ Dl objects, as returned by :func:`open` above, have the following methods:
|
|||
Return the pointer for the function named *name*, as a number, if it exists in
|
||||
the referenced shared object, otherwise ``None``. This is useful in code like::
|
||||
|
||||
>>> if a.sym('time'):
|
||||
>>> if a.sym('time'):
|
||||
... a.call('time')
|
||||
... else:
|
||||
... else:
|
||||
... time.time()
|
||||
|
||||
(Note that this function will return a non-zero number, as zero is the *NULL*
|
||||
|
|
|
@ -2,7 +2,7 @@
|
|||
----------------------------------------------------------
|
||||
|
||||
.. module:: email.mime
|
||||
:synopsis: Build MIME messages.
|
||||
:synopsis: Build MIME messages.
|
||||
|
||||
|
||||
Ordinarily, you get a message object structure by passing a file or some text to
|
||||
|
|
|
@ -151,7 +151,7 @@ it is deleted when the output file is closed. In-place filtering is disabled
|
|||
when standard input is read.
|
||||
|
||||
.. warning::
|
||||
|
||||
|
||||
The current implementation does not work for MS-DOS 8+3 filesystems.
|
||||
|
||||
|
||||
|
|
|
@ -6,8 +6,8 @@
|
|||
:platform: IRIX
|
||||
:synopsis: FORMS library for applications with graphical user interfaces.
|
||||
:deprecated:
|
||||
|
||||
|
||||
|
||||
|
||||
.. deprecated:: 2.6
|
||||
The :mod:`fl` module has been deprecated for removal in Python 3.0.
|
||||
|
||||
|
@ -484,8 +484,8 @@ FORMS objects have these data attributes; see the FORMS documentation:
|
|||
:platform: IRIX
|
||||
:synopsis: Constants used with the fl module.
|
||||
:deprecated:
|
||||
|
||||
|
||||
|
||||
|
||||
.. deprecated:: 2.6
|
||||
The :mod:`FL` module has been deprecated for removal in Python 3.0.
|
||||
|
||||
|
@ -506,8 +506,8 @@ source for a complete list of the defined names. Suggested use::
|
|||
:platform: IRIX
|
||||
:synopsis: Functions for loading stored FORMS designs.
|
||||
:deprecated:
|
||||
|
||||
|
||||
|
||||
|
||||
.. deprecated:: 2.6
|
||||
The :mod:`flp` module has been deprecated for removal in Python 3.0.
|
||||
|
||||
|
|
|
@ -6,7 +6,7 @@
|
|||
:platform: IRIX
|
||||
:synopsis: Font Manager interface for SGI workstations.
|
||||
:deprecated:
|
||||
|
||||
|
||||
.. deprecated:: 2.6
|
||||
The :mod:`fm` module has been deprecated for removal in Python 3.0.
|
||||
|
||||
|
|
|
@ -5,10 +5,10 @@
|
|||
.. module:: fpformat
|
||||
:synopsis: General floating point formatting functions.
|
||||
:deprecated:
|
||||
|
||||
|
||||
.. deprecated:: 2.6
|
||||
The :mod:`fpformat` module has been removed in Python 3.0.
|
||||
|
||||
|
||||
.. sectionauthor:: Moshe Zadka <moshez@zadka.site.co.il>
|
||||
|
||||
|
||||
|
|
|
@ -888,7 +888,7 @@ available. They are listed here in alphabetical order.
|
|||
.. versionchanged:: 2.5
|
||||
Use *fget*'s docstring if no *doc* given.
|
||||
|
||||
.. versionchanged:: 2.6
|
||||
.. versionchanged:: 2.6
|
||||
The ``getter``, ``setter``, and ``deleter`` attributes were added.
|
||||
|
||||
|
||||
|
@ -1178,10 +1178,10 @@ available. They are listed here in alphabetical order.
|
|||
single inheritance, "super" can be used to refer to parent classes without
|
||||
naming them explicitly, thus making the code more maintainable. This use
|
||||
closely parallels the use of "super" in other programming languages.
|
||||
|
||||
|
||||
The second use case is to support cooperative multiple inheritence in a
|
||||
dynamic execution environment. This use case is unique to Python and is
|
||||
not found in statically compiled languages or languages that only support
|
||||
dynamic execution environment. This use case is unique to Python and is
|
||||
not found in statically compiled languages or languages that only support
|
||||
single inheritance. This makes in possible to implement "diamond diagrams"
|
||||
where multiple base classes implement the same method. Good design dictates
|
||||
that this method have the same calling signature in every case (because the
|
||||
|
@ -1242,7 +1242,7 @@ available. They are listed here in alphabetical order.
|
|||
|
||||
>>> class X(object):
|
||||
... a = 1
|
||||
...
|
||||
...
|
||||
>>> X = type('X', (object,), dict(a=1))
|
||||
|
||||
.. versionadded:: 2.2
|
||||
|
@ -1397,7 +1397,7 @@ available. They are listed here in alphabetical order.
|
|||
|
||||
For example, the statement ``import spam`` results in bytecode resembling the
|
||||
following code::
|
||||
|
||||
|
||||
spam = __import__('spam', globals(), locals(), [], -1)
|
||||
|
||||
The statement ``import spam.ham`` results in this call::
|
||||
|
|
|
@ -6,8 +6,8 @@
|
|||
:platform: IRIX
|
||||
:synopsis: Functions from the Silicon Graphics Graphics Library.
|
||||
:deprecated:
|
||||
|
||||
|
||||
|
||||
|
||||
.. deprecated:: 2.6
|
||||
The :mod:`gl` module has been deprecated for removal in Python 3.0.
|
||||
|
||||
|
@ -166,8 +166,8 @@ Here is a tiny but complete example GL program in Python::
|
|||
:platform: IRIX
|
||||
:synopsis: Constants used with the gl module.
|
||||
:deprecated:
|
||||
|
||||
|
||||
|
||||
|
||||
.. deprecated:: 2.6
|
||||
The :mod:`DEVICE` module has been deprecated for removal in Python 3.0.
|
||||
|
||||
|
@ -184,8 +184,8 @@ module source file for details.
|
|||
:platform: IRIX
|
||||
:synopsis: Constants used with the gl module.
|
||||
:deprecated:
|
||||
|
||||
|
||||
|
||||
|
||||
.. deprecated:: 2.6
|
||||
The :mod:`GL` module has been deprecated for removal in Python 3.0.
|
||||
|
||||
|
|
|
@ -102,7 +102,7 @@ Using a heap to insert items at the correct place in a priority queue:
|
|||
H
|
||||
N
|
||||
|
||||
|
||||
|
||||
The module also offers three general purpose functions based on heaps.
|
||||
|
||||
|
||||
|
|
|
@ -4,7 +4,7 @@
|
|||
.. module:: htmllib
|
||||
:synopsis: A parser for HTML documents.
|
||||
:deprecated:
|
||||
|
||||
|
||||
.. deprecated:: 2.6
|
||||
The :mod:`htmllib` module has been removed in Python 3.0.
|
||||
|
||||
|
|
|
@ -230,7 +230,7 @@ Python syntax colors:
|
|||
Keywords
|
||||
orange
|
||||
|
||||
Strings
|
||||
Strings
|
||||
green
|
||||
|
||||
Comments
|
||||
|
|
|
@ -5,7 +5,7 @@
|
|||
.. module:: imageop
|
||||
:synopsis: Manipulate raw image data.
|
||||
:deprecated:
|
||||
|
||||
|
||||
.. deprecated:: 2.6
|
||||
The :mod:`imageop` module has been removed in Python 3.0.
|
||||
|
||||
|
|
|
@ -6,7 +6,7 @@
|
|||
:platform: IRIX
|
||||
:synopsis: Support for SGI imglib files.
|
||||
:deprecated:
|
||||
|
||||
|
||||
.. deprecated:: 2.6
|
||||
The :mod:`imgfile` module has been deprecated for removal in Python 3.0.
|
||||
|
||||
|
|
|
@ -215,7 +215,7 @@ I/O Base Classes
|
|||
.. method:: close()
|
||||
|
||||
Flush and close this stream. This method has no effect if the file is
|
||||
already closed. Once the file is closed, any operation on the file
|
||||
already closed. Once the file is closed, any operation on the file
|
||||
(e.g. reading or writing) will raise an :exc:`IOError`. The internal
|
||||
file descriptor isn't closed if *closefd* was False.
|
||||
|
||||
|
@ -629,7 +629,7 @@ Text I/O
|
|||
.. attribute:: line_buffering
|
||||
|
||||
Whether line buffering is enabled.
|
||||
|
||||
|
||||
|
||||
.. class:: StringIO([initial_value[, encoding[, errors[, newline]]]])
|
||||
|
||||
|
|
|
@ -76,7 +76,7 @@ loops that truncate the stream.
|
|||
|
||||
.. function:: itertools.chain.from_iterable(iterable)
|
||||
|
||||
Alternate constructor for :func:`chain`. Gets chained inputs from a
|
||||
Alternate constructor for :func:`chain`. Gets chained inputs from a
|
||||
single iterable argument that is evaluated lazily. Equivalent to::
|
||||
|
||||
@classmethod
|
||||
|
@ -93,9 +93,9 @@ loops that truncate the stream.
|
|||
|
||||
Return *r* length subsequences of elements from the input *iterable*.
|
||||
|
||||
Combinations are emitted in lexicographic sort order. So, if the
|
||||
Combinations are emitted in lexicographic sort order. So, if the
|
||||
input *iterable* is sorted, the combination tuples will be produced
|
||||
in sorted order.
|
||||
in sorted order.
|
||||
|
||||
Elements are treated as unique based on their position, not on their
|
||||
value. So if the input elements are unique, there will be no repeat
|
||||
|
@ -314,7 +314,7 @@ loops that truncate the stream.
|
|||
for i, element in enumerate(iterable):
|
||||
if i == nexti:
|
||||
yield element
|
||||
nexti = it.next()
|
||||
nexti = it.next()
|
||||
|
||||
If *start* is ``None``, then iteration starts at zero. If *step* is ``None``,
|
||||
then the step defaults to one.
|
||||
|
@ -380,12 +380,12 @@ loops that truncate the stream.
|
|||
Return successive *r* length permutations of elements in the *iterable*.
|
||||
|
||||
If *r* is not specified or is ``None``, then *r* defaults to the length
|
||||
of the *iterable* and all possible full-length permutations
|
||||
of the *iterable* and all possible full-length permutations
|
||||
are generated.
|
||||
|
||||
Permutations are emitted in lexicographic sort order. So, if the
|
||||
Permutations are emitted in lexicographic sort order. So, if the
|
||||
input *iterable* is sorted, the permutation tuples will be produced
|
||||
in sorted order.
|
||||
in sorted order.
|
||||
|
||||
Elements are treated as unique based on their position, not on their
|
||||
value. So if the input elements are unique, there will be no repeat
|
||||
|
@ -416,7 +416,7 @@ loops that truncate the stream.
|
|||
else:
|
||||
return
|
||||
|
||||
The code for :func:`permutations` can be also expressed as a subsequence of
|
||||
The code for :func:`permutations` can be also expressed as a subsequence of
|
||||
:func:`product`, filtered to exclude entries with repeated elements (those
|
||||
from the same position in the input pool)::
|
||||
|
||||
|
@ -564,7 +564,7 @@ can be combined.
|
|||
>>> data = [ 1, 4,5,6, 10, 15,16,17,18, 22, 25,26,27,28]
|
||||
>>> for k, g in groupby(enumerate(data), lambda (i,x):i-x):
|
||||
... print map(itemgetter(1), g)
|
||||
...
|
||||
...
|
||||
[1]
|
||||
[4, 5, 6]
|
||||
[10]
|
||||
|
@ -691,7 +691,7 @@ which incur interpreter overhead.
|
|||
def unique_everseen(iterable, key=None):
|
||||
"List unique elements, preserving order. Remember all elements ever seen."
|
||||
# unique_everseen('AAAABBBCCDAABBB') --> A B C D
|
||||
# unique_everseen('ABBCcAD', str.lower) --> A B C D
|
||||
# unique_everseen('ABBCcAD', str.lower) --> A B C D
|
||||
seen = set()
|
||||
seen_add = seen.add
|
||||
if key is None:
|
||||
|
|
|
@ -6,7 +6,7 @@
|
|||
:platform: IRIX
|
||||
:synopsis: Read and write image files in compressed JPEG format.
|
||||
:deprecated:
|
||||
|
||||
|
||||
.. deprecated:: 2.6
|
||||
The :mod:`jpeg` module has been deprecated for removal in Python 3.0.
|
||||
|
||||
|
|
|
@ -14,7 +14,7 @@ syntax (ECMA-262 3rd edition) used as a lightweight data interchange format.
|
|||
:mod:`marshal` and :mod:`pickle` modules.
|
||||
|
||||
Encoding basic Python object hierarchies::
|
||||
|
||||
|
||||
>>> import json
|
||||
>>> json.dumps(['foo', {'bar': ('baz', None, 1.0, 2)}])
|
||||
'["foo", {"bar": ["baz", null, 1.0, 2]}]'
|
||||
|
@ -43,12 +43,12 @@ Pretty printing::
|
|||
>>> import json
|
||||
>>> print json.dumps({'4': 5, '6': 7}, sort_keys=True, indent=4)
|
||||
{
|
||||
"4": 5,
|
||||
"4": 5,
|
||||
"6": 7
|
||||
}
|
||||
|
||||
Decoding JSON::
|
||||
|
||||
|
||||
>>> import json
|
||||
>>> json.loads('["foo", {"bar":["baz", null, 1.0, 2]}]')
|
||||
[u'foo', {u'bar': [u'baz', None, 1.0, 2]}]
|
||||
|
@ -66,7 +66,7 @@ Specializing JSON object decoding::
|
|||
... if '__complex__' in dct:
|
||||
... return complex(dct['real'], dct['imag'])
|
||||
... return dct
|
||||
...
|
||||
...
|
||||
>>> json.loads('{"__complex__": true, "real": 1, "imag": 2}',
|
||||
... object_hook=as_complex)
|
||||
(1+2j)
|
||||
|
@ -75,26 +75,26 @@ Specializing JSON object decoding::
|
|||
Decimal('1.1')
|
||||
|
||||
Extending :class:`JSONEncoder`::
|
||||
|
||||
|
||||
>>> import json
|
||||
>>> class ComplexEncoder(json.JSONEncoder):
|
||||
... def default(self, obj):
|
||||
... if isinstance(obj, complex):
|
||||
... return [obj.real, obj.imag]
|
||||
... return json.JSONEncoder.default(self, obj)
|
||||
...
|
||||
...
|
||||
>>> dumps(2 + 1j, cls=ComplexEncoder)
|
||||
'[2.0, 1.0]'
|
||||
>>> ComplexEncoder().encode(2 + 1j)
|
||||
'[2.0, 1.0]'
|
||||
>>> list(ComplexEncoder().iterencode(2 + 1j))
|
||||
['[', '2.0', ', ', '1.0', ']']
|
||||
|
||||
|
||||
|
||||
.. highlight:: none
|
||||
|
||||
Using json.tool from the shell to validate and pretty-print::
|
||||
|
||||
|
||||
$ echo '{"json":"obj"}' | python -mjson.tool
|
||||
{
|
||||
"json": "obj"
|
||||
|
@ -104,7 +104,7 @@ Using json.tool from the shell to validate and pretty-print::
|
|||
|
||||
.. highlight:: python
|
||||
|
||||
.. note::
|
||||
.. note::
|
||||
|
||||
The JSON produced by this module's default settings is a subset of
|
||||
YAML, so it may be used as a serializer for that as well.
|
||||
|
@ -368,7 +368,7 @@ Encoders and decoders
|
|||
|
||||
For example, to support arbitrary iterators, you could implement default
|
||||
like this::
|
||||
|
||||
|
||||
def default(self, o):
|
||||
try:
|
||||
iterable = iter(o)
|
||||
|
@ -392,6 +392,6 @@ Encoders and decoders
|
|||
|
||||
Encode the given object, *o*, and yield each string representation as
|
||||
available. For example::
|
||||
|
||||
|
||||
for chunk in JSONEncoder().iterencode(bigobject):
|
||||
mysocket.write(chunk)
|
||||
|
|
|
@ -494,7 +494,7 @@ Example::
|
|||
>>> import locale
|
||||
>>> loc = locale.getlocale() # get current locale
|
||||
>>> locale.setlocale(locale.LC_ALL, 'de_DE') # use German locale; name might vary with platform
|
||||
>>> locale.strcoll('f\xe4n', 'foo') # compare a string containing an umlaut
|
||||
>>> locale.strcoll('f\xe4n', 'foo') # compare a string containing an umlaut
|
||||
>>> locale.setlocale(locale.LC_ALL, '') # use user's preferred locale
|
||||
>>> locale.setlocale(locale.LC_ALL, 'C') # use default (C) locale
|
||||
>>> locale.setlocale(locale.LC_ALL, loc) # restore saved locale
|
||||
|
|
|
@ -82,7 +82,7 @@ Note the capitalization of the module name; this is a historical artifact.
|
|||
parameter can be a pathname or an ``FSSpec`` or ``FSRef`` object.
|
||||
|
||||
.. note::
|
||||
|
||||
|
||||
It is not possible to use an ``FSSpec`` in 64-bit mode.
|
||||
|
||||
|
||||
|
@ -93,7 +93,7 @@ Note the capitalization of the module name; this is a historical artifact.
|
|||
strings.
|
||||
|
||||
.. note::
|
||||
|
||||
|
||||
It is not possible to use an ``FSSpec`` in 64-bit mode.
|
||||
|
||||
.. function:: openrf(name [, mode])
|
||||
|
|
|
@ -1686,7 +1686,7 @@ due to malformed messages in the mailbox::
|
|||
# that's better than losing a message completely.
|
||||
box.lock()
|
||||
box.add(message)
|
||||
box.flush()
|
||||
box.flush()
|
||||
box.unlock()
|
||||
|
||||
# Remove original message
|
||||
|
|
|
@ -45,7 +45,7 @@ themselves supported; and recursive lists and dictionaries should not be written
|
|||
(they will cause infinite loops).
|
||||
|
||||
.. warning::
|
||||
|
||||
|
||||
On machines where C's ``long int`` type has more than 32 bits (such as the
|
||||
DEC Alpha), it is possible to create plain Python integers that are longer
|
||||
than 32 bits. If such an integer is marshaled and read back in on a machine
|
||||
|
|
|
@ -109,7 +109,7 @@ Number-theoretic and representation functions
|
|||
.. function:: isnan(x)
|
||||
|
||||
Checks if the float *x* is a NaN (not a number). NaNs are part of the
|
||||
IEEE 754 standards. Operation like but not limited to ``inf * 0``,
|
||||
IEEE 754 standards. Operation like but not limited to ``inf * 0``,
|
||||
``inf / inf`` or any operation involving a NaN, e.g. ``nan * 1``, return
|
||||
a NaN.
|
||||
|
||||
|
|
|
@ -4,7 +4,7 @@
|
|||
.. module:: mhlib
|
||||
:synopsis: Manipulate MH mailboxes from Python.
|
||||
:deprecated:
|
||||
|
||||
|
||||
.. deprecated:: 2.6
|
||||
The :mod:`mhlib` module has been removed in Python 3.0. Use the
|
||||
:mod:`mailbox` instead.
|
||||
|
|
|
@ -93,7 +93,7 @@ memory but does not update the underlying file.
|
|||
will be relative to the offset from the beginning of the file. *offset*
|
||||
defaults to 0. *offset* must be a multiple of the PAGESIZE or
|
||||
ALLOCATIONGRANULARITY.
|
||||
|
||||
|
||||
This example shows a simple way of using :class:`mmap`::
|
||||
|
||||
import mmap
|
||||
|
|
|
@ -18,7 +18,7 @@ documentation.
|
|||
|
||||
The module implements both the normal and wide char variants of the console I/O
|
||||
api. The normal API deals only with ASCII characters and is of limited use
|
||||
for internationalized applications. The wide char API should be used where
|
||||
for internationalized applications. The wide char API should be used where
|
||||
ever possible
|
||||
|
||||
.. _msvcrt-files:
|
||||
|
@ -98,13 +98,13 @@ Console I/O
|
|||
return the keycode. The :kbd:`Control-C` keypress cannot be read with this
|
||||
function.
|
||||
|
||||
|
||||
|
||||
.. function:: getwch()
|
||||
|
||||
Wide char variant of :func:`getch`, returning a Unicode value.
|
||||
|
||||
|
||||
.. versionadded:: 2.6
|
||||
|
||||
|
||||
|
||||
.. function:: getche()
|
||||
|
||||
|
@ -115,7 +115,7 @@ Console I/O
|
|||
.. function:: getwche()
|
||||
|
||||
Wide char variant of :func:`getche`, returning a Unicode value.
|
||||
|
||||
|
||||
.. versionadded:: 2.6
|
||||
|
||||
|
||||
|
@ -123,24 +123,24 @@ Console I/O
|
|||
|
||||
Print the character *char* to the console without buffering.
|
||||
|
||||
|
||||
|
||||
.. function:: putwch(unicode_char)
|
||||
|
||||
Wide char variant of :func:`putch`, accepting a Unicode value.
|
||||
|
||||
|
||||
.. versionadded:: 2.6
|
||||
|
||||
|
||||
|
||||
.. function:: ungetch(char)
|
||||
|
||||
Cause the character *char* to be "pushed back" into the console buffer; it will
|
||||
be the next character read by :func:`getch` or :func:`getche`.
|
||||
|
||||
|
||||
|
||||
.. function:: ungetwch(unicode_char)
|
||||
|
||||
Wide char variant of :func:`ungetch`, accepting a Unicode value.
|
||||
|
||||
|
||||
.. versionadded:: 2.6
|
||||
|
||||
|
||||
|
|
|
@ -21,9 +21,9 @@ Windows.
|
|||
.. warning::
|
||||
|
||||
Some of this package's functionality requires a functioning shared semaphore
|
||||
implementation on the host operating system. Without one, the
|
||||
:mod:`multiprocessing.synchronize` module will be disabled, and attempts to
|
||||
import it will result in an :exc:`ImportError`. See
|
||||
implementation on the host operating system. Without one, the
|
||||
:mod:`multiprocessing.synchronize` module will be disabled, and attempts to
|
||||
import it will result in an :exc:`ImportError`. See
|
||||
:issue:`3770` for additional information.
|
||||
|
||||
.. note::
|
||||
|
@ -38,7 +38,7 @@ Windows.
|
|||
>>> p = Pool(5)
|
||||
>>> def f(x):
|
||||
... return x*x
|
||||
...
|
||||
...
|
||||
>>> p.map(f, [1,2,3])
|
||||
Process PoolWorker-1:
|
||||
Process PoolWorker-2:
|
||||
|
@ -77,11 +77,11 @@ To show the individual process IDs involved, here is an expanded example::
|
|||
print 'module name:', __name__
|
||||
print 'parent process:', os.getppid()
|
||||
print 'process id:', os.getpid()
|
||||
|
||||
|
||||
def f(name):
|
||||
info('function f')
|
||||
print 'hello', name
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
info('main line')
|
||||
p = Process(target=f, args=('bob',))
|
||||
|
@ -543,7 +543,7 @@ For an example of the usage of queues for interprocess communication see
|
|||
|
||||
.. method:: put(item[, block[, timeout]])
|
||||
|
||||
Put item into the queue. If the optional argument *block* is ``True``
|
||||
Put item into the queue. If the optional argument *block* is ``True``
|
||||
(the default) and *timeout* is ``None`` (the default), block if necessary until
|
||||
a free slot is available. If *timeout* is a positive number, it blocks at
|
||||
most *timeout* seconds and raises the :exc:`Queue.Full` exception if no
|
||||
|
@ -858,7 +858,7 @@ object -- see :ref:`multiprocessing-managers`.
|
|||
acceptable. If *block* is ``True`` and *timeout* is not ``None`` then it
|
||||
specifies a timeout in seconds. If *block* is ``False`` then *timeout* is
|
||||
ignored.
|
||||
|
||||
|
||||
Note that on OS/X ``sem_timedwait`` is unsupported, so timeout arguments
|
||||
for these will be ignored.
|
||||
|
||||
|
@ -1135,22 +1135,22 @@ their parent process exits. The manager classes are defined in the
|
|||
server process which is using the given address and authentication key.
|
||||
|
||||
.. method:: get_server()
|
||||
|
||||
|
||||
Returns a :class:`Server` object which represents the actual server under
|
||||
the control of the Manager. The :class:`Server` object supports the
|
||||
the control of the Manager. The :class:`Server` object supports the
|
||||
:meth:`serve_forever` method:
|
||||
|
||||
|
||||
>>> from multiprocessing.managers import BaseManager
|
||||
>>> m = BaseManager(address=('', 50000), authkey='abc'))
|
||||
>>> server = m.get_server()
|
||||
>>> s.serve_forever()
|
||||
|
||||
|
||||
:class:`Server` additionally have an :attr:`address` attribute.
|
||||
|
||||
.. method:: connect()
|
||||
|
||||
|
||||
Connect a local manager object to a remote manager process:
|
||||
|
||||
|
||||
>>> from multiprocessing.managers import BaseManager
|
||||
>>> m = BaseManager(address='127.0.0.1', authkey='abc))
|
||||
>>> m.connect()
|
||||
|
@ -1360,7 +1360,7 @@ Another client can also use it::
|
|||
>>> queue.get()
|
||||
'hello'
|
||||
|
||||
Local processes can also access that queue, using the code from above on the
|
||||
Local processes can also access that queue, using the code from above on the
|
||||
client to access it remotely::
|
||||
|
||||
>>> from multiprocessing import Process, Queue
|
||||
|
@ -1371,12 +1371,12 @@ client to access it remotely::
|
|||
... super(Worker, self).__init__()
|
||||
... def run(self):
|
||||
... self.q.put('local hello')
|
||||
...
|
||||
...
|
||||
>>> queue = Queue()
|
||||
>>> w = Worker(queue)
|
||||
>>> w.start()
|
||||
>>> class QueueManager(BaseManager): pass
|
||||
...
|
||||
...
|
||||
>>> QueueManager.register('get_queue', callable=lambda: queue)
|
||||
>>> m = QueueManager(address=('', 50000), authkey='abracadabra')
|
||||
>>> s = m.get_server()
|
||||
|
@ -2120,7 +2120,7 @@ Some simple benchmarks comparing :mod:`multiprocessing` with :mod:`threading`:
|
|||
.. literalinclude:: ../includes/mp_benchmarks.py
|
||||
|
||||
An example/demo of how to use the :class:`managers.SyncManager`, :class:`Process`
|
||||
and others to build a system which can distribute processes and work via a
|
||||
and others to build a system which can distribute processes and work via a
|
||||
distributed queue to a "cluster" of machines on a network, accessible via SSH.
|
||||
You will need to have private key authentication for all hosts configured for
|
||||
this to work.
|
||||
|
|
|
@ -5,7 +5,7 @@
|
|||
.. module:: mutex
|
||||
:synopsis: Lock and queue for mutual exclusion.
|
||||
:deprecated:
|
||||
|
||||
|
||||
.. deprecated::
|
||||
The :mod:`mutex` module has been removed in Python 3.0.
|
||||
|
||||
|
|
|
@ -24,16 +24,16 @@ about a newsgroup and print the subjects of the last 10 articles::
|
|||
Group comp.lang.python has 59 articles, range 3742 to 3803
|
||||
>>> resp, subs = s.xhdr('subject', first + '-' + last)
|
||||
>>> for id, sub in subs[-10:]: print id, sub
|
||||
...
|
||||
...
|
||||
3792 Re: Removing elements from a list while iterating...
|
||||
3793 Re: Who likes Info files?
|
||||
3794 Emacs and doc strings
|
||||
3795 a few questions about the Mac implementation
|
||||
3796 Re: executable python scripts
|
||||
3797 Re: executable python scripts
|
||||
3798 Re: a few questions about the Mac implementation
|
||||
3798 Re: a few questions about the Mac implementation
|
||||
3799 Re: PROPOSAL: A Generic Python Object Interface for Python C Modules
|
||||
3802 Re: executable python scripts
|
||||
3802 Re: executable python scripts
|
||||
3803 Re: \POSIX{} wait and SIGCHLD
|
||||
>>> s.quit()
|
||||
'205 news.cwi.nl closing connection. Goodbye.'
|
||||
|
|
|
@ -7,7 +7,7 @@
|
|||
|
||||
|
||||
.. testsetup::
|
||||
|
||||
|
||||
import operator
|
||||
from operator import itemgetter
|
||||
|
||||
|
@ -437,7 +437,7 @@ objects.
|
|||
|
||||
>>> class C:
|
||||
... pass
|
||||
...
|
||||
...
|
||||
>>> import operator
|
||||
>>> obj = C()
|
||||
>>> operator.isMappingType(obj)
|
||||
|
@ -547,9 +547,9 @@ expect a function argument.
|
|||
def g(obj):
|
||||
return tuple(obj[item] for item in items)
|
||||
return g
|
||||
|
||||
The items can be any type accepted by the operand's :meth:`__getitem__`
|
||||
method. Dictionaries accept any hashable value. Lists, tuples, and
|
||||
|
||||
The items can be any type accepted by the operand's :meth:`__getitem__`
|
||||
method. Dictionaries accept any hashable value. Lists, tuples, and
|
||||
strings accept an index or a slice:
|
||||
|
||||
>>> itemgetter(1)('ABCDEFG')
|
||||
|
|
|
@ -799,7 +799,7 @@ And to define an option with only a long option string::
|
|||
The keyword arguments define attributes of the new Option object. The most
|
||||
important option attribute is :attr:`action`, and it largely determines which
|
||||
other attributes are relevant or required. If you pass irrelevant option
|
||||
attributes, or fail to pass required ones, :mod:`optparse` raises an
|
||||
attributes, or fail to pass required ones, :mod:`optparse` raises an
|
||||
:exc:`OptionError` exception explaining your mistake.
|
||||
|
||||
An option's *action* determines what :mod:`optparse` does when it encounters
|
||||
|
|
|
@ -368,7 +368,7 @@ These functions create new file objects. (See also :func:`open`.)
|
|||
is returned. Availability: Unix, Windows.
|
||||
|
||||
.. deprecated:: 2.6
|
||||
This function is obsolete. Use the :mod:`subprocess` module. Check
|
||||
This function is obsolete. Use the :mod:`subprocess` module. Check
|
||||
especially the :ref:`subprocess-replacements` section.
|
||||
|
||||
.. versionchanged:: 2.0
|
||||
|
@ -418,7 +418,7 @@ functions, see :ref:`popen2-flow-control`.
|
|||
child_stdout)``.
|
||||
|
||||
.. deprecated:: 2.6
|
||||
This function is obsolete. Use the :mod:`subprocess` module. Check
|
||||
This function is obsolete. Use the :mod:`subprocess` module. Check
|
||||
especially the :ref:`subprocess-replacements` section.
|
||||
|
||||
Availability: Unix, Windows.
|
||||
|
@ -432,7 +432,7 @@ functions, see :ref:`popen2-flow-control`.
|
|||
child_stdout, child_stderr)``.
|
||||
|
||||
.. deprecated:: 2.6
|
||||
This function is obsolete. Use the :mod:`subprocess` module. Check
|
||||
This function is obsolete. Use the :mod:`subprocess` module. Check
|
||||
especially the :ref:`subprocess-replacements` section.
|
||||
|
||||
Availability: Unix, Windows.
|
||||
|
@ -446,7 +446,7 @@ functions, see :ref:`popen2-flow-control`.
|
|||
child_stdout_and_stderr)``.
|
||||
|
||||
.. deprecated:: 2.6
|
||||
This function is obsolete. Use the :mod:`subprocess` module. Check
|
||||
This function is obsolete. Use the :mod:`subprocess` module. Check
|
||||
especially the :ref:`subprocess-replacements` section.
|
||||
|
||||
Availability: Unix, Windows.
|
||||
|
@ -1449,7 +1449,7 @@ to be ignored.
|
|||
These functions all execute a new program, replacing the current process; they
|
||||
do not return. On Unix, the new executable is loaded into the current process,
|
||||
and will have the same process id as the caller. Errors will be reported as
|
||||
:exc:`OSError` exceptions.
|
||||
:exc:`OSError` exceptions.
|
||||
|
||||
The current process is replaced immediately. Open file objects and
|
||||
descriptors are not flushed, so if there may be data buffered
|
||||
|
@ -1481,7 +1481,7 @@ to be ignored.
|
|||
used to define the environment variables for the new process (these are used
|
||||
instead of the current process' environment); the functions :func:`execl`,
|
||||
:func:`execlp`, :func:`execv`, and :func:`execvp` all cause the new process to
|
||||
inherit the environment of the current process.
|
||||
inherit the environment of the current process.
|
||||
|
||||
Availability: Unix, Windows.
|
||||
|
||||
|
@ -1718,7 +1718,7 @@ written in Python, such as a mail server's external command delivery program.
|
|||
|
||||
(Note that the :mod:`subprocess` module provides more powerful facilities for
|
||||
spawning new processes and retrieving their results; using that module is
|
||||
preferable to using these functions. Check specially the *Replacing Older
|
||||
preferable to using these functions. Check specially the *Replacing Older
|
||||
Functions with the subprocess Module* section in that documentation page.)
|
||||
|
||||
If *mode* is :const:`P_NOWAIT`, this function returns the process id of the new
|
||||
|
|
|
@ -18,26 +18,26 @@ the standard audio interface for Linux and recent versions of FreeBSD.
|
|||
use ALSA, you'll have to make sure its OSS compatibility layer
|
||||
is active to use ossaudiodev, but you're gonna need it for the vast
|
||||
majority of Linux audio apps anyways.
|
||||
|
||||
|
||||
Sounds like things are also complicated for other BSDs. In response
|
||||
to my python-dev query, Thomas Wouters said:
|
||||
|
||||
|
||||
> Likewise, googling shows OpenBSD also uses OSS/Free -- the commercial
|
||||
> OSS installation manual tells you to remove references to OSS/Free from the
|
||||
> kernel :)
|
||||
|
||||
|
||||
but Aleksander Piotrowsk actually has an OpenBSD box, and he quotes
|
||||
from its <soundcard.h>:
|
||||
> * WARNING! WARNING!
|
||||
> * This is an OSS (Linux) audio emulator.
|
||||
> * Use the Native NetBSD API for developing new code, and this
|
||||
> * only for compiling Linux programs.
|
||||
|
||||
|
||||
There's also an ossaudio manpage on OpenBSD that explains things
|
||||
further. Presumably NetBSD and OpenBSD have a different standard
|
||||
audio interface. That's the great thing about standards, there are so
|
||||
many to choose from ... ;-)
|
||||
|
||||
|
||||
This probably all warrants a footnote or two, but I don't understand
|
||||
things well enough right now to write it! --GPW
|
||||
|
||||
|
|
|
@ -70,7 +70,7 @@ also available for Python:
|
|||
Robin Dunn.
|
||||
|
||||
PyGTK, PyQt, and wxPython, all have a modern look and feel and more
|
||||
widgets than Tkinter. In addition, there are many other GUI toolkits for
|
||||
widgets than Tkinter. In addition, there are many other GUI toolkits for
|
||||
Python, both cross-platform, and platform-specific. See the `GUI Programming
|
||||
<http://wiki.python.org/moin/GuiProgramming>`_ page in the Python Wiki for a
|
||||
much more complete list, and also for links to documents where the
|
||||
|
|
|
@ -37,7 +37,7 @@ of the debugger is::
|
|||
(Pdb) continue
|
||||
NameError: 'spam'
|
||||
> <string>(1)?()
|
||||
(Pdb)
|
||||
(Pdb)
|
||||
|
||||
:file:`pdb.py` can also be invoked as a script to debug other scripts. For
|
||||
example::
|
||||
|
@ -68,7 +68,7 @@ Typical usage to inspect a crashed program is::
|
|||
>>> pdb.pm()
|
||||
> ./mymodule.py(3)test2()
|
||||
-> print spam
|
||||
(Pdb)
|
||||
(Pdb)
|
||||
|
||||
The module defines the following functions; each enters the debugger in a
|
||||
slightly different way:
|
||||
|
@ -109,7 +109,7 @@ slightly different way:
|
|||
|
||||
.. function:: post_mortem([traceback])
|
||||
|
||||
Enter post-mortem debugging of the given *traceback* object. If no
|
||||
Enter post-mortem debugging of the given *traceback* object. If no
|
||||
*traceback* is given, it uses the one of the exception that is currently
|
||||
being handled (an exception must be being handled if the default is to be
|
||||
used).
|
||||
|
|
|
@ -413,7 +413,7 @@ Pickling and unpickling normal class instances
|
|||
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
|
||||
.. method:: object.__getinitargs__()
|
||||
|
||||
|
||||
When a pickled class instance is unpickled, its :meth:`__init__` method is
|
||||
normally *not* invoked. If it is desirable that the :meth:`__init__` method
|
||||
be called on unpickling, an old-style class can define a method
|
||||
|
@ -430,31 +430,31 @@ Pickling and unpickling normal class instances
|
|||
is affected by the values passed to the :meth:`__new__` method for the type
|
||||
(as it is for tuples and strings). Instances of a :term:`new-style class`
|
||||
``C`` are created using ::
|
||||
|
||||
|
||||
obj = C.__new__(C, *args)
|
||||
|
||||
|
||||
where *args* is the result of calling :meth:`__getnewargs__` on the original
|
||||
object; if there is no :meth:`__getnewargs__`, an empty tuple is assumed.
|
||||
|
||||
.. method:: object.__getstate__()
|
||||
|
||||
|
||||
Classes can further influence how their instances are pickled; if the class
|
||||
defines the method :meth:`__getstate__`, it is called and the return state is
|
||||
pickled as the contents for the instance, instead of the contents of the
|
||||
instance's dictionary. If there is no :meth:`__getstate__` method, the
|
||||
instance's :attr:`__dict__` is pickled.
|
||||
|
||||
.. method:: object.__setstate__()
|
||||
|
||||
.. method:: object.__setstate__()
|
||||
|
||||
Upon unpickling, if the class also defines the method :meth:`__setstate__`,
|
||||
it is called with the unpickled state. [#]_ If there is no
|
||||
:meth:`__setstate__` method, the pickled state must be a dictionary and its
|
||||
items are assigned to the new instance's dictionary. If a class defines both
|
||||
:meth:`__getstate__` and :meth:`__setstate__`, the state object needn't be a
|
||||
dictionary and these methods can do what they want. [#]_
|
||||
|
||||
|
||||
.. warning::
|
||||
|
||||
|
||||
For :term:`new-style class`\es, if :meth:`__getstate__` returns a false
|
||||
value, the :meth:`__setstate__` method will not be called.
|
||||
|
||||
|
@ -463,7 +463,7 @@ Pickling and unpickling extension types
|
|||
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
|
||||
.. method:: object.__reduce__()
|
||||
|
||||
|
||||
When the :class:`Pickler` encounters an object of a type it knows nothing
|
||||
about --- such as an extension type --- it looks in two places for a hint of
|
||||
how to pickle it. One alternative is for the object to implement a
|
||||
|
@ -518,7 +518,7 @@ Pickling and unpickling extension types
|
|||
is primarily used for dictionary subclasses, but may be used by other
|
||||
classes as long as they implement :meth:`__setitem__`.
|
||||
|
||||
.. method:: object.__reduce_ex__(protocol)
|
||||
.. method:: object.__reduce_ex__(protocol)
|
||||
|
||||
It is sometimes useful to know the protocol version when implementing
|
||||
:meth:`__reduce__`. This can be done by implementing a method named
|
||||
|
|
|
@ -9,7 +9,7 @@
|
|||
|
||||
|
||||
.. deprecated:: 2.6
|
||||
This module is obsolete. Use the :mod:`subprocess` module. Check
|
||||
This module is obsolete. Use the :mod:`subprocess` module. Check
|
||||
especially the :ref:`subprocess-replacements` section.
|
||||
|
||||
This module allows you to spawn processes and connect to their
|
||||
|
|
|
@ -51,17 +51,17 @@ examine the results of a profile operation.
|
|||
|
||||
The Python standard library provides three different profilers:
|
||||
|
||||
#. :mod:`cProfile` is recommended for most users; it's a C extension
|
||||
#. :mod:`cProfile` is recommended for most users; it's a C extension
|
||||
with reasonable overhead
|
||||
that makes it suitable for profiling long-running programs.
|
||||
that makes it suitable for profiling long-running programs.
|
||||
Based on :mod:`lsprof`,
|
||||
contributed by Brett Rosen and Ted Czotter.
|
||||
contributed by Brett Rosen and Ted Czotter.
|
||||
|
||||
.. versionadded:: 2.5
|
||||
|
||||
#. :mod:`profile`, a pure Python module whose interface is imitated by
|
||||
:mod:`cProfile`. Adds significant overhead to profiled programs.
|
||||
If you're trying to extend
|
||||
:mod:`cProfile`. Adds significant overhead to profiled programs.
|
||||
If you're trying to extend
|
||||
the profiler in some way, the task might be easier with this module.
|
||||
Copyright © 1994, by InfoSeek Corporation.
|
||||
|
||||
|
@ -72,7 +72,7 @@ The Python standard library provides three different profilers:
|
|||
the overhead of profiling, at the expense of longer data
|
||||
post-processing times. It is no longer maintained and may be
|
||||
dropped in a future version of Python.
|
||||
|
||||
|
||||
|
||||
.. versionchanged:: 2.5
|
||||
The results should be more meaningful than in the past: the timing core
|
||||
|
@ -276,24 +276,24 @@ reading the source code for these modules.
|
|||
that the text string in the far right column was used to sort the output. The
|
||||
column headings include:
|
||||
|
||||
ncalls
|
||||
ncalls
|
||||
for the number of calls,
|
||||
|
||||
tottime
|
||||
tottime
|
||||
for the total time spent in the given function (and excluding time made in calls
|
||||
to sub-functions),
|
||||
|
||||
percall
|
||||
percall
|
||||
is the quotient of ``tottime`` divided by ``ncalls``
|
||||
|
||||
cumtime
|
||||
cumtime
|
||||
is the total time spent in this and all subfunctions (from invocation till
|
||||
exit). This figure is accurate *even* for recursive functions.
|
||||
|
||||
percall
|
||||
percall
|
||||
is the quotient of ``cumtime`` divided by primitive calls
|
||||
|
||||
filename:lineno(function)
|
||||
filename:lineno(function)
|
||||
provides the respective data of each function
|
||||
|
||||
When there are two numbers in the first column (for example, ``43/3``), then the
|
||||
|
|
|
@ -182,9 +182,9 @@ XMLParser Objects
|
|||
|
||||
.. attribute:: xmlparser.buffer_size
|
||||
|
||||
The size of the buffer used when :attr:`buffer_text` is true.
|
||||
A new buffer size can be set by assigning a new integer value
|
||||
to this attribute.
|
||||
The size of the buffer used when :attr:`buffer_text` is true.
|
||||
A new buffer size can be set by assigning a new integer value
|
||||
to this attribute.
|
||||
When the size is changed, the buffer will be flushed.
|
||||
|
||||
.. versionadded:: 2.3
|
||||
|
|
|
@ -994,14 +994,14 @@ method of :class:`MatchObject` in the following manner:
|
|||
|
||||
>>> pair.match("717ak").group(1)
|
||||
'7'
|
||||
|
||||
|
||||
# Error because re.match() returns None, which doesn't have a group() method:
|
||||
>>> pair.match("718ak").group(1)
|
||||
Traceback (most recent call last):
|
||||
File "<pyshell#23>", line 1, in <module>
|
||||
re.match(r".*(.).*\1", "718ak").group(1)
|
||||
AttributeError: 'NoneType' object has no attribute 'group'
|
||||
|
||||
|
||||
>>> pair.match("354aa").group(1)
|
||||
'a'
|
||||
|
||||
|
@ -1110,7 +1110,7 @@ where the search is to start:
|
|||
Making a Phonebook
|
||||
^^^^^^^^^^^^^^^^^^
|
||||
|
||||
:func:`split` splits a string into a list delimited by the passed pattern. The
|
||||
:func:`split` splits a string into a list delimited by the passed pattern. The
|
||||
method is invaluable for converting textual data into data structures that can be
|
||||
easily read and modified by Python as demonstrated in the following example that
|
||||
creates a phonebook.
|
||||
|
@ -1119,7 +1119,7 @@ First, here is the input. Normally it may come from a file, here we are using
|
|||
triple-quoted string syntax:
|
||||
|
||||
>>> input = """Ross McFluff: 834.345.1254 155 Elm Street
|
||||
...
|
||||
...
|
||||
... Ronald Heathmore: 892.345.3428 436 Finley Avenue
|
||||
... Frank Burger: 925.541.7625 662 South Dogwood Way
|
||||
...
|
||||
|
|
|
@ -5,7 +5,7 @@
|
|||
.. module:: rexec
|
||||
:synopsis: Basic restricted execution framework.
|
||||
:deprecated:
|
||||
|
||||
|
||||
.. deprecated:: 2.6
|
||||
The :mod:`rexec` module has been removed in Python 3.0.
|
||||
|
||||
|
@ -272,7 +272,7 @@ Let us say that we want a slightly more relaxed policy than the standard
|
|||
pass
|
||||
elif mode in ('w', 'wb', 'a', 'ab'):
|
||||
# check filename : must begin with /tmp/
|
||||
if file[:5]!='/tmp/':
|
||||
if file[:5]!='/tmp/':
|
||||
raise IOError, "can't write outside /tmp"
|
||||
elif (string.find(file, '/../') >= 0 or
|
||||
file[:3] == '../' or file[-3:] == '/..'):
|
||||
|
|
|
@ -61,6 +61,6 @@ Completer objects have the following method:
|
|||
If called for a dotted name, it will try to evaluate anything without obvious
|
||||
side-effects (functions will not be evaluated, but it can generate calls to
|
||||
:meth:`__getattr__`) up to the last part, and find matches for the rest via the
|
||||
:func:`dir` function. Any exception raised during the evaluation of the
|
||||
:func:`dir` function. Any exception raised during the evaluation of the
|
||||
expression is caught, silenced and :const:`None` is returned.
|
||||
|
||||
|
|
|
@ -13,7 +13,7 @@
|
|||
single: World Wide Web
|
||||
single: URL
|
||||
single: robots.txt
|
||||
|
||||
|
||||
.. note::
|
||||
The :mod:`robotparser` module has been renamed :mod:`urllib.robotparser` in
|
||||
Python 3.0.
|
||||
|
|
|
@ -42,7 +42,7 @@ Example::
|
|||
930343700.276
|
||||
|
||||
In multi-threaded environments, the :class:`scheduler` class has limitations
|
||||
with respect to thread-safety, inability to insert a new task before
|
||||
with respect to thread-safety, inability to insert a new task before
|
||||
the one currently pending in a running scheduler, and holding up the main
|
||||
thread until the event queue is empty. Instead, the preferred approach
|
||||
is to use the :class:`threading.Timer` class instead.
|
||||
|
@ -59,7 +59,7 @@ Example::
|
|||
... Timer(5, print_time, ()).start()
|
||||
... Timer(10, print_time, ()).start()
|
||||
... time.sleep(11) # sleep while time-delay events execute
|
||||
... print time.time()
|
||||
... print time.time()
|
||||
...
|
||||
>>> print_some_times()
|
||||
930343690.257
|
||||
|
|
|
@ -4,7 +4,7 @@
|
|||
.. module:: sgmllib
|
||||
:synopsis: Only as much of an SGML parser as needed to parse HTML.
|
||||
:deprecated:
|
||||
|
||||
|
||||
.. deprecated:: 2.6
|
||||
The :mod:`sgmllib` module has been removed in Python 3.0.
|
||||
|
||||
|
|
|
@ -20,7 +20,7 @@ copying and removal. For operations on individual files, see also the
|
|||
|
||||
Even the higher-level file copying functions (:func:`copy`, :func:`copy2`)
|
||||
can't copy all file metadata.
|
||||
|
||||
|
||||
On POSIX platforms, this means that file owner and group are lost as well
|
||||
as ACLs. On Mac OS, the resource fork and other metadata are not used.
|
||||
This means that resources will be lost and file type and creator codes will
|
||||
|
@ -124,7 +124,7 @@ copying and removal. For operations on individual files, see also the
|
|||
error. Copy permissions and times of directories using :func:`copystat`.
|
||||
|
||||
.. versionchanged:: 2.6
|
||||
Added the *ignore* argument to be able to influence what is being copied.
|
||||
Added the *ignore* argument to be able to influence what is being copied.
|
||||
|
||||
|
||||
.. function:: rmtree(path[, ignore_errors[, onerror]])
|
||||
|
@ -189,7 +189,7 @@ provided by this module. ::
|
|||
os.makedirs(dst)
|
||||
errors = []
|
||||
for name in names:
|
||||
if name in ignored_names:
|
||||
if name in ignored_names:
|
||||
continue
|
||||
srcname = os.path.join(src, name)
|
||||
dstname = os.path.join(dst, name)
|
||||
|
@ -221,7 +221,7 @@ provided by this module. ::
|
|||
Another example that uses the :func:`ignore_patterns` helper::
|
||||
|
||||
from shutil import copytree, ignore_patterns
|
||||
|
||||
|
||||
copytree(source, destination, ignore=ignore_patterns('*.pyc', 'tmp*'))
|
||||
|
||||
This will copy everything except ``.pyc`` files and files or directories whose
|
||||
|
@ -231,7 +231,7 @@ Another example that uses the *ignore* argument to add a logging call::
|
|||
|
||||
from shutil import copytree
|
||||
import logging
|
||||
|
||||
|
||||
def _logpath(path, names):
|
||||
logging.info('Working in %s' % path)
|
||||
return [] # nothing will be ignored
|
||||
|
|
|
@ -39,12 +39,12 @@ rules for working with signals and their handlers:
|
|||
* Some care must be taken if both signals and threads are used in the same
|
||||
program. The fundamental thing to remember in using signals and threads
|
||||
simultaneously is: always perform :func:`signal` operations in the main thread
|
||||
of execution. Any thread can perform an :func:`alarm`, :func:`getsignal`,
|
||||
:func:`pause`, :func:`setitimer` or :func:`getitimer`; only the main thread
|
||||
can set a new signal handler, and the main thread will be the only one to
|
||||
receive signals (this is enforced by the Python :mod:`signal` module, even
|
||||
if the underlying thread implementation supports sending signals to
|
||||
individual threads). This means that signals can't be used as a means of
|
||||
of execution. Any thread can perform an :func:`alarm`, :func:`getsignal`,
|
||||
:func:`pause`, :func:`setitimer` or :func:`getitimer`; only the main thread
|
||||
can set a new signal handler, and the main thread will be the only one to
|
||||
receive signals (this is enforced by the Python :mod:`signal` module, even
|
||||
if the underlying thread implementation supports sending signals to
|
||||
individual threads). This means that signals can't be used as a means of
|
||||
inter-thread communication. Use locks instead.
|
||||
|
||||
The variables defined in the :mod:`signal` module are:
|
||||
|
@ -80,22 +80,22 @@ The variables defined in the :mod:`signal` module are:
|
|||
One more than the number of the highest signal number.
|
||||
|
||||
|
||||
.. data:: ITIMER_REAL
|
||||
.. data:: ITIMER_REAL
|
||||
|
||||
Decrements interval timer in real time, and delivers :const:`SIGALRM` upon expiration.
|
||||
|
||||
|
||||
.. data:: ITIMER_VIRTUAL
|
||||
.. data:: ITIMER_VIRTUAL
|
||||
|
||||
Decrements interval timer only when the process is executing, and delivers
|
||||
Decrements interval timer only when the process is executing, and delivers
|
||||
SIGVTALRM upon expiration.
|
||||
|
||||
|
||||
.. data:: ITIMER_PROF
|
||||
|
||||
Decrements interval timer both when the process executes and when the
|
||||
system is executing on behalf of the process. Coupled with ITIMER_VIRTUAL,
|
||||
this timer is usually used to profile the time spent by the application
|
||||
|
||||
Decrements interval timer both when the process executes and when the
|
||||
system is executing on behalf of the process. Coupled with ITIMER_VIRTUAL,
|
||||
this timer is usually used to profile the time spent by the application
|
||||
in user and kernel space. SIGPROF is delivered upon expiration.
|
||||
|
||||
|
||||
|
@ -105,7 +105,7 @@ The :mod:`signal` module defines one exception:
|
|||
|
||||
Raised to signal an error from the underlying :func:`setitimer` or
|
||||
:func:`getitimer` implementation. Expect this error if an invalid
|
||||
interval timer or a negative time is passed to :func:`setitimer`.
|
||||
interval timer or a negative time is passed to :func:`setitimer`.
|
||||
This error is a subtype of :exc:`IOError`.
|
||||
|
||||
|
||||
|
@ -143,21 +143,21 @@ The :mod:`signal` module defines the following functions:
|
|||
|
||||
.. function:: setitimer(which, seconds[, interval])
|
||||
|
||||
Sets given interval timer (one of :const:`signal.ITIMER_REAL`,
|
||||
Sets given interval timer (one of :const:`signal.ITIMER_REAL`,
|
||||
:const:`signal.ITIMER_VIRTUAL` or :const:`signal.ITIMER_PROF`) specified
|
||||
by *which* to fire after *seconds* (float is accepted, different from
|
||||
by *which* to fire after *seconds* (float is accepted, different from
|
||||
:func:`alarm`) and after that every *interval* seconds. The interval
|
||||
timer specified by *which* can be cleared by setting seconds to zero.
|
||||
|
||||
When an interval timer fires, a signal is sent to the process.
|
||||
The signal sent is dependent on the timer being used;
|
||||
:const:`signal.ITIMER_REAL` will deliver :const:`SIGALRM`,
|
||||
The signal sent is dependent on the timer being used;
|
||||
:const:`signal.ITIMER_REAL` will deliver :const:`SIGALRM`,
|
||||
:const:`signal.ITIMER_VIRTUAL` sends :const:`SIGVTALRM`,
|
||||
and :const:`signal.ITIMER_PROF` will deliver :const:`SIGPROF`.
|
||||
|
||||
The old values are returned as a tuple: (delay, interval).
|
||||
|
||||
Attempting to pass an invalid interval timer will cause a
|
||||
Attempting to pass an invalid interval timer will cause a
|
||||
:exc:`ItimerError`.
|
||||
|
||||
.. versionadded:: 2.6
|
||||
|
@ -190,7 +190,7 @@ The :mod:`signal` module defines the following functions:
|
|||
will be restarted when interrupted by signal *signalnum*, otherwise system calls will
|
||||
be interrupted. Returns nothing. Availability: Unix (see the man page
|
||||
:manpage:`siginterrupt(3)` for further information).
|
||||
|
||||
|
||||
Note that installing a signal handler with :func:`signal` will reset the restart
|
||||
behaviour to interruptible by implicitly calling :cfunc:`siginterrupt` with a true *flag*
|
||||
value for the given signal.
|
||||
|
@ -239,7 +239,7 @@ be sent, and the handler raises an exception. ::
|
|||
signal.alarm(5)
|
||||
|
||||
# This open() may hang indefinitely
|
||||
fd = os.open('/dev/ttyS0', os.O_RDWR)
|
||||
fd = os.open('/dev/ttyS0', os.O_RDWR)
|
||||
|
||||
signal.alarm(0) # Disable the alarm
|
||||
|
||||
|
|
|
@ -151,7 +151,7 @@ Server code::
|
|||
requestHandler=RequestHandler)
|
||||
server.register_introspection_functions()
|
||||
|
||||
# Register pow() function; this will use the value of
|
||||
# Register pow() function; this will use the value of
|
||||
# pow.__name__ as the name, which is just 'pow'.
|
||||
server.register_function(pow)
|
||||
|
||||
|
@ -160,10 +160,10 @@ Server code::
|
|||
return x + y
|
||||
server.register_function(adder_function, 'add')
|
||||
|
||||
# Register an instance; all the methods of the instance are
|
||||
# Register an instance; all the methods of the instance are
|
||||
# published as XML-RPC methods (in this case, just 'div').
|
||||
class MyFuncs:
|
||||
def div(self, x, y):
|
||||
def div(self, x, y):
|
||||
return x // y
|
||||
|
||||
server.register_instance(MyFuncs())
|
||||
|
|
|
@ -189,9 +189,9 @@ An :class:`SMTP` instance has the following methods:
|
|||
|
||||
Identify yourself to an ESMTP server using ``EHLO``. The hostname argument
|
||||
defaults to the fully qualified domain name of the local host. Examine the
|
||||
response for ESMTP option and store them for use by :meth:`has_extn`.
|
||||
Also sets several informational attributes: the message returned by
|
||||
the server is stored as the :attr:`ehlo_resp` attribute, :attr:`does_esmtp`
|
||||
response for ESMTP option and store them for use by :meth:`has_extn`.
|
||||
Also sets several informational attributes: the message returned by
|
||||
the server is stored as the :attr:`ehlo_resp` attribute, :attr:`does_esmtp`
|
||||
is set to true or false depending on whether the server supports ESMTP, and
|
||||
:attr:`esmtp_features` will be a dictionary containing the names of the
|
||||
SMTP service extensions this server supports, and their
|
||||
|
|
|
@ -184,10 +184,10 @@ The module :mod:`socket` exports the following constants and functions:
|
|||
|
||||
.. data:: SIO_*
|
||||
RCVALL_*
|
||||
|
||||
|
||||
Constants for Windows' WSAIoctl(). The constants are used as arguments to the
|
||||
:meth:`ioctl` method of socket objects.
|
||||
|
||||
|
||||
.. versionadded:: 2.6
|
||||
|
||||
.. data:: TIPC_*
|
||||
|
@ -222,7 +222,7 @@ The module :mod:`socket` exports the following constants and functions:
|
|||
all the necessary arguments for creating the corresponding socket. *host* is a domain
|
||||
name, a string representation of an IPv4/v6 address or ``None``. *port* is a string
|
||||
service name such as ``'http'``, a numeric port number or ``None``.
|
||||
The rest of the arguments are optional and must be numeric if specified.
|
||||
The rest of the arguments are optional and must be numeric if specified.
|
||||
By passing ``None`` as the value of *host* and *port*, , you can pass ``NULL`` to the C API.
|
||||
|
||||
The :func:`getaddrinfo` function returns a list of 5-tuples with the following
|
||||
|
@ -588,14 +588,14 @@ correspond to Unix system calls applicable to sockets.
|
|||
contents of the buffer (see the optional built-in module :mod:`struct` for a way
|
||||
to decode C structures encoded as strings).
|
||||
|
||||
|
||||
|
||||
.. method:: socket.ioctl(control, option)
|
||||
|
||||
:platform: Windows
|
||||
|
||||
:platform: Windows
|
||||
|
||||
The :meth:`ioctl` method is a limited interface to the WSAIoctl system
|
||||
interface. Please refer to the MSDN documentation for more information.
|
||||
|
||||
|
||||
.. versionadded:: 2.6
|
||||
|
||||
|
||||
|
@ -909,7 +909,7 @@ sends traffic to the first one connected successfully. ::
|
|||
s.close()
|
||||
print 'Received', repr(data)
|
||||
|
||||
|
||||
|
||||
The last example shows how to write a very simple network sniffer with raw
|
||||
sockets on Windows. The example requires administrator privileges to modify
|
||||
the interface::
|
||||
|
@ -918,19 +918,19 @@ the interface::
|
|||
|
||||
# the public network interface
|
||||
HOST = socket.gethostbyname(socket.gethostname())
|
||||
|
||||
|
||||
# create a raw socket and bind it to the public interface
|
||||
s = socket.socket(socket.AF_INET, socket.SOCK_RAW, socket.IPPROTO_IP)
|
||||
s.bind((HOST, 0))
|
||||
|
||||
|
||||
# Include IP headers
|
||||
s.setsockopt(socket.IPPROTO_IP, socket.IP_HDRINCL, 1)
|
||||
|
||||
|
||||
# receive all packages
|
||||
s.ioctl(socket.SIO_RCVALL, socket.RCVALL_ON)
|
||||
|
||||
|
||||
# receive a package
|
||||
print s.recvfrom(65565)
|
||||
|
||||
|
||||
# disabled promiscuous mode
|
||||
s.ioctl(socket.SIO_RCVALL, socket.RCVALL_OFF)
|
||||
|
|
|
@ -244,7 +244,7 @@ Connection Objects
|
|||
|
||||
.. method:: Connection.rollback()
|
||||
|
||||
This method rolls back any changes to the database since the last call to
|
||||
This method rolls back any changes to the database since the last call to
|
||||
:meth:`commit`.
|
||||
|
||||
.. method:: Connection.close()
|
||||
|
@ -487,29 +487,29 @@ Cursor Objects
|
|||
.. literalinclude:: ../includes/sqlite3/executescript.py
|
||||
|
||||
|
||||
.. method:: Cursor.fetchone()
|
||||
|
||||
.. method:: Cursor.fetchone()
|
||||
|
||||
Fetches the next row of a query result set, returning a single sequence,
|
||||
or :const:`None` when no more data is available.
|
||||
|
||||
|
||||
.. method:: Cursor.fetchmany([size=cursor.arraysize])
|
||||
|
||||
|
||||
Fetches the next set of rows of a query result, returning a list. An empty
|
||||
list is returned when no more rows are available.
|
||||
|
||||
|
||||
The number of rows to fetch per call is specified by the *size* parameter.
|
||||
If it is not given, the cursor's arraysize determines the number of rows
|
||||
to be fetched. The method should try to fetch as many rows as indicated by
|
||||
the size parameter. If this is not possible due to the specified number of
|
||||
rows not being available, fewer rows may be returned.
|
||||
|
||||
|
||||
Note there are performance considerations involved with the *size* parameter.
|
||||
For optimal performance, it is usually best to use the arraysize attribute.
|
||||
If the *size* parameter is used, then it is best for it to retain the same
|
||||
value from one :meth:`fetchmany` call to the next.
|
||||
|
||||
.. method:: Cursor.fetchall()
|
||||
|
||||
.. method:: Cursor.fetchall()
|
||||
|
||||
Fetches all (remaining) rows of a query result, returning a list. Note that
|
||||
the cursor's arraysize attribute can affect the performance of this operation.
|
||||
|
@ -546,8 +546,8 @@ Cursor Objects
|
|||
|
||||
This read-only attribute provides the column names of the last query. To
|
||||
remain compatible with the Python DB API, it returns a 7-tuple for each
|
||||
column where the last six items of each tuple are :const:`None`.
|
||||
|
||||
column where the last six items of each tuple are :const:`None`.
|
||||
|
||||
It is set for ``SELECT`` statements without any matching rows as well.
|
||||
|
||||
.. _sqlite3-row-objects:
|
||||
|
@ -558,7 +558,7 @@ Row Objects
|
|||
.. class:: Row
|
||||
|
||||
A :class:`Row` instance serves as a highly optimized
|
||||
:attr:`~Connection.row_factory` for :class:`Connection` objects.
|
||||
:attr:`~Connection.row_factory` for :class:`Connection` objects.
|
||||
It tries to mimic a tuple in most of its features.
|
||||
|
||||
It supports mapping access by column name and index, iteration,
|
||||
|
@ -566,7 +566,7 @@ Row Objects
|
|||
|
||||
If two :class:`Row` objects have exactly the same columns and their
|
||||
members are equal, they compare equal.
|
||||
|
||||
|
||||
.. versionchanged:: 2.6
|
||||
Added iteration and equality (hashability).
|
||||
|
||||
|
@ -793,7 +793,7 @@ Controlling Transactions
|
|||
------------------------
|
||||
|
||||
By default, the :mod:`sqlite3` module opens transactions implicitly before a
|
||||
Data Modification Language (DML) statement (i.e.
|
||||
Data Modification Language (DML) statement (i.e.
|
||||
``INSERT``/``UPDATE``/``DELETE``/``REPLACE``), and commits transactions
|
||||
implicitly before a non-DML, non-query statement (i. e.
|
||||
anything other than ``SELECT`` or the aforementioned).
|
||||
|
|
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in New Issue