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)
``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)
``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.
+-----------------------+-------------------------+---------------------------------+
| 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)`` |
formatted = _group(formatted, monetary=monetary)[0]
return formatted
-import re, operator
+import re, collections
_percent_re = re.compile(r'%(?:\((?P<key>.*?)\))?'
r'(?P<modifiers>[-#0-9 +*.hlL]*?)[eEfFgGdiouxXcrs%]')
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)
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)
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)
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)
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)
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")
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
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
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)
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)
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__,
"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.")
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__,
projects / python / commitdiff