[Python-checkins] bpo-33462: Add __reversed__ to dict and dict views (GH-6827)
INADA Naoki
webhook-mailer at python.org
Mon Nov 5 19:38:58 EST 2018
https://github.com/python/cpython/commit/6531bf6309c8fda1954060a0fb5ea930b1efb656
commit: 6531bf6309c8fda1954060a0fb5ea930b1efb656
branch: master
author: Rémi Lapeyre <remi.lapeyre at henki.fr>
committer: INADA Naoki <methane at users.noreply.github.com>
date: 2018-11-06T09:38:54+09:00
summary:
bpo-33462: Add __reversed__ to dict and dict views (GH-6827)
files:
A Misc/NEWS.d/next/Core and Builtins/2018-05-23-17-18-02.bpo-33462.gurbpbrhe.rst
M Doc/library/stdtypes.rst
M Doc/whatsnew/3.8.rst
M Include/dictobject.h
M Lib/test/test_collections.py
M Lib/test/test_dict.py
M Lib/test/test_enumerate.py
M Objects/clinic/dictobject.c.h
M Objects/dictobject.c
M Objects/object.c
diff --git a/Doc/library/stdtypes.rst b/Doc/library/stdtypes.rst
index 4686cec96885..49d433805a32 100644
--- a/Doc/library/stdtypes.rst
+++ b/Doc/library/stdtypes.rst
@@ -4285,6 +4285,11 @@ pairs within braces, for example: ``{'jack': 4098, 'sjoerd': 4127}`` or ``{4098:
LIFO order is now guaranteed. In prior versions, :meth:`popitem` would
return an arbitrary key/value pair.
+ .. describe:: reversed(d)
+
+ Return a reversed iterator over the keys of the dictionary. This is a
+ shortcut for ``reversed(d.keys())``.
+
.. method:: setdefault(key[, default])
If *key* is in the dictionary, return its value. If not, insert *key*
@@ -4332,6 +4337,22 @@ pairs within braces, for example: ``{'jack': 4098, 'sjoerd': 4127}`` or ``{4098:
Dictionary order is guaranteed to be insertion order. This behavior was
implementation detail of CPython from 3.6.
+ Dictionaries and dictionary views are reversible. ::
+
+ >>> d = {"one": 1, "two": 2, "three": 3, "four": 4}
+ >>> d
+ {'one': 1, 'two': 2, 'three': 3, 'four': 4}
+ >>> list(reversed(d))
+ ['four', 'three', 'two', 'one']
+ >>> list(reversed(d.values()))
+ [4, 3, 2, 1]
+ >>> list(reversed(d.items()))
+ [('four', 4), ('three', 3), ('two', 2), ('one', 1)]
+
+ .. versionchanged:: 3.8
+ Dictionaries are now reversible.
+
+
.. seealso::
:class:`types.MappingProxyType` can be used to create a read-only view
of a :class:`dict`.
@@ -4375,6 +4396,14 @@ support membership tests:
Return ``True`` if *x* is in the underlying dictionary's keys, values or
items (in the latter case, *x* should be a ``(key, value)`` tuple).
+.. describe:: reversed(dictview)
+
+ Return an reversed iterator over the keys, values or items of the dictionnary.
+ The view will be iterated in reverse order of the insertion.
+
+ .. versionchanged:: 3.8
+ Dictionary views are now reversible.
+
Keys views are set-like since their entries are unique and hashable. If all
values are hashable, so that ``(key, value)`` pairs are unique and hashable,
diff --git a/Doc/whatsnew/3.8.rst b/Doc/whatsnew/3.8.rst
index 566c369c85bd..2d3a116df9d3 100644
--- a/Doc/whatsnew/3.8.rst
+++ b/Doc/whatsnew/3.8.rst
@@ -98,6 +98,9 @@ Other Language Changes
* Added support of ``\N{name}`` escapes in :mod:`regular expressions <re>`.
(Contributed by Jonathan Eunice and Serhiy Storchaka in :issue:`30688`.)
+* Dict and dictviews are now iterable in reversed insertion order using
+ :func:`reversed`. (Contributed by Rémi Lapeyre in :issue:`33462`.)
+
* The syntax allowed for keyword names in function calls was further
restricted. In particular, ``f((keyword)=arg)`` is no longer allowed. It was
never intended to permit more than a bare name on the left-hand side of a
diff --git a/Include/dictobject.h b/Include/dictobject.h
index 28930f436d70..c0f24df7d265 100644
--- a/Include/dictobject.h
+++ b/Include/dictobject.h
@@ -51,6 +51,9 @@ PyAPI_DATA(PyTypeObject) PyDict_Type;
PyAPI_DATA(PyTypeObject) PyDictIterKey_Type;
PyAPI_DATA(PyTypeObject) PyDictIterValue_Type;
PyAPI_DATA(PyTypeObject) PyDictIterItem_Type;
+PyAPI_DATA(PyTypeObject) PyDictRevIterKey_Type;
+PyAPI_DATA(PyTypeObject) PyDictRevIterItem_Type;
+PyAPI_DATA(PyTypeObject) PyDictRevIterValue_Type;
PyAPI_DATA(PyTypeObject) PyDictKeys_Type;
PyAPI_DATA(PyTypeObject) PyDictItems_Type;
PyAPI_DATA(PyTypeObject) PyDictValues_Type;
diff --git a/Lib/test/test_collections.py b/Lib/test/test_collections.py
index 0b7cb5848b1b..200e0273c33e 100644
--- a/Lib/test/test_collections.py
+++ b/Lib/test/test_collections.py
@@ -796,22 +796,21 @@ class ItBlocked(It):
def test_Reversible(self):
# Check some non-reversibles
- non_samples = [None, 42, 3.14, 1j, dict(), set(), frozenset()]
+ non_samples = [None, 42, 3.14, 1j, set(), frozenset()]
for x in non_samples:
self.assertNotIsInstance(x, Reversible)
self.assertFalse(issubclass(type(x), Reversible), repr(type(x)))
# Check some non-reversible iterables
- non_reversibles = [dict().keys(), dict().items(), dict().values(),
- Counter(), Counter().keys(), Counter().items(),
- Counter().values(), _test_gen(),
- (x for x in []), iter([]), reversed([])]
+ non_reversibles = [_test_gen(), (x for x in []), iter([]), reversed([])]
for x in non_reversibles:
self.assertNotIsInstance(x, Reversible)
self.assertFalse(issubclass(type(x), Reversible), repr(type(x)))
# Check some reversible iterables
samples = [bytes(), str(), tuple(), list(), OrderedDict(),
OrderedDict().keys(), OrderedDict().items(),
- OrderedDict().values()]
+ OrderedDict().values(), Counter(), Counter().keys(),
+ Counter().items(), Counter().values(), dict(),
+ dict().keys(), dict().items(), dict().values()]
for x in samples:
self.assertIsInstance(x, Reversible)
self.assertTrue(issubclass(type(x), Reversible), repr(type(x)))
@@ -1612,7 +1611,7 @@ def test_MutableMapping_subclass(self):
self.assertIsInstance(z, set)
list(z)
mymap['blue'] = 7 # Shouldn't affect 'z'
- self.assertEqual(sorted(z), [('orange', 3), ('red', 5)])
+ self.assertEqual(z, {('orange', 3), ('red', 5)})
def test_Sequence(self):
for sample in [tuple, list, bytes, str]:
@@ -1767,10 +1766,10 @@ def test_basics(self):
self.assertTrue(issubclass(Counter, Mapping))
self.assertEqual(len(c), 3)
self.assertEqual(sum(c.values()), 6)
- self.assertEqual(sorted(c.values()), [1, 2, 3])
- self.assertEqual(sorted(c.keys()), ['a', 'b', 'c'])
- self.assertEqual(sorted(c), ['a', 'b', 'c'])
- self.assertEqual(sorted(c.items()),
+ self.assertEqual(list(c.values()), [3, 2, 1])
+ self.assertEqual(list(c.keys()), ['a', 'b', 'c'])
+ self.assertEqual(list(c), ['a', 'b', 'c'])
+ self.assertEqual(list(c.items()),
[('a', 3), ('b', 2), ('c', 1)])
self.assertEqual(c['b'], 2)
self.assertEqual(c['z'], 0)
@@ -1784,7 +1783,7 @@ def test_basics(self):
for i in range(5):
self.assertEqual(c.most_common(i),
[('a', 3), ('b', 2), ('c', 1)][:i])
- self.assertEqual(''.join(sorted(c.elements())), 'aaabbc')
+ self.assertEqual(''.join(c.elements()), 'aaabbc')
c['a'] += 1 # increment an existing value
c['b'] -= 2 # sub existing value to zero
del c['c'] # remove an entry
@@ -1793,7 +1792,7 @@ def test_basics(self):
c['e'] = -5 # directly assign a missing value
c['f'] += 4 # add to a missing value
self.assertEqual(c, dict(a=4, b=0, d=-2, e=-5, f=4))
- self.assertEqual(''.join(sorted(c.elements())), 'aaaaffff')
+ self.assertEqual(''.join(c.elements()), 'aaaaffff')
self.assertEqual(c.pop('f'), 4)
self.assertNotIn('f', c)
for i in range(3):
diff --git a/Lib/test/test_dict.py b/Lib/test/test_dict.py
index 90c0a3131a78..71fffe398f34 100644
--- a/Lib/test/test_dict.py
+++ b/Lib/test/test_dict.py
@@ -1021,7 +1021,7 @@ def test_iterator_pickling(self):
it = iter(data)
d = pickle.dumps(it, proto)
it = pickle.loads(d)
- self.assertEqual(sorted(it), sorted(data))
+ self.assertEqual(list(it), list(data))
it = pickle.loads(d)
try:
@@ -1031,7 +1031,7 @@ def test_iterator_pickling(self):
d = pickle.dumps(it, proto)
it = pickle.loads(d)
del data[drop]
- self.assertEqual(sorted(it), sorted(data))
+ self.assertEqual(list(it), list(data))
def test_itemiterator_pickling(self):
for proto in range(pickle.HIGHEST_PROTOCOL + 1):
@@ -1062,7 +1062,7 @@ def test_valuesiterator_pickling(self):
it = iter(data.values())
d = pickle.dumps(it, proto)
it = pickle.loads(d)
- self.assertEqual(sorted(list(it)), sorted(list(data.values())))
+ self.assertEqual(list(it), list(data.values()))
it = pickle.loads(d)
drop = next(it)
@@ -1071,6 +1071,62 @@ def test_valuesiterator_pickling(self):
values = list(it) + [drop]
self.assertEqual(sorted(values), sorted(list(data.values())))
+ def test_reverseiterator_pickling(self):
+ for proto in range(pickle.HIGHEST_PROTOCOL + 1):
+ data = {1:"a", 2:"b", 3:"c"}
+ it = reversed(data)
+ d = pickle.dumps(it, proto)
+ it = pickle.loads(d)
+ self.assertEqual(list(it), list(reversed(data)))
+
+ it = pickle.loads(d)
+ try:
+ drop = next(it)
+ except StopIteration:
+ continue
+ d = pickle.dumps(it, proto)
+ it = pickle.loads(d)
+ del data[drop]
+ self.assertEqual(list(it), list(reversed(data)))
+
+ def test_reverseitemiterator_pickling(self):
+ for proto in range(pickle.HIGHEST_PROTOCOL + 1):
+ data = {1:"a", 2:"b", 3:"c"}
+ # dictviews aren't picklable, only their iterators
+ itorg = reversed(data.items())
+ d = pickle.dumps(itorg, proto)
+ it = pickle.loads(d)
+ # note that the type of the unpickled iterator
+ # is not necessarily the same as the original. It is
+ # merely an object supporting the iterator protocol, yielding
+ # the same objects as the original one.
+ # self.assertEqual(type(itorg), type(it))
+ self.assertIsInstance(it, collections.abc.Iterator)
+ self.assertEqual(dict(it), data)
+
+ it = pickle.loads(d)
+ drop = next(it)
+ d = pickle.dumps(it, proto)
+ it = pickle.loads(d)
+ del data[drop[0]]
+ self.assertEqual(dict(it), data)
+
+ def test_reversevaluesiterator_pickling(self):
+ for proto in range(pickle.HIGHEST_PROTOCOL):
+ data = {1:"a", 2:"b", 3:"c"}
+ # data.values() isn't picklable, only its iterator
+ it = reversed(data.values())
+ d = pickle.dumps(it, proto)
+ it = pickle.loads(d)
+ self.assertEqual(list(it), list(reversed(data.values())))
+
+ it = pickle.loads(d)
+ drop = next(it)
+ d = pickle.dumps(it, proto)
+ it = pickle.loads(d)
+ values = list(it) + [drop]
+ self.assertEqual(sorted(values), sorted(data.values()))
+
def test_instance_dict_getattr_str_subclass(self):
class Foo:
def __init__(self, msg):
@@ -1222,6 +1278,13 @@ def iter_and_mutate():
self.assertRaises(RuntimeError, iter_and_mutate)
+ def test_reversed(self):
+ d = {"a": 1, "b": 2, "foo": 0, "c": 3, "d": 4}
+ del d["foo"]
+ r = reversed(d)
+ self.assertEqual(list(r), list('dcba'))
+ self.assertRaises(StopIteration, next, r)
+
def test_dict_copy_order(self):
# bpo-34320
od = collections.OrderedDict([('a', 1), ('b', 2)])
diff --git a/Lib/test/test_enumerate.py b/Lib/test/test_enumerate.py
index e455adee50fe..5785cb46492e 100644
--- a/Lib/test/test_enumerate.py
+++ b/Lib/test/test_enumerate.py
@@ -160,9 +160,9 @@ def __getitem__(self, i):
raise StopIteration
def __len__(self):
return 5
- for data in 'abc', range(5), tuple(enumerate('abc')), A(), range(1,17,5):
+ for data in ('abc', range(5), tuple(enumerate('abc')), A(),
+ range(1,17,5), dict.fromkeys('abcde')):
self.assertEqual(list(data)[::-1], list(reversed(data)))
- self.assertRaises(TypeError, reversed, {})
# don't allow keyword arguments
self.assertRaises(TypeError, reversed, [], a=1)
diff --git a/Misc/NEWS.d/next/Core and Builtins/2018-05-23-17-18-02.bpo-33462.gurbpbrhe.rst b/Misc/NEWS.d/next/Core and Builtins/2018-05-23-17-18-02.bpo-33462.gurbpbrhe.rst
new file mode 100644
index 000000000000..ed1f0342731e
--- /dev/null
+++ b/Misc/NEWS.d/next/Core and Builtins/2018-05-23-17-18-02.bpo-33462.gurbpbrhe.rst
@@ -0,0 +1 @@
+Make dict and dict views reversible. Patch by Rémi Lapeyre.
diff --git a/Objects/clinic/dictobject.c.h b/Objects/clinic/dictobject.c.h
index 58677cd772bc..4f4c9fa9cb7a 100644
--- a/Objects/clinic/dictobject.c.h
+++ b/Objects/clinic/dictobject.c.h
@@ -103,4 +103,22 @@ dict_setdefault(PyDictObject *self, PyObject *const *args, Py_ssize_t nargs)
exit:
return return_value;
}
-/*[clinic end generated code: output=d7508c5091609a23 input=a9049054013a1b77]*/
+
+PyDoc_STRVAR(dict___reversed____doc__,
+"__reversed__($self, /)\n"
+"--\n"
+"\n"
+"Return a reverse iterator over the dict keys.");
+
+#define DICT___REVERSED___METHODDEF \
+ {"__reversed__", (PyCFunction)dict___reversed__, METH_NOARGS, dict___reversed____doc__},
+
+static PyObject *
+dict___reversed___impl(PyDictObject *self);
+
+static PyObject *
+dict___reversed__(PyDictObject *self, PyObject *Py_UNUSED(ignored))
+{
+ return dict___reversed___impl(self);
+}
+/*[clinic end generated code: output=b9923851cbd9213a input=a9049054013a1b77]*/
diff --git a/Objects/dictobject.c b/Objects/dictobject.c
index ea564a2b7c9f..08ec9e254ab2 100644
--- a/Objects/dictobject.c
+++ b/Objects/dictobject.c
@@ -3100,6 +3100,7 @@ static PyMethodDef mapp_methods[] = {
clear__doc__},
{"copy", (PyCFunction)dict_copy, METH_NOARGS,
copy__doc__},
+ DICT___REVERSED___METHODDEF
{NULL, NULL} /* sentinel */
};
@@ -3335,22 +3336,32 @@ dictiter_new(PyDictObject *dict, PyTypeObject *itertype)
{
dictiterobject *di;
di = PyObject_GC_New(dictiterobject, itertype);
- if (di == NULL)
+ if (di == NULL) {
return NULL;
+ }
Py_INCREF(dict);
di->di_dict = dict;
di->di_used = dict->ma_used;
- di->di_pos = 0;
di->len = dict->ma_used;
- if (itertype == &PyDictIterItem_Type) {
+ if ((itertype == &PyDictRevIterKey_Type ||
+ itertype == &PyDictRevIterItem_Type ||
+ itertype == &PyDictRevIterValue_Type) && dict->ma_used) {
+ di->di_pos = dict->ma_keys->dk_nentries - 1;
+ }
+ else {
+ di->di_pos = 0;
+ }
+ if (itertype == &PyDictIterItem_Type ||
+ itertype == &PyDictRevIterItem_Type) {
di->di_result = PyTuple_Pack(2, Py_None, Py_None);
if (di->di_result == NULL) {
Py_DECREF(di);
return NULL;
}
}
- else
+ else {
di->di_result = NULL;
+ }
_PyObject_GC_TRACK(di);
return (PyObject *)di;
}
@@ -3664,6 +3675,120 @@ PyTypeObject PyDictIterItem_Type = {
};
+/* dictreviter */
+
+static PyObject *
+dictreviter_iternext(dictiterobject *di)
+{
+ PyDictObject *d = di->di_dict;
+
+ if (d == NULL) {
+ return NULL;
+ }
+ assert (PyDict_Check(d));
+
+ if (di->di_used != d->ma_used) {
+ PyErr_SetString(PyExc_RuntimeError,
+ "dictionary changed size during iteration");
+ di->di_used = -1; /* Make this state sticky */
+ return NULL;
+ }
+
+ Py_ssize_t i = di->di_pos;
+ PyDictKeysObject *k = d->ma_keys;
+ PyObject *key, *value, *result;
+
+ if (d->ma_values) {
+ if (i < 0) {
+ goto fail;
+ }
+ key = DK_ENTRIES(k)[i].me_key;
+ value = d->ma_values[i];
+ assert (value != NULL);
+ }
+ else {
+ PyDictKeyEntry *entry_ptr = &DK_ENTRIES(k)[i];
+ while (i >= 0 && entry_ptr->me_value == NULL) {
+ entry_ptr--;
+ i--;
+ }
+ if (i < 0) {
+ goto fail;
+ }
+ key = entry_ptr->me_key;
+ value = entry_ptr->me_value;
+ }
+ di->di_pos = i-1;
+ di->len--;
+
+ if (Py_TYPE(di) == &PyDictRevIterKey_Type) {
+ Py_INCREF(key);
+ return key;
+ }
+ else if (Py_TYPE(di) == &PyDictRevIterValue_Type) {
+ Py_INCREF(value);
+ return value;
+ }
+ else if (Py_TYPE(di) == &PyDictRevIterItem_Type) {
+ Py_INCREF(key);
+ Py_INCREF(value);
+ result = di->di_result;
+ if (Py_REFCNT(result) == 1) {
+ PyObject *oldkey = PyTuple_GET_ITEM(result, 0);
+ PyObject *oldvalue = PyTuple_GET_ITEM(result, 1);
+ PyTuple_SET_ITEM(result, 0, key); /* steals reference */
+ PyTuple_SET_ITEM(result, 1, value); /* steals reference */
+ Py_INCREF(result);
+ Py_DECREF(oldkey);
+ Py_DECREF(oldvalue);
+ }
+ else {
+ result = PyTuple_New(2);
+ if (result == NULL) {
+ return NULL;
+ }
+ PyTuple_SET_ITEM(result, 0, key); /* steals reference */
+ PyTuple_SET_ITEM(result, 1, value); /* steals reference */
+ }
+ return result;
+ }
+ else {
+ Py_UNREACHABLE();
+ }
+
+fail:
+ di->di_dict = NULL;
+ Py_DECREF(d);
+ return NULL;
+}
+
+PyTypeObject PyDictRevIterKey_Type = {
+ PyVarObject_HEAD_INIT(&PyType_Type, 0)
+ "dict_reversekeyiterator",
+ sizeof(dictiterobject),
+ .tp_dealloc = (destructor)dictiter_dealloc,
+ .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC,
+ .tp_traverse = (traverseproc)dictiter_traverse,
+ .tp_iter = PyObject_SelfIter,
+ .tp_iternext = (iternextfunc)dictreviter_iternext,
+ .tp_methods = dictiter_methods
+};
+
+
+/*[clinic input]
+dict.__reversed__
+
+Return a reverse iterator over the dict keys.
+[clinic start generated code]*/
+
+static PyObject *
+dict___reversed___impl(PyDictObject *self)
+/*[clinic end generated code: output=e674483336d1ed51 input=23210ef3477d8c4d]*/
+{
+ assert (PyDict_Check(self));
+ return dictiter_new(self, &PyDictRevIterKey_Type);
+}
+
static PyObject *
dictiter_reduce(dictiterobject *di, PyObject *Py_UNUSED(ignored))
{
@@ -3671,7 +3796,6 @@ dictiter_reduce(dictiterobject *di, PyObject *Py_UNUSED(ignored))
dictiterobject tmp = *di;
Py_XINCREF(tmp.di_dict);
- /* iterate the temporary into a list */
PyObject *list = PySequence_List((PyObject*)&tmp);
Py_XDECREF(tmp.di_dict);
if (list == NULL) {
@@ -3680,6 +3804,30 @@ dictiter_reduce(dictiterobject *di, PyObject *Py_UNUSED(ignored))
return Py_BuildValue("N(N)", _PyObject_GetBuiltin("iter"), list);
}
+PyTypeObject PyDictRevIterItem_Type = {
+ PyVarObject_HEAD_INIT(&PyType_Type, 0)
+ "dict_reverseitemiterator",
+ sizeof(dictiterobject),
+ .tp_dealloc = (destructor)dictiter_dealloc,
+ .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC,
+ .tp_traverse = (traverseproc)dictiter_traverse,
+ .tp_iter = PyObject_SelfIter,
+ .tp_iternext = (iternextfunc)dictreviter_iternext,
+ .tp_methods = dictiter_methods
+};
+
+PyTypeObject PyDictRevIterValue_Type = {
+ PyVarObject_HEAD_INIT(&PyType_Type, 0)
+ "dict_reversevalueiterator",
+ sizeof(dictiterobject),
+ .tp_dealloc = (destructor)dictiter_dealloc,
+ .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC,
+ .tp_traverse = (traverseproc)dictiter_traverse,
+ .tp_iter = PyObject_SelfIter,
+ .tp_iternext = (iternextfunc)dictreviter_iternext,
+ .tp_methods = dictiter_methods
+};
+
/***********************************************/
/* View objects for keys(), items(), values(). */
/***********************************************/
@@ -4035,9 +4183,16 @@ dictviews_isdisjoint(PyObject *self, PyObject *other)
PyDoc_STRVAR(isdisjoint_doc,
"Return True if the view and the given iterable have a null intersection.");
+static PyObject* dictkeys_reversed(_PyDictViewObject *dv);
+
+PyDoc_STRVAR(reversed_keys_doc,
+"Return a reverse iterator over the dict keys.");
+
static PyMethodDef dictkeys_methods[] = {
{"isdisjoint", (PyCFunction)dictviews_isdisjoint, METH_O,
isdisjoint_doc},
+ {"__reversed__", (PyCFunction)dictkeys_reversed, METH_NOARGS,
+ reversed_keys_doc},
{NULL, NULL} /* sentinel */
};
@@ -4080,6 +4235,15 @@ dictkeys_new(PyObject *dict, PyObject *Py_UNUSED(ignored))
return _PyDictView_New(dict, &PyDictKeys_Type);
}
+static PyObject *
+dictkeys_reversed(_PyDictViewObject *dv)
+{
+ if (dv->dv_dict == NULL) {
+ Py_RETURN_NONE;
+ }
+ return dictiter_new(dv->dv_dict, &PyDictRevIterKey_Type);
+}
+
/*** dict_items ***/
static PyObject *
@@ -4125,9 +4289,16 @@ static PySequenceMethods dictitems_as_sequence = {
(objobjproc)dictitems_contains, /* sq_contains */
};
+static PyObject* dictitems_reversed(_PyDictViewObject *dv);
+
+PyDoc_STRVAR(reversed_items_doc,
+"Return a reverse iterator over the dict items.");
+
static PyMethodDef dictitems_methods[] = {
{"isdisjoint", (PyCFunction)dictviews_isdisjoint, METH_O,
isdisjoint_doc},
+ {"__reversed__", (PyCFunction)dictitems_reversed, METH_NOARGS,
+ reversed_items_doc},
{NULL, NULL} /* sentinel */
};
@@ -4170,6 +4341,15 @@ dictitems_new(PyObject *dict, PyObject *Py_UNUSED(ignored))
return _PyDictView_New(dict, &PyDictItems_Type);
}
+static PyObject *
+dictitems_reversed(_PyDictViewObject *dv)
+{
+ if (dv->dv_dict == NULL) {
+ Py_RETURN_NONE;
+ }
+ return dictiter_new(dv->dv_dict, &PyDictRevIterItem_Type);
+}
+
/*** dict_values ***/
static PyObject *
@@ -4192,7 +4372,14 @@ static PySequenceMethods dictvalues_as_sequence = {
(objobjproc)0, /* sq_contains */
};
+static PyObject* dictvalues_reversed(_PyDictViewObject *dv);
+
+PyDoc_STRVAR(reversed_values_doc,
+"Return a reverse iterator over the dict values.");
+
static PyMethodDef dictvalues_methods[] = {
+ {"__reversed__", (PyCFunction)dictvalues_reversed, METH_NOARGS,
+ reversed_values_doc},
{NULL, NULL} /* sentinel */
};
@@ -4235,6 +4422,16 @@ dictvalues_new(PyObject *dict, PyObject *Py_UNUSED(ignored))
return _PyDictView_New(dict, &PyDictValues_Type);
}
+static PyObject *
+dictvalues_reversed(_PyDictViewObject *dv)
+{
+ if (dv->dv_dict == NULL) {
+ Py_RETURN_NONE;
+ }
+ return dictiter_new(dv->dv_dict, &PyDictRevIterValue_Type);
+}
+
+
/* Returns NULL if cannot allocate a new PyDictKeysObject,
but does not set an error */
PyDictKeysObject *
diff --git a/Objects/object.c b/Objects/object.c
index d3a97f6c5bd4..72e2684820ce 100644
--- a/Objects/object.c
+++ b/Objects/object.c
@@ -1790,6 +1790,15 @@ _Py_ReadyTypes(void)
if (PyType_Ready(&PyDictItems_Type) < 0)
Py_FatalError("Can't initialize dict items type");
+ if (PyType_Ready(&PyDictRevIterKey_Type) < 0)
+ Py_FatalError("Can't initialize reversed dict keys type");
+
+ if (PyType_Ready(&PyDictRevIterValue_Type) < 0)
+ Py_FatalError("Can't initialize reversed dict values type");
+
+ if (PyType_Ready(&PyDictRevIterItem_Type) < 0)
+ Py_FatalError("Can't initialize reversed dict items type");
+
if (PyType_Ready(&PyODict_Type) < 0)
Py_FatalError("Can't initialize OrderedDict type");
More information about the Python-checkins
mailing list