Issue #10516: added copy() and clear() methods to bytearrays as well

Doc/library/stdtypes.rst

@@ -1675,10 +1675,10 @@ Note that while lists allow their items to be of any type, bytearray object
 | ``s.extend(x)``              | same as ``s[len(s):len(s)] =   | \(2)                |
 |                              | x``                            |                     |
 +------------------------------+--------------------------------+---------------------+
-| ``s.clear()``                | remove all items from ``s``    | \(8)                |
+| ``s.clear()``                | remove all items from ``s``    |                     |
 |                              |                                |                     |
 +------------------------------+--------------------------------+---------------------+
-| ``s.copy()``                 | return a shallow copy of ``s`` | \(8)                |
+| ``s.copy()``                 | return a shallow copy of ``s`` |                     |
 |                              |                                |                     |
 +------------------------------+--------------------------------+---------------------+
 | ``s.count(x)``               | return number of *i*'s for     |                     |
@@ -1757,8 +1757,7 @@ Notes:
       detect that the list has been mutated during a sort.
 
 (8)
-   :meth:`clear`, :meth:`!copy` and :meth:`sort` are not supported by
-   :class:`bytearray` objects.
+   :meth:`sort` is not supported by :class:`bytearray` objects.
 
     .. versionadded:: 3.3
        :meth:`clear` and :meth:`!copy` methods.

Lib/test/test_bytes.py

@@ -564,6 +564,39 @@ class ByteArrayTest(BaseBytesTest):
         b.reverse()
         self.assertFalse(b)
 
+    def test_clear(self):
+        b = bytearray(b'python')
+        b.clear()
+        self.assertEqual(b, b'')
+
+        b = bytearray(b'')
+        b.clear()
+        self.assertEqual(b, b'')
+
+        b = bytearray(b'')
+        b.append(ord('r'))
+        b.clear()
+        b.append(ord('p'))
+        self.assertEqual(b, b'p')
+
+    def test_copy(self):
+        b = bytearray(b'abc')
+        bb = b.copy()
+        self.assertEqual(bb, b'abc')
+
+        b = bytearray(b'')
+        bb = b.copy()
+        self.assertEqual(bb, b'')
+
+        # test that it's indeed a copy and not a reference
+        b = bytearray(b'abc')
+        bb = b.copy()
+        self.assertEqual(b, bb)
+        self.assertIsNot(b, bb)
+        bb.append(ord('d'))
+        self.assertEqual(bb, b'abcd')
+        self.assertEqual(b, b'abc')
+
     def test_regexps(self):
         def by(s):
             return bytearray(map(ord, s))

Misc/NEWS

@@ -47,7 +47,7 @@ Core and Builtins
 
 - Check for NULL result in PyType_FromSpec.
 
-- Issue #10516: New copy() and clear() methods for lists.
+- Issue #10516: New copy() and clear() methods for lists and bytearrays.
 
 Library
 -------

Objects/bytearrayobject.c

@@ -1148,6 +1148,30 @@ bytearray_count(PyByteArrayObject *self, PyObject *args)
     return count_obj;
 }
 
+PyDoc_STRVAR(clear__doc__,
+"B.clear() -> None\n\
+\n\
+Remove all items from B.");
+
+static PyObject * 
+bytearray_clear(PyByteArrayObject *self)
+{
+    if (PyByteArray_Resize((PyObject *)self, 0) < 0)
+        return NULL;
+    Py_RETURN_NONE;
+}
+
+PyDoc_STRVAR(copy__doc__,
+"B.copy() -> bytearray\n\
+\n\
+Return a copy of B.");
+
+static PyObject *
+bytearray_copy(PyByteArrayObject *self)
+{
+    return PyByteArray_FromStringAndSize(PyByteArray_AS_STRING((PyObject *)self),
+                                         PyByteArray_GET_SIZE(self));
+}
 
 PyDoc_STRVAR(index__doc__,
 "B.index(sub[, start[, end]]) -> int\n\
@@ -2730,6 +2754,8 @@ bytearray_methods[] = {
     {"capitalize", (PyCFunction)stringlib_capitalize, METH_NOARGS,
      _Py_capitalize__doc__},
     {"center", (PyCFunction)stringlib_center, METH_VARARGS, center__doc__},
+    {"clear", (PyCFunction)bytearray_clear, METH_NOARGS, clear__doc__},
+    {"copy", (PyCFunction)bytearray_copy, METH_NOARGS, copy__doc__},
     {"count", (PyCFunction)bytearray_count, METH_VARARGS, count__doc__},
     {"decode", (PyCFunction)bytearray_decode, METH_VARARGS | METH_KEYWORDS, decode_doc},
     {"endswith", (PyCFunction)bytearray_endswith, METH_VARARGS, endswith__doc__},