python
diff --git a/‎Doc/library/uuid.rst
Copy file name to clipboardExpand all lines: Doc/library/uuid.rst
+4Lines changed: 4 additions & 0 deletions b/‎Doc/library/uuid.rst
Copy file name to clipboardExpand all lines: Doc/library/uuid.rst
+4Lines changed: 4 additions & 0 deletions
diff --git a/‎Lib/test/test_uuid.py
Copy file name to clipboardExpand all lines: Lib/test/test_uuid.py
+14-6Lines changed: 14 additions & 6 deletions b/‎Lib/test/test_uuid.py
Copy file name to clipboardExpand all lines: Lib/test/test_uuid.py
+14-6Lines changed: 14 additions & 6 deletions
diff --git a/‎Lib/uuid.py
Copy file name to clipboardExpand all lines: Lib/uuid.py
+5-1Lines changed: 5 additions & 1 deletion b/‎Lib/uuid.py
Copy file name to clipboardExpand all lines: Lib/uuid.py
+5-1Lines changed: 5 additions & 1 deletion
@@ -75,6 +75,10 @@ which relays any information about the UUID's safety, using this enumeration:
    ``12345678-1234-5678-1234-567812345678`` where the 32 hexadecimal digits
    represent the UUID.
 
+   .. versionchanged:: 3.7
+      *bytes* and *bytes_le* parameters now accept any bytes-like objects,
+      bytearray and memoryview for example, not only :class:`bytes`.
+
 :class:`UUID` instances have these read-only attributes:
 
 .. attribute:: UUID.bytes
 
@@ -213,14 +213,18 @@ def test_exceptions(self):
         badvalue(lambda: uuid.UUID('123456781234567812345678z2345678'))
 
         # Badly formed bytes.
-        badvalue(lambda: uuid.UUID(bytes='abc'))
-        badvalue(lambda: uuid.UUID(bytes='\0'*15))
-        badvalue(lambda: uuid.UUID(bytes='\0'*17))
+        badtype(lambda: uuid.UUID(bytes='unicode'))
+        badtype(lambda: uuid.UUID(bytes='u'*16))
+        badvalue(lambda: uuid.UUID(bytes=b'abc'))
+        badvalue(lambda: uuid.UUID(bytes=b'\0'*15))
+        badvalue(lambda: uuid.UUID(bytes=b'\0'*17))
 
         # Badly formed bytes_le.
-        badvalue(lambda: uuid.UUID(bytes_le='abc'))
-        badvalue(lambda: uuid.UUID(bytes_le='\0'*15))
-        badvalue(lambda: uuid.UUID(bytes_le='\0'*17))
+        badtype(lambda: uuid.UUID(bytes_le='unicode'))
+        badtype(lambda: uuid.UUID(bytes_le='u'*16))
+        badvalue(lambda: uuid.UUID(bytes_le=b'abc'))
+        badvalue(lambda: uuid.UUID(bytes_le=b'\0'*15))
+        badvalue(lambda: uuid.UUID(bytes_le=b'\0'*17))
 
         # Badly formed fields.
         badvalue(lambda: uuid.UUID(fields=(1,)))
@@ -458,9 +462,13 @@ def testIssue8621(self):
 
     def test_bytes_like(self):
         u = uuid.uuid4()
+
         self.assertEqual(uuid.UUID(bytes=memoryview(u.bytes)), u)
         self.assertEqual(uuid.UUID(bytes=bytearray(u.bytes)), u)
 
+        self.assertEqual(uuid.UUID(bytes_le=memoryview(u.bytes_le)), u)
+        self.assertEqual(uuid.UUID(bytes_le=bytearray(u.bytes_le)), u)
+
 
 class TestInternals(unittest.TestCase):
     @unittest.skipUnless(os.name == 'posix', 'requires Posix')
 
@@ -159,14 +159,18 @@ def __init__(self, hex=None, bytes=None, bytes_le=None, fields=None,
                 raise ValueError('badly formed hexadecimal UUID string')
             int = int_(hex, 16)
         if bytes_le is not None:
+            if not isinstance(bytes_le, (bytes_, bytearray)):
+                bytes_le = bytes_(bytes_le)
             if len(bytes_le) != 16:
                 raise ValueError('bytes_le is not a 16-char string')
             bytes = (bytes_le[4-1::-1] + bytes_le[6-1:4-1:-1] +
                      bytes_le[8-1:6-1:-1] + bytes_le[8:])
         if bytes is not None:
+            int = int_.from_bytes(bytes, byteorder='big')
+            # test length after the conversion to raise a TypeError exception
+            # if 'bytes' type is str even if 'bytes' length is not 16
             if len(bytes) != 16:
                 raise ValueError('bytes is not a 16-char string')
-            int = int_.from_bytes(bytes, byteorder='big')
         if fields is not None:
             if len(fields) != 6:
                 raise ValueError('fields is not a 6-tuple')