From 89e12963ad7f0551b325b282267ad21011aa5fd7 Mon Sep 17 00:00:00 2001 From: Raymond Hettinger Date: Mon, 26 Jan 2009 02:09:03 +0000 Subject: As discussed on python-dev, remove several operator functions isSequenceType(), isMappingType(), and isNumberType() in favor of using abstract base classes. Also, remove repeat() and irepeat() in favor of mul() and imul(). After the buildbots have had a go at this. Will backport to Py3.0.1. For Py2.7, will just mark as deprecated. --- Doc/library/operator.rst | 76 ----------------------------------------------- Lib/locale.py | 4 +-- Lib/test/test_array.py | 2 -- Lib/test/test_bool.py | 6 ---- Lib/test/test_operator.py | 52 -------------------------------- Misc/NEWS | 4 +++ Modules/operator.c | 15 ---------- 7 files changed, 6 insertions(+), 153 deletions(-) diff --git a/Doc/library/operator.rst b/Doc/library/operator.rst index d1d1c16..089c7fa 100644 --- a/Doc/library/operator.rst +++ b/Doc/library/operator.rst @@ -221,12 +221,6 @@ Operations which work with sequences include: Return the index of the first of occurrence of *b* in *a*. -.. function:: repeat(a, b) - __repeat__(a, b) - - Return ``a * b`` where *a* is a sequence and *b* is an integer. - - .. function:: setitem(a, b, c) __setitem__(a, b, c) @@ -294,13 +288,6 @@ example, the :term:`statement` ``x += y`` is equivalent to ``a = ipow(a, b)`` is equivalent to ``a **= b``. -.. function:: irepeat(a, b) - __irepeat__(a, b) - - ``a = irepeat(a, b)`` is equivalent to ``a *= b`` where *a* is a sequence and - *b* is an integer. - - .. function:: irshift(a, b) __irshift__(a, b) @@ -324,67 +311,6 @@ example, the :term:`statement` ``x += y`` is equivalent to ``a = ixor(a, b)`` is equivalent to ``a ^= b``. - -The :mod:`operator` module also defines a few predicates to test the type of -objects. - -.. XXX just remove them? -.. note:: - - Be careful not to misinterpret the results of these functions; none have any - measure of reliability with instance objects. - For example: - - >>> class C: - ... pass - ... - >>> import operator - >>> obj = C() - >>> operator.isMappingType(obj) - True - -.. note:: - - Since there are now abstract classes for collection types, you should write, - for example, ``isinstance(obj, collections.Mapping)`` and ``isinstance(obj, - collections.Sequence)``. - -.. function:: isMappingType(obj) - - Returns true if the object *obj* supports the mapping interface. This is true for - dictionaries and all instance objects defining :meth:`__getitem__`. - - .. warning:: - - There is no reliable way to test if an instance supports the complete mapping - protocol since the interface itself is ill-defined. This makes this test less - useful than it otherwise might be. - - -.. function:: isNumberType(obj) - - Returns true if the object *obj* represents a number. This is true for all - numeric types implemented in C. - - .. warning:: - - There is no reliable way to test if an instance supports the complete numeric - interface since the interface itself is ill-defined. This makes this test less - useful than it otherwise might be. - - -.. function:: isSequenceType(obj) - - Returns true if the object *obj* supports the sequence protocol. This returns true - for all objects which define sequence methods in C, and for all instance objects - defining :meth:`__getitem__`. - - .. warning:: - - There is no reliable way to test if an instance supports the complete sequence - interface since the interface itself is ill-defined. This makes this test less - useful than it otherwise might be. - Example: Build a dictionary that maps the ordinals from ``0`` to ``255`` to their character equivalents. @@ -513,8 +439,6 @@ Python syntax and the functions in the :mod:`operator` module. +-----------------------+-------------------------+---------------------------------+ | Right Shift | ``a >> b`` | ``rshift(a, b)`` | +-----------------------+-------------------------+---------------------------------+ -| Sequence Repetition | ``seq * i`` | ``repeat(seq, i)`` | -+-----------------------+-------------------------+---------------------------------+ | String Formatting | ``s % obj`` | ``mod(s, obj)`` | +-----------------------+-------------------------+---------------------------------+ | Subtraction | ``a - b`` | ``sub(a, b)`` | diff --git a/Lib/locale.py b/Lib/locale.py index 0bed19e..4116ef1 100644 --- a/Lib/locale.py +++ b/Lib/locale.py @@ -187,7 +187,7 @@ def format(percent, value, grouping=False, monetary=False, *additional): formatted = _group(formatted, monetary=monetary)[0] return formatted -import re, operator +import re, collections _percent_re = re.compile(r'%(?:\((?P.*?)\))?' r'(?P[-#0-9 +*.hlL]*?)[eEfFgGdiouxXcrs%]') @@ -207,7 +207,7 @@ def format_string(f, val, grouping=False): del new_val[i+1:i+1+starcount] i += (1 + starcount) val = tuple(new_val) - elif operator.isMappingType(val): + elif isinstance(val, collections.Mapping): for perc in percents: key = perc.group("key") val[key] = format(perc.group(), val[key], grouping) diff --git a/Lib/test/test_array.py b/Lib/test/test_array.py index 2b80a7d..08c64cb 100755 --- a/Lib/test/test_array.py +++ b/Lib/test/test_array.py @@ -725,8 +725,6 @@ class BaseTest(unittest.TestCase): self.assertRaises(BufferError, operator.setitem, a, slice(0, 0), a) self.assertRaises(BufferError, operator.delitem, a, 0) self.assertRaises(BufferError, operator.delitem, a, slice(0, 1)) - self.assertRaises(BufferError, operator.irepeat, a, 2) - self.assertRaises(BufferError, operator.irepeat, a, 0) def test_weakref(self): s = array.array(self.typecode, self.example) diff --git a/Lib/test/test_bool.py b/Lib/test/test_bool.py index 591b0eb..80229aa 100644 --- a/Lib/test/test_bool.py +++ b/Lib/test/test_bool.py @@ -245,16 +245,10 @@ class BoolTest(unittest.TestCase): import operator self.assertIs(operator.truth(0), False) self.assertIs(operator.truth(1), True) - self.assertIs(operator.isNumberType(None), False) - self.assertIs(operator.isNumberType(0), True) self.assertIs(operator.not_(1), False) self.assertIs(operator.not_(0), True) - self.assertIs(operator.isSequenceType(0), False) - self.assertIs(operator.isSequenceType([]), True) self.assertIs(operator.contains([], 1), False) self.assertIs(operator.contains([1], 1), True) - self.assertIs(operator.isMappingType(1), False) - self.assertIs(operator.isMappingType({}), True) self.assertIs(operator.lt(0, 0), False) self.assertIs(operator.lt(0, 1), True) self.assertIs(operator.is_(True, True), True) diff --git a/Lib/test/test_operator.py b/Lib/test/test_operator.py index 2a02dac..bf38298 100644 --- a/Lib/test/test_operator.py +++ b/Lib/test/test_operator.py @@ -164,31 +164,6 @@ class OperatorTestCase(unittest.TestCase): self.failUnlessRaises(TypeError, operator.invert, None) self.assertEqual(operator.inv(4), -5) - def test_isMappingType(self): - self.failUnlessRaises(TypeError, operator.isMappingType) - self.failIf(operator.isMappingType(1)) - self.failIf(operator.isMappingType(operator.isMappingType)) - self.failUnless(operator.isMappingType(operator.__dict__)) - self.failUnless(operator.isMappingType({})) - - def test_isNumberType(self): - self.failUnlessRaises(TypeError, operator.isNumberType) - self.failUnless(operator.isNumberType(8)) - self.failUnless(operator.isNumberType(8j)) - self.failUnless(operator.isNumberType(8)) - self.failUnless(operator.isNumberType(8.3)) - self.failIf(operator.isNumberType(dir())) - - def test_isSequenceType(self): - self.failUnlessRaises(TypeError, operator.isSequenceType) - self.failUnless(operator.isSequenceType(dir())) - self.failUnless(operator.isSequenceType(())) - self.failUnless(operator.isSequenceType(range(10))) - self.failUnless(operator.isSequenceType('yeahbuddy')) - self.failIf(operator.isSequenceType(3)) - class Dict(dict): pass - self.failIf(operator.isSequenceType(Dict())) - def test_lshift(self): self.failUnlessRaises(TypeError, operator.lshift) self.failUnlessRaises(TypeError, operator.lshift, None, 42) @@ -235,31 +210,6 @@ class OperatorTestCase(unittest.TestCase): self.assertRaises(TypeError, operator.pow, 1) self.assertRaises(TypeError, operator.pow, 1, 2, 3) - def test_repeat(self): - a = list(range(3)) - self.failUnlessRaises(TypeError, operator.repeat) - self.failUnlessRaises(TypeError, operator.repeat, a, None) - self.failUnless(operator.repeat(a, 2) == a+a) - self.failUnless(operator.repeat(a, 1) == a) - self.failUnless(operator.repeat(a, 0) == []) - a = (1, 2, 3) - self.failUnless(operator.repeat(a, 2) == a+a) - self.failUnless(operator.repeat(a, 1) == a) - self.failUnless(operator.repeat(a, 0) == ()) - a = '123' - self.failUnless(operator.repeat(a, 2) == a+a) - self.failUnless(operator.repeat(a, 1) == a) - self.failUnless(operator.repeat(a, 0) == '') - a = Seq1([4, 5, 6]) - self.failUnless(operator.repeat(a, 2) == [4, 5, 6, 4, 5, 6]) - self.failUnless(operator.repeat(a, 1) == [4, 5, 6]) - self.failUnless(operator.repeat(a, 0) == []) - a = Seq2([4, 5, 6]) - self.failUnless(operator.repeat(a, 2) == [4, 5, 6, 4, 5, 6]) - self.failUnless(operator.repeat(a, 1) == [4, 5, 6]) - self.failUnless(operator.repeat(a, 0) == []) - self.failUnlessRaises(TypeError, operator.repeat, 6, 7) - def test_rshift(self): self.failUnlessRaises(TypeError, operator.rshift) self.failUnlessRaises(TypeError, operator.rshift, None, 42) @@ -443,7 +393,6 @@ class OperatorTestCase(unittest.TestCase): self.assertEqual(operator.itruediv (c, 5), "itruediv") self.assertEqual(operator.ixor (c, 5), "ixor") self.assertEqual(operator.iconcat (c, c), "iadd") - self.assertEqual(operator.irepeat (c, 5), "imul") self.assertEqual(operator.__iadd__ (c, 5), "iadd") self.assertEqual(operator.__iand__ (c, 5), "iand") self.assertEqual(operator.__ifloordiv__(c, 5), "ifloordiv") @@ -457,7 +406,6 @@ class OperatorTestCase(unittest.TestCase): self.assertEqual(operator.__itruediv__ (c, 5), "itruediv") self.assertEqual(operator.__ixor__ (c, 5), "ixor") self.assertEqual(operator.__iconcat__ (c, c), "iadd") - self.assertEqual(operator.__irepeat__ (c, 5), "imul") def test_main(verbose=None): import sys diff --git a/Misc/NEWS b/Misc/NEWS index 0263056..3c69228 100644 --- a/Misc/NEWS +++ b/Misc/NEWS @@ -144,6 +144,10 @@ Core and Builtins Library ------- +- Removed isSequenceType(), isMappingType, and isNumberType() from the + operator module; use the abstract base classes instead. Also removed + the repeat() function; use mul() instead. + - Issue #4863: distutils.mwerkscompiler has been removed. - Fix and properly document the multiprocessing module's logging diff --git a/Modules/operator.c b/Modules/operator.c index 1398fca..9a1efb2 100644 --- a/Modules/operator.c +++ b/Modules/operator.c @@ -65,7 +65,6 @@ used for special class methods; variants without leading and trailing\n\ if(! PyArg_UnpackTuple(a,#OP,2,2,&a1,&a2)) return NULL; \ return PyObject_RichCompare(a1,a2,A); } -spami(isNumberType , PyNumber_Check) spami(truth , PyObject_IsTrue) spam2(op_add , PyNumber_Add) spam2(op_sub , PyNumber_Subtract) @@ -95,15 +94,11 @@ spam2(op_irshift , PyNumber_InPlaceRshift) spam2(op_iand , PyNumber_InPlaceAnd) spam2(op_ixor , PyNumber_InPlaceXor) spam2(op_ior , PyNumber_InPlaceOr) -spami(isSequenceType , PySequence_Check) spam2(op_concat , PySequence_Concat) -spamoi(op_repeat , PySequence_Repeat) spam2(op_iconcat , PySequence_InPlaceConcat) -spamoi(op_irepeat , PySequence_InPlaceRepeat) spami2b(op_contains , PySequence_Contains) spamn2(indexOf , PySequence_Index) spamn2(countOf , PySequence_Count) -spami(isMappingType , PyMapping_Check) spam2(op_getitem , PyObject_GetItem) spam2n(op_delitem , PyObject_DelItem) spam3n(op_setitem , PyObject_SetItem) @@ -173,10 +168,6 @@ is_not(PyObject *s, PyObject *a) static struct PyMethodDef operator_methods[] = { -spam1o(isNumberType, - "isNumberType(a) -- Return True if a has a numeric type, False otherwise.") -spam1o(isSequenceType, - "isSequenceType(a) -- Return True if a has a sequence type, False otherwise.") spam1o(truth, "truth(a) -- Return True if a is true, False otherwise.") spam2(contains,__contains__, @@ -185,8 +176,6 @@ spam1(indexOf, "indexOf(a, b) -- Return the first index of b in a.") spam1(countOf, "countOf(a, b) -- Return the number of times b occurs in a.") -spam1o(isMappingType, - "isMappingType(a) -- Return True if a has a mapping type, False otherwise.") spam1(is_, "is_(a, b) -- Same as a is b.") spam1(is_not, "is_not(a, b) -- Same as a is not b.") @@ -221,12 +210,8 @@ spam2(ixor,__ixor__, "ixor(a, b) -- Same as a ^= b.") spam2(ior,__ior__, "ior(a, b) -- Same as a |= b.") spam2(concat,__concat__, "concat(a, b) -- Same as a + b, for a and b sequences.") -spam2(repeat,__repeat__, - "repeat(a, b) -- Return a * b, where a is a sequence, and b is an integer.") spam2(iconcat,__iconcat__, "iconcat(a, b) -- Same as a += b, for a and b sequences.") -spam2(irepeat,__irepeat__, - "irepeat(a, b) -- Same as a *= b, where a is a sequence, and b is an integer.") spam2(getitem,__getitem__, "getitem(a, b) -- Same as a[b].") spam2(setitem,__setitem__, -- cgit v0.12