the Unicode string representation on success, \NULL{} on failure.
This is the equivalent of the Python expression
\samp{unistr(\var{o})}. Called by the
- \function{unistr()}\bifuncindex{unistr} built-in function.
+ \function{unistr()}\bifuncindex{unistr} built-in function.
\end{cfuncdesc}
\begin{cfuncdesc}{int}{PyObject_IsInstance}{PyObject *inst, PyObject *cls}
\begin{cfuncdesc}{PyObject*}{PySequence_Fast_GET_ITEM}{PyObject *o, int i}
Return the \var{i}th element of \var{o}, assuming that \var{o} was
- returned by \cfunction{PySequence_Fast()}, and that \var{i} is
- within bounds. The caller is expected to get the length of the
- sequence by calling \cfunction{PySequence_Size()} on \var{o}, since
- lists and tuples are guaranteed to always return their true length.
+ returned by \cfunction{PySequence_Fast()}, \var{o} is not \NULL{},
+ and that \var{i} is within bounds.
+\end{cfuncdesc}
+
+\begin{cfuncdesc}{int}{PySequence_Fast_GET_SIZE}{PyObject *o}
+ Returns the length of \var{o}, assuming that \var{o} was
+ returned by \cfunction{PySequence_Fast()} and that \var{o} is
+ not \NULL{}. The size can also be gotten by calling
+ \cfunction{PySequence_Size()} on \var{o}, but
+ \cfunction{PySequence_Fast_GET_SIZE()} is faster because it can
+ assume \var{o} is a list or tuple.
\end{cfuncdesc}
\code{del \var{x}.\var{foobar}}.
\end{funcdesc}
+\begin{funcdesc}{dictionary}{\optional{mapping-or-sequence}}
+ Return a new dictionary initialized from the optional argument.
+ If an argument is not specified, return a new empty dictionary.
+ If the argument is a mapping object, return a dictionary mapping the
+ same keys to the same values as does the mapping object.
+ Else the argument must be a sequence, a container that supports
+ iteration, or an iterator object. The elements of the argument must
+ each also be of one of those kinds, and each must in turn contain
+ exactly two objects. The first is used as a key in the new dictionary,
+ and the second as the key's value. If a given key is seen more than
+ once, the last value associated with it is retained in the new
+ dictionary.
+ For example, these all return a dictionary equal to
+ \code{\{1: 2, 2: 3\}}:
+ \code{dictionary(\{1: 2, 2: 3\})},
+ \code{dictionary(\{1: 2, 2: 3\}.items()},
+ \code{dictionary(\{1: 2, 2: 3\}.iteritems()},
+ \code{dictionary(zip((1, 2), (2, 3)))},
+ \code{dictionary([[2, 3], [1, 2]])}, and
+ \code{dictionary([(i-1, i) for i in (2, 3)])}.
+\end{funcdesc}
+
\begin{funcdesc}{dir}{\optional{object}}
Without arguments, return the list of names in the current local
symbol table. With an argument, attempts to return a list of valid
may be a sequence (string, tuple or list) or a mapping (dictionary).
\end{funcdesc}
-\begin{funcdesc}{list}{sequence}
+\begin{funcdesc}{list}{\optional{sequence}}
Return a list whose items are the same and in the same order as
\var{sequence}'s items. \var{sequence} may be either a sequence, a
container that supports iteration, or an iterator object. If
printable string.
\end{funcdesc}
-\begin{funcdesc}{tuple}{sequence}
+\begin{funcdesc}{tuple}{\optional{sequence}}
Return a tuple whose items are the same and in the same order as
\var{sequence}'s items. \var{sequence} may be a sequence, a
container that supports iteration, or an iterator object.
DL_IMPORT(PyObject *) PySequence_List(PyObject *o);
-
/*
Returns the sequence, o, as a list on success, and NULL on failure.
This is equivalent to the Python expression: list(o)
*/
DL_IMPORT(PyObject *) PySequence_Fast(PyObject *o, const char* m);
-
/*
Returns the sequence, o, as a tuple, unless it's already a
tuple or list. Use PySequence_Fast_GET_ITEM to access the
- members of this list.
+ members of this list, and PySequence_Fast_GET_SIZE to get its length.
Returns NULL on failure. If the object does not support iteration,
raises a TypeError exception with m as the message text.
*/
+#define PySequence_Fast_GET_SIZE(o) \
+ (PyList_Check(o) ? PyList_GET_SIZE(o) : PyTuple_GET_SIZE(o))
+ /*
+ Return the size of o, assuming that o was returned by
+ PySequence_Fast and is not NULL.
+ */
+
#define PySequence_Fast_GET_ITEM(o, i)\
(PyList_Check(o) ? PyList_GET_ITEM(o, i) : PyTuple_GET_ITEM(o, i))
-
/*
Return the ith element of o, assuming that o was returned by
PySequence_Fast, and that i is within bounds.
vereq(d, {})
d = dictionary({})
vereq(d, {})
- d = dictionary(mapping={})
+ d = dictionary(x={})
vereq(d, {})
d = dictionary({1: 2, 'a': 'b'})
vereq(d, {1: 2, 'a': 'b'})
+ vereq(d, dictionary(d.items()))
+ vereq(d, dictionary(x=d.iteritems()))
for badarg in 0, 0L, 0j, "0", [0], (0,):
try:
dictionary(badarg)
except TypeError:
pass
+ except ValueError:
+ if badarg == "0":
+ # It's a sequence, and its elements are also sequences (gotta
+ # love strings <wink>), but they aren't of length 2, so this
+ # one seemed better as a ValueError than a TypeError.
+ pass
+ else:
+ raise TestFailed("no TypeError from dictionary(%r)" % badarg)
else:
raise TestFailed("no TypeError from dictionary(%r)" % badarg)
try:
except TypeError:
pass
else:
- raise TestFailed("no TypeError from dictionary(senseless={}")
+ raise TestFailed("no TypeError from dictionary(senseless={})")
try:
dictionary({}, {})
raise TestFailed("no TypeError from dictionary({}, {})")
class Mapping:
+ # Lacks a .keys() method; will be added later.
dict = {1:2, 3:4, 'a':1j}
- def __getitem__(self, i):
- return self.dict[i]
-
try:
dictionary(Mapping())
except TypeError:
raise TestFailed("no TypeError from dictionary(incomplete mapping)")
Mapping.keys = lambda self: self.dict.keys()
- d = dictionary(mapping=Mapping())
+ Mapping.__getitem__ = lambda self, i: self.dict[i]
+ d = dictionary(x=Mapping())
vereq(d, Mapping.dict)
+ # Init from sequence of iterable objects, each producing a 2-sequence.
+ class AddressBookEntry:
+ def __init__(self, first, last):
+ self.first = first
+ self.last = last
+ def __iter__(self):
+ return iter([self.first, self.last])
+
+ d = dictionary([AddressBookEntry('Tim', 'Warsaw'),
+ AddressBookEntry('Barry', 'Peters'),
+ AddressBookEntry('Tim', 'Peters'),
+ AddressBookEntry('Barry', 'Warsaw')])
+ vereq(d, {'Barry': 'Warsaw', 'Tim': 'Peters'})
+
+ d = dictionary(zip(range(4), range(1, 5)))
+ vereq(d, dictionary([(i, i+1) for i in range(4)]))
+
+ # Bad sequence lengths.
+ for bad in ['tooshort'], ['too', 'long', 'by 1']:
+ try:
+ dictionary(bad)
+ except ValueError:
+ pass
+ else:
+ raise TestFailed("no ValueError from dictionary(%r)" % bad)
+
def test_dir():
if verbose:
print "Testing dir() ..."
vereq(unicode(string='abc', errors='strict'), u'abc')
vereq(tuple(sequence=range(3)), (0, 1, 2))
vereq(list(sequence=(0, 1, 2)), range(3))
- vereq(dictionary(mapping={1: 2}), {1: 2})
+ vereq(dictionary(x={1: 2}), {1: 2})
for constructor in (int, float, long, complex, str, unicode,
tuple, list, dictionary, file):
vereq(f.__call__(a=42), 42)
a = []
list.__init__(a, sequence=[0, 1, 2])
- vereq(a, [0, 1, 2])
+ vereq(a, [0, 1, 2])
def test_main():
class_docstrings()
Type/class unification and new-style classes
+- dictionary() now accepts an iterable object producing 2-sequences.
+ For example, dictionary(d.items()) == d for any dictionary d. The
+ argument, and the elements of the argument, can be any iterable
+ objects.
+
- Methods of built-in types now properly check for keyword arguments
(formerly these were silently ignored). The only built-in methods
that take keyword arguments are __call__, __init__ and __new__.
C API
+- New function PySequence_Fast_GET_SIZE() returns the size of a non-
+ NULL result from PySequence_Fast(), more quickly than calling
+ PySequence_Size().
+
New platforms
- Updated RISCOS port by Dietmar Schwertberger.
/* Get iterator. */
it = PyObject_GetIter(v);
if (it == NULL)
- return type_error("tuple() argument must support iteration");
+ return NULL;
/* Guess result size and allocate space. */
n = PySequence_Size(v);
/* Update unconditionally replaces existing items.
Merge has a 3rd argument 'override'; if set, it acts like Update,
- otherwise it leaves existing items unchanged. */
+ otherwise it leaves existing items unchanged.
+
+ PyDict_{Update,Merge} update/merge from a mapping object.
+
+ PyDict_{Update,Merge}FromSeq2 update/merge from any iterable object
+ producing iterable objects of length 2.
+*/
+
+static int
+PyDict_MergeFromSeq2(PyObject *d, PyObject *seq2, int override)
+{
+ PyObject *it; /* iter(seq2) */
+ int i; /* index into seq2 of current element */
+ PyObject *item; /* seq2[i] */
+ PyObject *fast; /* item as a 2-tuple or 2-list */
+
+ assert(d != NULL);
+ assert(PyDict_Check(d));
+ assert(seq2 != NULL);
+
+ it = PyObject_GetIter(seq2);
+ if (it == NULL)
+ return -1;
+
+ for (i = 0; ; ++i) {
+ PyObject *key, *value;
+ int n;
+
+ fast = NULL;
+ item = PyIter_Next(it);
+ if (item == NULL) {
+ if (PyErr_Occurred())
+ goto Fail;
+ break;
+ }
+
+ /* Convert item to sequence, and verify length 2. */
+ fast = PySequence_Fast(item, "");
+ if (fast == NULL) {
+ if (PyErr_ExceptionMatches(PyExc_TypeError))
+ PyErr_Format(PyExc_TypeError,
+ "cannot convert dictionary update "
+ "sequence element #%d to a sequence",
+ i);
+ goto Fail;
+ }
+ n = PySequence_Fast_GET_SIZE(fast);
+ if (n != 2) {
+ PyErr_Format(PyExc_ValueError,
+ "dictionary update sequence element #%d "
+ "has length %d; 2 is required",
+ i, n);
+ goto Fail;
+ }
+
+ /* Update/merge with this (key, value) pair. */
+ key = PySequence_Fast_GET_ITEM(fast, 0);
+ value = PySequence_Fast_GET_ITEM(fast, 1);
+ if (override || PyDict_GetItem(d, key) == NULL) {
+ int status = PyDict_SetItem(d, key, value);
+ if (status < 0)
+ goto Fail;
+ }
+ Py_DECREF(fast);
+ Py_DECREF(item);
+ }
+
+ i = 0;
+ goto Return;
+Fail:
+ Py_XDECREF(item);
+ Py_XDECREF(fast);
+ i = -1;
+Return:
+ Py_DECREF(it);
+ return i;
+}
+
+static int
+PyDict_UpdateFromSeq2(PyObject *d, PyObject *seq2)
+{
+ return PyDict_MergeFromSeq2(d, seq2, 1);
+}
int
PyDict_Update(PyObject *a, PyObject *b)
dict_init(PyObject *self, PyObject *args, PyObject *kwds)
{
PyObject *arg = NULL;
- static char *kwlist[] = {"mapping", 0};
+ static char *kwlist[] = {"x", 0};
+ int result = 0;
if (!PyArg_ParseTupleAndKeywords(args, kwds, "|O:dictionary",
kwlist, &arg))
- return -1;
- if (arg != NULL) {
- if (PyDict_Merge(self, arg, 1) < 0) {
- /* An error like "AttributeError: keys" is too
- cryptic in this context. */
- if (PyErr_ExceptionMatches(PyExc_AttributeError)) {
- PyErr_SetString(PyExc_TypeError,
- "argument must be of a mapping type");
- }
- return -1;
- }
+ result = -1;
+
+ else if (arg != NULL) {
+ if (PyObject_HasAttrString(arg, "keys"))
+ result = PyDict_Merge(self, arg, 1);
+ else
+ result = PyDict_MergeFromSeq2(self, arg, 1);
}
- return 0;
+ return result;
}
static PyObject *
}
static char dictionary_doc[] =
-"dictionary() -> new empty dictionary\n"
-"dictionary(mapping) -> new dict initialized from mapping's key+value pairs";
+"dictionary() -> new empty dictionary.\n"
+"dictionary(mapping) -> new dict initialized from a mapping object's\n"
+" (key, value) pairs.\n"
+"dictionary(seq) -> new dict initialized from the 2-element elements of\n"
+" a sequence; for example, from mapping.items(). seq must be an\n"
+" iterable object, producing iterable objects each producing exactly\n"
+" two objects, the first of which is used as a key and the second as\n"
+" its value. If a given key is seen more than once, the dict retains\n"
+" the last value associated with it.";
PyTypeObject PyDict_Type = {
PyObject_HEAD_INIT(&PyType_Type)
projects / python / commitdiff