The typical Python prompt of the interactive shell when entering code for
an indented code block.
- Abstract Base Class
+ abstract base class
Abstract Base Classes (abbreviated ABCs) complement :term:`duck-typing` by
providing a way to define interfaces when other techniques like :func:`hasattr`
would be clumsy. Python comes with many builtin ABCs for data structures
.. sectionauthor:: Georg Brandl
.. much of the content adapted from docstrings
-This module provides the infrastructure for defining :term:`abstract base
-classes` (ABCs) in Python, as outlined in :pep:`3119`; see the PEP for why this
+This module provides the infrastructure for defining an :term:`abstract base
+class` (ABCs) in Python, as outlined in :pep:`3119`; see the PEP for why this
was added to Python. (See also :pep:`3141` and the :mod:`numbers` module
regarding a type hierarchy for numbers based on ABCs.)
The collections module offers the following ABCs:
-========================= ==================== ====================== ====================================================
-ABC Inherits Abstract Methods Mixin Methods
-========================= ==================== ====================== ====================================================
-:class:`Container` ``__contains__``
-:class:`Hashable` ``__hash__``
-:class:`Iterable` ``__iter__``
-:class:`Iterator` :class:`Iterable` ``__next__`` ``__iter__``
-:class:`Sized` ``__len__``
-
-: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:`Sequence` :class:`Sized`, ``__getitem__`` ``__contains__``. ``__iter__``, ``__reversed__``.
- :class:`Iterable`, and ``__len__`` ``index``, and ``count``
- :class:`Container`
-
-:class:`MutableSequnce` :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__``
-========================= ==================== ====================== ====================================================
+========================= ===================== ====================== ====================================================
+ABC Inherits Abstract Methods Mixin Methods
+========================= ===================== ====================== ====================================================
+:class:`Container` ``__contains__``
+:class:`Hashable` ``__hash__``
+:class:`Iterable` ``__iter__``
+: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:`MutableSequnce` :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__``
+:class:`ItemsView` :class:`MappingView`, ``__contains__``,
+ :class:`Set` ``__iter__``
+:class:`ValuesView` :class:`MappingView` ``__contains__``, ``__iter__``
+========================= ===================== ====================== ====================================================
These ABCs allow us to ask classes or instances if they provide
particular functionality, for example::
Unix command :program:`cp -p`.
-.. function:: copytree(src, dst[, symlinks])
+.. function:: ignore_patterns(\*patterns)
+
+ This factory function creates a function that can be used as a callable for
+ :func:`copytree`\'s *ignore* argument, ignoring files and directories that
+ match one of the glob-style *patterns* provided. See the example below.
+
+
+.. function:: copytree(src, dst[, symlinks=False[, ignore=None]])
Recursively copy an entire directory tree rooted at *src*. The destination
- directory, named by *dst*, must not already exist; it will be created as well as
- missing parent directories. Permissions and times of directories are copied with
- :func:`copystat`, individual files are copied using :func:`copy2`. If
- *symlinks* is true, symbolic links in the source tree are represented as
- symbolic links in the new tree; if false or omitted, the contents of the linked
- files are copied to the new tree. If exception(s) occur, an :exc:`Error` is
- raised with a list of reasons.
-
- The source code for this should be considered an example rather than a tool.
+ directory, named by *dst*, must not already exist; it will be created as well
+ as missing parent directories. Permissions and times of directories are
+ copied with :func:`copystat`, individual files are copied using
+ :func:`copy2`.
+
+ If *symlinks* is true, symbolic links in the source tree are represented as
+ symbolic links in the new tree; if false or omitted, the contents of the
+ linked files are copied to the new tree.
+
+ If *ignore* is given, it must be a callable that will receive as its
+ arguments the directory being visited by :func:`copytree`, and a list of its
+ contents, as returned by :func:`os.listdir`. Since :func:`copytree` is
+ called recursively, the *ignore* callable will be called once for each
+ directory that is copied. The callable must return a sequence of directory
+ and file names relative to the current directory (i.e. a subset of the items
+ in its second argument); these names will then be ignored in the copy
+ process. :func:`ignore_patterns` can be used to create such a callable that
+ ignores names based on glob-style patterns.
+
+ If exception(s) occur, an :exc:`Error` is raised with a list of reasons.
+
+ The source code for this should be considered an example rather than the
+ ultimate tool.
.. function:: rmtree(path[, ignore_errors[, onerror]])
files, like ttys, it makes sense to continue reading after an EOF is hit.) Note
that this method may call the underlying C function :cfunc:`fread` more than
once in an effort to acquire as close to *size* bytes as possible. Also note
- that when in non-blocking mode, less data than what was requested may be
+ that when in non-blocking mode, less data than was requested may be
returned, even if no *size* parameter was given.
-<?xml version="1.0" encoding="UTF-8"?>
-<OpenSearchDescription xmlns="http://a9.com/-/spec/opensearch/1.1/">
- <ShortName>Python Docs</ShortName>
- <LongName>Python Documentation</LongName>
- <Description>Search the Python documentation</Description>
- <InputEncoding>utf-8</InputEncoding>
- <Url type="text/html" method="get" template="{{ pathto('search') }}?">
- <Param name="q" value="{searchTerms}" />
- <Param name="check_keywords" value="yes" />
- <Param name="area" value="default" />
- </Url>
- <Image height="16" width="16" type="image/x-icon">http://www.python.org/images/favicon16x16.ico</Image>
-</OpenSearchDescription>
-
+{% extends "!opensearch.xml" %}
+{% block extra -%}
+<Image height="16" width="16" type="image/x-icon">http://www.python.org/images/favicon16x16.ico</Image>
+{%- endblock %}
available, instead of restricting itself to protocol 1.
(Contributed by W. Barnes; :issue:`1551443`.)
+* The :mod:`cgi` module will now read variables from the query string of an
+ HTTP POST request. This makes it possible to use form actions with
+ URLs such as "/cgi-bin/add.py?category=1". (Contributed by
+ Alexandre Fiori and Nubis; :issue:`1817`.)
+
* The :mod:`cmath` module underwent an extensive set of revisions,
thanks to Mark Dickinson and Christian Heimes, that added some new
features and greatly improved the accuracy of the computations.
* The :mod:`sets` module has been deprecated; it's better to
use the built-in :class:`set` and :class:`frozenset` types.
+* The :func:`shutil.copytree` function now has an optional **ignore** argument
+ that takes a callable object. This callable will receive each directory path
+ and a list of the directory's contents, and returns a list of names that
+ will be ignored, not copied.
+
+ The :mod:`shutil` module also provides an :func:`ignore_patterns`
+ function for use with this new parameter.
+ :func:`ignore_patterns` takes an arbitrary number of glob-style patterns
+ and will ignore any files and directories that match this pattern.
+ The following example copies a directory tree, but skip both SVN's internal
+ :file:`.svn` directories and Emacs backup
+ files, which have names ending with '~'::
+
+ shutil.copytree('Doc/library', '/tmp/library',
+ ignore=shutil.ignore_patterns('*~', '.svn'))
+
+ (Contributed by Tarek Ziadé; :issue:`2663`.)
+
* Integrating signal handling with GUI handling event loops
like those used by Tkinter or GTk+ has long been a problem; most
software ends up polling, waking up every fraction of a second.
...
ValueError: malformed string
-The module also includes
-:class:`NodeVisitor` and :class:`NodeTransformer` classes
-for traversing and modifying an AST, and functions for common transformations such as changing line numbers.
+The module also includes :class:`NodeVisitor` and
+:class:`NodeTransformer` classes for traversing and modifying an AST,
+and functions for common transformations such as changing line
+numbers.
.. ======================================================================
"""Simple textbox editing widget with Emacs-like keybindings."""
-import curses, ascii
+import curses
+import curses.ascii
def rectangle(win, uly, ulx, lry, lrx):
"""Draw a rectangle with corners at the provided upper-left
returning the index of the last non-blank character."""
last = self.maxx
while True:
- if ascii.ascii(self.win.inch(y, last)) != ascii.SP:
+ if curses.ascii.ascii(self.win.inch(y, last)) != curses.ascii.SP:
last = min(self.maxx, last+1)
break
elif last == 0:
pass
if self.insert_mode:
(backy, backx) = self.win.getyx()
- if ascii.isprint(oldch):
+ if curses.ascii.isprint(oldch):
self._insert_printable_char(oldch)
self.win.move(backy, backx)
"Process a single editing command."
(y, x) = self.win.getyx()
self.lastcmd = ch
- if ascii.isprint(ch):
+ if curses.ascii.isprint(ch):
if y < self.maxy or x < self.maxx:
self._insert_printable_char(ch)
- elif ch == ascii.SOH: # ^a
+ elif ch == curses.ascii.SOH: # ^a
self.win.move(y, 0)
- elif ch in (ascii.STX,curses.KEY_LEFT, ascii.BS,curses.KEY_BACKSPACE):
+ elif ch in (curses.ascii.STX,curses.KEY_LEFT, curses.ascii.BS,curses.KEY_BACKSPACE):
if x > 0:
self.win.move(y, x-1)
elif y == 0:
self.win.move(y-1, self._end_of_line(y-1))
else:
self.win.move(y-1, self.maxx)
- if ch in (ascii.BS, curses.KEY_BACKSPACE):
+ if ch in (curses.ascii.BS, curses.KEY_BACKSPACE):
self.win.delch()
- elif ch == ascii.EOT: # ^d
+ elif ch == curses.ascii.EOT: # ^d
self.win.delch()
- elif ch == ascii.ENQ: # ^e
+ elif ch == curses.ascii.ENQ: # ^e
if self.stripspaces:
self.win.move(y, self._end_of_line(y))
else:
self.win.move(y, self.maxx)
- elif ch in (ascii.ACK, curses.KEY_RIGHT): # ^f
+ elif ch in (curses.ascii.ACK, curses.KEY_RIGHT): # ^f
if x < self.maxx:
self.win.move(y, x+1)
elif y == self.maxy:
pass
else:
self.win.move(y+1, 0)
- elif ch == ascii.BEL: # ^g
+ elif ch == curses.ascii.BEL: # ^g
return 0
- elif ch == ascii.NL: # ^j
+ elif ch == curses.ascii.NL: # ^j
if self.maxy == 0:
return 0
elif y < self.maxy:
self.win.move(y+1, 0)
- elif ch == ascii.VT: # ^k
+ elif ch == curses.ascii.VT: # ^k
if x == 0 and self._end_of_line(y) == 0:
self.win.deleteln()
else:
# first undo the effect of self._end_of_line
self.win.move(y, x)
self.win.clrtoeol()
- elif ch == ascii.FF: # ^l
+ elif ch == curses.ascii.FF: # ^l
self.win.refresh()
- elif ch in (ascii.SO, curses.KEY_DOWN): # ^n
+ elif ch in (curses.ascii.SO, curses.KEY_DOWN): # ^n
if y < self.maxy:
self.win.move(y+1, x)
if x > self._end_of_line(y+1):
self.win.move(y+1, self._end_of_line(y+1))
- elif ch == ascii.SI: # ^o
+ elif ch == curses.ascii.SI: # ^o
self.win.insertln()
- elif ch in (ascii.DLE, curses.KEY_UP): # ^p
+ elif ch in (curses.ascii.DLE, curses.KEY_UP): # ^p
if y > 0:
self.win.move(y-1, x)
if x > self._end_of_line(y-1):
for x in range(self.maxx+1):
if self.stripspaces and x > stop:
break
- result = result + chr(ascii.ascii(self.win.inch(y, x)))
+ result = result + chr(curses.ascii.ascii(self.win.inch(y, x)))
if self.maxy > 0:
result = result + "\n"
return result
if denominator == 0:
raise ZeroDivisionError('Fraction(%s, 0)' % numerator)
-
- numerator = numerator.__index__()
- denominator = denominator.__index__()
+ numerator = operator.index(numerator)
+ denominator = operator.index(denominator)
g = gcd(numerator, denominator)
self._numerator = numerator // g
self._denominator = denominator // g
host_enc = self.host.encode("ascii")
except UnicodeEncodeError:
host_enc = self.host.encode("idna")
- if self.port == HTTP_PORT:
+ if self.port == self.default_port:
self.putheader('Host', host_enc)
else:
host_enc = host_enc.decode("ascii")
input_offset = 0
while read_set or write_set:
- rlist, wlist, xlist = select.select(read_set, write_set, [])
+ try:
+ rlist, wlist, xlist = select.select(read_set, write_set, [])
+ except select.error as e:
+ if e.args[0] == errno.EINTR:
+ continue
+ raise
# XXX Rewrite these to use non-blocking I/O on the
# file objects; they are no longer using C stdio!
curses - Tests that use curses and will modify the terminal's
state and output modes.
+ lib2to3 - Run the tests for 2to3 (They take a while.)
+
largefile - It is okay to run some test that may create huge
files. These tests can take a long time and may
consume >2GB of disk space temporarily.
from test import support
-RESOURCE_NAMES = ('audio', 'curses', 'largefile', 'network', 'bsddb',
- 'decimal', 'compiler', 'subprocess', 'urlfetch')
+RESOURCE_NAMES = ('audio', 'curses', 'lib2to3', 'largefile', 'network',
+ 'bsddb', 'decimal', 'compiler', 'subprocess', 'urlfetch')
def usage(msg):
self.assertEqual(audioop.getsample(data[1], 2, i), i)
self.assertEqual(audioop.getsample(data[2], 4, i), i)
+ def test_negavitelen(self):
+ # from issue 3306, previously it segfaulted
+ self.assertRaises(audioop.error,
+ audioop.findmax, ''.join(chr(x) for x in range(256)), -2392392)
def test_main():
run_unittest(TestAudioop)
self.assertEqual(list(iter(bz2f)), sio.readlines())
bz2f.close()
+ def testClosedIteratorDeadlock(self):
+ # "Test that iteration on a closed bz2file releases the lock."
+ # http://bugs.python.org/issue3309
+ self.createTempFile()
+ bz2f = BZ2File(self.filename)
+ bz2f.close()
+ self.assertRaises(ValueError, bz2f.__next__)
+ # This call will deadlock of the above .__next__ call failed to
+ # release the lock.
+ self.assertRaises(ValueError, bz2f.readlines)
+
def testWrite(self):
# "Test BZ2File.write()"
bz2f = BZ2File(self.filename, "w")
self.assertRaisesMessage(ZeroDivisionError, "Fraction(12, 0)",
F, 12, 0)
- self.assertRaises(AttributeError, F, 1.5)
- self.assertRaises(AttributeError, F, 1.5 + 3j)
+ self.assertRaises(TypeError, F, 1.5)
+ self.assertRaises(TypeError, F, 1.5 + 3j)
- self.assertRaises(AttributeError, F, F(1, 2), 3)
- self.assertRaises(AttributeError, F, "3/2", 3)
+ self.assertRaises(TypeError, F, F(1, 2), 3)
+ self.assertRaises(TypeError, F, "3/2", 3)
def testFromString(self):
self.assertEquals((5, 1), _components(F("5")))
+#!/usr/bin/env python
+
#
# Unit tests for the multiprocessing package
#
def test_clear_type_cache(self):
sys._clear_type_cache()
- def test_compact_freelists(self):
- sys._compact_freelists()
- r = sys._compact_freelists()
- ## freed blocks shouldn't change
- #self.assertEqual(r[0][2], 0)
- ## fill freelists
- #ints = list(range(10000))
- #floats = [float(i) for i in ints]
- #del ints
- #del floats
- ## should free more than 100 blocks
- #r = sys._compact_freelists()
- #self.assert_(r[0][1] > 100, r[0][1])
- #self.assert_(r[0][2] > 100, r[0][2])
-
def test_ioencoding(self):
import subprocess,os
env = dict(os.environ)
Matthew Dixon Cowles
Christopher A. Craig
Laura Creighton
+Simon Cross
Drew Csillag
John Cugini
Tom Culliton
#_md5 md5module.c md5.c
-# The _sha module implements the SHA checksum algorithm.
-# (NIST's Secure Hash Algorithm.)
+# The _sha module implements the SHA checksum algorithms.
+# (NIST's Secure Hash Algorithms.)
#_sha shamodule.c
+#_sha256 sha256module.c
+#_sha512 sha512module.c
# The _tkinter module.
ret = -1;
done:
- PyMem_Free(name);
return ret;
}
}
len1 >>= 1;
- if ( len1 < len2 ) {
+ if ( len2 < 0 || len1 < len2 ) {
PyErr_SetString(AudioopError, "Input sample should be longer");
return 0;
}
PyBytesObject* ret;
ACQUIRE_LOCK(self);
if (self->mode == MODE_CLOSED) {
+ RELEASE_LOCK(self);
PyErr_SetString(PyExc_ValueError,
"I/O operation on closed file");
return NULL;
errno = 0;
PyFPE_START_PROTECT("complex function", return 0)
x = c_log(x);
- if (PyTuple_GET_SIZE(args) == 2)
- x = c_quot(x, c_log(y));
+ if (PyTuple_GET_SIZE(args) == 2) {
+ y = c_log(y);
+ x = c_quot(x, y);
+ }
PyFPE_END_PROTECT(x)
if (errno != 0)
return math_error();
{
struct tm buf;
time_t tt;
- tt = time(&tt);
- buf = *localtime(&tt);
if (!gettmarg(tup, &buf))
return NULL;
tt = mktime(&buf);
return m->sq_item(s, i);
}
- return type_error("'%.200s' object is unindexable", s);
+ return type_error("'%.200s' object does not support indexing", s);
}
PyObject *
COMPARE_OP is often followed by JUMP_IF_FALSE or JUMP_IF_TRUE. And,
those opcodes are often followed by a POP_TOP.
- Verifying the prediction costs a single high-speed test of register
+ Verifying the prediction costs a single high-speed test of a register
variable against a constant. If the pairing was good, then the
- processor has a high likelihood of making its own successful branch
- prediction which results in a nearly zero overhead transition to the
- next opcode.
-
- A successful prediction saves a trip through the eval-loop including
- its two unpredictable branches, the HAS_ARG test and the switch-case.
-
- If collecting opcode statistics, turn off prediction so that
- statistics are accurately maintained (the predictions bypass
- the opcode frequency counter updates).
+ processor's own internal branch predication has a high likelihood of
+ success, resulting in a nearly zero-overhead transition to the
+ next opcode. A successful prediction saves a trip through the eval-loop
+ including its two unpredictable branches, the HAS_ARG test and the
+ switch-case. Combined with the processor's internal branch prediction,
+ a successful PREDICT has the effect of making the two opcodes run as if
+ they were a single new opcode with the bodies combined.
+
+ If collecting opcode statistics, your choices are to either keep the
+ predictions turned-on and interpret the results as if some opcodes
+ had been combined or turn-off predictions so that the opcode frequency
+ counter updates for both opcodes.
*/
#ifdef DYNAMIC_EXECUTION_PROFILE
if (install_sigs)
initsigs(); /* Signal handling stuff, including initintr() */
- /* Initialize warnings. */
- _PyWarnings_Init();
- if (PySys_HasWarnOptions()) {
- PyObject *warnings_module = PyImport_ImportModule("warnings");
- if (!warnings_module)
- PyErr_Clear();
- Py_XDECREF(warnings_module);
- }
+ /* Initialize warnings. */
+ _PyWarnings_Init();
+ if (PySys_HasWarnOptions()) {
+ PyObject *warnings_module = PyImport_ImportModule("warnings");
+ if (!warnings_module)
+ PyErr_Clear();
+ Py_XDECREF(warnings_module);
+ }
initmain(); /* Module __main__ */
if (!Py_NoSiteFlag)
PyException_SetTraceback(v, tb);
if (exception == NULL)
return;
- /* Now we know v != NULL too */
+ /* Now we know v != NULL too */
if (set_sys_last_vars) {
PySys_SetObject("last_type", exception);
PySys_SetObject("last_value", v);
PyAPI_FUNC(PyObject *)
PyRun_File(FILE *fp, const char *p, int s, PyObject *g, PyObject *l)
{
- return PyRun_FileExFlags(fp, p, s, g, l, 0, NULL);
+ return PyRun_FileExFlags(fp, p, s, g, l, 0, NULL);
}
#undef PyRun_FileEx
PyAPI_FUNC(PyObject *)
PyRun_FileEx(FILE *fp, const char *p, int s, PyObject *g, PyObject *l, int c)
{
- return PyRun_FileExFlags(fp, p, s, g, l, c, NULL);
+ return PyRun_FileExFlags(fp, p, s, g, l, c, NULL);
}
#undef PyRun_FileFlags
PyRun_FileFlags(FILE *fp, const char *p, int s, PyObject *g, PyObject *l,
PyCompilerFlags *flags)
{
- return PyRun_FileExFlags(fp, p, s, g, l, 0, flags);
+ return PyRun_FileExFlags(fp, p, s, g, l, 0, flags);
}
#undef PyRun_SimpleFile
projects / python / commitdiff