diff --git a/Lib/pickletools.py b/Lib/pickletools.py
--- a/Lib/pickletools.py
+++ b/Lib/pickletools.py
@@ -2083,24 +2083,26 @@ _dis_test = r"""
    34: c    GLOBAL     '__builtin__ bytes'
    53: p    PUT        3
    56: (    MARK
-   57: (        MARK
-   58: l            LIST       (MARK at 57)
-   59: p        PUT        4
-   62: L        LONG       97
-   67: a        APPEND
-   68: L        LONG       98
-   73: a        APPEND
-   74: L        LONG       99
-   79: a        APPEND
-   80: t        TUPLE      (MARK at 56)
-   81: p    PUT        5
-   84: R    REDUCE
-   85: p    PUT        6
-   88: V    UNICODE    'def'
-   93: p    PUT        7
-   96: s    SETITEM
-   97: a    APPEND
-   98: .    STOP
+   57: c        GLOBAL     '__builtin__ bytearray'
+   80: p        PUT        4
+   83: (        MARK
+   84: V            UNICODE    'abc'
+   89: p            PUT        5
+   92: V            UNICODE    'latin-1'
+  101: p            PUT        6
+  104: t            TUPLE      (MARK at 83)
+  105: p        PUT        7
+  108: R        REDUCE
+  109: p        PUT        8
+  112: t        TUPLE      (MARK at 56)
+  113: p    PUT        9
+  116: R    REDUCE
+  117: p    PUT        10
+  121: V    UNICODE    'def'
+  126: p    PUT        11
+  130: s    SETITEM
+  131: a    APPEND
+  132: .    STOP
 highest protocol among opcodes = 0
 
 Try again with a "binary" pickle.
@@ -2122,22 +2124,26 @@ Try again with a "binary" pickle.
    19: c        GLOBAL     '__builtin__ bytes'
    38: q        BINPUT     3
    40: (        MARK
-   41: ]            EMPTY_LIST
-   42: q            BINPUT     4
-   44: (            MARK
-   45: K                BININT1    97
-   47: K                BININT1    98
-   49: K                BININT1    99
-   51: e                APPENDS    (MARK at 44)
-   52: t            TUPLE      (MARK at 40)
-   53: q        BINPUT     5
-   55: R        REDUCE
-   56: q        BINPUT     6
-   58: X        BINUNICODE 'def'
-   66: q        BINPUT     7
-   68: s        SETITEM
-   69: e        APPENDS    (MARK at 3)
-   70: .    STOP
+   41: c            GLOBAL     '__builtin__ bytearray'
+   64: q            BINPUT     4
+   66: (            MARK
+   67: X                BINUNICODE 'abc'
+   75: q                BINPUT     5
+   77: X                BINUNICODE 'latin-1'
+   89: q                BINPUT     6
+   91: t                TUPLE      (MARK at 66)
+   92: q            BINPUT     7
+   94: R            REDUCE
+   95: q            BINPUT     8
+   97: t            TUPLE      (MARK at 40)
+   98: q        BINPUT     9
+  100: R        REDUCE
+  101: q        BINPUT     10
+  103: X        BINUNICODE 'def'
+  111: q        BINPUT     11
+  113: s        SETITEM
+  114: e        APPENDS    (MARK at 3)
+  115: .    STOP
 highest protocol among opcodes = 1
 
 Exercise the INST/OBJ/BUILD family.
diff --git a/Modules/_pickle.c b/Modules/_pickle.c
--- a/Modules/_pickle.c
+++ b/Modules/_pickle.c
@@ -1710,24 +1710,24 @@ save_bytes(PicklerObject *self, PyObject
            objects. Therefore, we need to fake the copy protocol (i.e.,
            the __reduce__ method) to permit bytes object unpickling. */
         PyObject *reduce_value = NULL;
-        PyObject *bytelist = NULL;
+        PyObject *bytearray = NULL;
         int status;
 
-        bytelist = PySequence_List(obj);
-        if (bytelist == NULL)
+        bytearray = PyByteArray_FromObject(obj);
+        if (bytearray == NULL)
             return -1;
 
         reduce_value = Py_BuildValue("(O(O))", (PyObject *)&PyBytes_Type,
-                                     bytelist);
+                                     bytearray);
         if (reduce_value == NULL) {
-            Py_DECREF(bytelist);
+            Py_DECREF(bytearray);
             return -1;
         }
 
         /* save_reduce() will memoize the object automatically. */
         status = save_reduce(self, reduce_value, obj);
         Py_DECREF(reduce_value);
-        Py_DECREF(bytelist);
+        Py_DECREF(bytearray);
         return status;
     }
     else {