diff --git a/Doc/library/tarfile.rst b/Doc/library/tarfile.rst
--- a/Doc/library/tarfile.rst
+++ b/Doc/library/tarfile.rst
@@ -72,16 +72,19 @@ Some facts and figures:
    +------------------+---------------------------------------------+
    | ``'w:xz'``       | Open for lzma compressed writing.           |
    +------------------+---------------------------------------------+
 
    Note that ``'a:gz'``, ``'a:bz2'`` or ``'a:xz'`` is not possible. If *mode*
    is not suitable to open a certain (compressed) file for reading,
    :exc:`ReadError` is raised. Use *mode* ``'r'`` to avoid this.  If a
    compression method is not supported, :exc:`CompressionError` is raised.
+   As a :term:`LBYL` alternative to catching this exception, a program can
+   inspect :data:`.compression_formats` to find what formats are
+   supported.
 
    If *fileobj* is specified, it is used as an alternative to a :term:`file object`
    opened in binary mode for *name*. It is supposed to be at position 0.
 
    For modes ``'w:gz'``, ``'r:gz'``, ``'w:bz2'``, ``'r:bz2'``, :func:`tarfile.open`
    accepts the keyword argument *compresslevel* to specify the compression level of
    the file.
 
@@ -206,16 +209,24 @@ The following variables are available on
 
 
 .. data:: ENCODING
 
    The default character encoding: ``'utf-8'`` on Windows,
    :func:`sys.getfilesystemencoding` otherwise.
 
 
+.. data:: compression_formats
+
+   A list containing all supported compression formats, sorted by strength; it
+   may contain ``'xz'``, ``'bz2'`` and ``'gz'``, in this order.
+
+   .. versionadded:: 3.5
+
+
 .. seealso::
 
    Module :mod:`zipfile`
       Documentation of the :mod:`zipfile` standard module.
 
    `GNU tar manual, Basic Tar Format <http://www.gnu.org/software/tar/manual/html_node/Standard.html>`_
       Documentation for tar archive files, including GNU tar extensions.
 
diff --git a/Lib/tarfile.py b/Lib/tarfile.py
--- a/Lib/tarfile.py
+++ b/Lib/tarfile.py
@@ -48,27 +48,43 @@ import struct
 import copy
 import re
 
 try:
     import grp, pwd
 except ImportError:
     grp = pwd = None
 
+try:
+    import zlib
+except ImportError:
+    zlib = None
+
+try:
+    import lzma
+except ImportError:
+    lzma = None
+
+try:
+    import bz2
+except ImportError:
+    bz2 = None
+
 # os.symlink on Windows prior to 6.0 raises NotImplementedError
 symlink_exception = (AttributeError, NotImplementedError)
 try:
     # OSError (winerror=1314) will be raised if the caller does not hold the
     # SeCreateSymbolicLinkPrivilege privilege
     symlink_exception += (OSError,)
 except NameError:
     pass
 
 # from tarfile import *
-__all__ = ["TarFile", "TarInfo", "is_tarfile", "TarError"]
+__all__ = ["TarFile", "TarInfo", "is_tarfile", "TarError",
+           "compression_formats"]
 
 #---------------------------------------------------------
 # tar constants
 #---------------------------------------------------------
 NUL = b"\0"                     # the null character
 BLOCKSIZE = 512                 # length of processing blocks
 RECORDSIZE = BLOCKSIZE * 20     # length of records
 GNU_MAGIC = b"ustar  \0"        # magic gnu tar string
@@ -354,44 +370,37 @@ class _Stream:
         self.fileobj  = fileobj
         self.bufsize  = bufsize
         self.buf      = b""
         self.pos      = 0
         self.closed   = False
 
         try:
             if comptype == "gz":
-                try:
-                    import zlib
-                except ImportError:
+                if zlib is None:
                     raise CompressionError("zlib module is not available")
-                self.zlib = zlib
                 self.crc = zlib.crc32(b"")
                 if mode == "r":
                     self._init_read_gz()
                     self.exception = zlib.error
                 else:
                     self._init_write_gz()
 
             elif comptype == "bz2":
-                try:
-                    import bz2
-                except ImportError:
+                if bz2 is None:
                     raise CompressionError("bz2 module is not available")
                 if mode == "r":
                     self.dbuf = b""
                     self.cmp = bz2.BZ2Decompressor()
                     self.exception = OSError
                 else:
                     self.cmp = bz2.BZ2Compressor()
 
             elif comptype == "xz":
-                try:
-                    import lzma
-                except ImportError:
+                if lzma is None:
                     raise CompressionError("lzma module is not available")
                 if mode == "r":
                     self.dbuf = b""
                     self.cmp = lzma.LZMADecompressor()
                     self.exception = lzma.LZMAError
                 else:
                     self.cmp = lzma.LZMACompressor()
 
@@ -406,32 +415,32 @@ class _Stream:
 
     def __del__(self):
         if hasattr(self, "closed") and not self.closed:
             self.close()
 
     def _init_write_gz(self):
         """Initialize for writing with gzip compression.
         """
-        self.cmp = self.zlib.compressobj(9, self.zlib.DEFLATED,
-                                            -self.zlib.MAX_WBITS,
-                                            self.zlib.DEF_MEM_LEVEL,
-                                            0)
+        self.cmp = zlib.compressobj(9, zlib.DEFLATED,
+                                       -zlib.MAX_WBITS,
+                                       zlib.DEF_MEM_LEVEL,
+                                       0)
         timestamp = struct.pack("<L", int(time.time()))
         self.__write(b"\037\213\010\010" + timestamp + b"\002\377")
         if self.name.endswith(".gz"):
             self.name = self.name[:-3]
         # RFC1952 says we must use ISO-8859-1 for the FNAME field.
         self.__write(self.name.encode("iso-8859-1", "replace") + NUL)
 
     def write(self, s):
         """Write string s to the stream.
         """
         if self.comptype == "gz":
-            self.crc = self.zlib.crc32(s, self.crc)
+            self.crc = zlib.crc32(s, self.crc)
         self.pos += len(s)
         if self.comptype != "tar":
             s = self.cmp.compress(s)
         self.__write(s)
 
     def __write(self, s):
         """Write string s to the stream if a whole new block
            is ready to be written.
@@ -467,17 +476,17 @@ class _Stream:
         if not self._extfileobj:
             self.fileobj.close()
 
         self.closed = True
 
     def _init_read_gz(self):
         """Initialize for reading a gzip compressed fileobj.
         """
-        self.cmp = self.zlib.decompressobj(-self.zlib.MAX_WBITS)
+        self.cmp = zlib.decompressobj(-zlib.MAX_WBITS)
         self.dbuf = b""
 
         # taken from gzip.GzipFile with some alterations
         if self.__read(2) != b"\037\213":
             raise ReadError("not a gzip file")
         if self.__read(1) != b"\010":
             raise CompressionError("unsupported compression method")
 
@@ -1631,19 +1640,17 @@ class TarFile(object):
     @classmethod
     def bz2open(cls, name, mode="r", fileobj=None, compresslevel=9, **kwargs):
         """Open bzip2 compressed tar archive name for reading or writing.
            Appending is not allowed.
         """
         if mode not in ("r", "w"):
             raise ValueError("mode must be 'r' or 'w'.")
 
-        try:
-            import bz2
-        except ImportError:
+        if bz2 is None:
             raise CompressionError("bz2 module is not available")
 
         fileobj = bz2.BZ2File(fileobj or name, mode,
                               compresslevel=compresslevel)
 
         try:
             t = cls.taropen(name, mode, fileobj, **kwargs)
         except (OSError, EOFError):
@@ -1660,19 +1667,17 @@ class TarFile(object):
     @classmethod
     def xzopen(cls, name, mode="r", fileobj=None, preset=None, **kwargs):
         """Open lzma compressed tar archive name for reading or writing.
            Appending is not allowed.
         """
         if mode not in ("r", "w"):
             raise ValueError("mode must be 'r' or 'w'")
 
-        try:
-            import lzma
-        except ImportError:
+        if lzma is None:
             raise CompressionError("lzma module is not available")
 
         fileobj = lzma.LZMAFile(fileobj or name, mode, preset=preset)
 
         try:
             t = cls.taropen(name, mode, fileobj, **kwargs)
         except (lzma.LZMAError, EOFError):
             fileobj.close()
@@ -2401,33 +2406,38 @@ class TarIter:
             if not tarinfo:
                 self.tarfile._loaded = True
                 raise StopIteration
         else:
             raise StopIteration
         self.index += 1
         return tarinfo
 
-#--------------------
-# exported functions
-#--------------------
+#---------------------------------
+# exported functions and constants
+#---------------------------------
 def is_tarfile(name):
     """Return True if name points to a tar archive that we
        are able to handle, else return False.
     """
     try:
         t = open(name)
         t.close()
         return True
     except TarError:
         return False
 
 bltn_open = open
 open = TarFile.open
 
+# supported compression formats, sorted by strength
+compression_formats = [name for name, module in
+                       [("xz", lzma), ("bz2", bz2), ("gz", zlib)]
+                       if module is not None]
+
 
 def main():
     import argparse
 
     description = 'A simple command line interface for tarfile module.'
     parser = argparse.ArgumentParser(description=description)
     parser.add_argument('-v', '--verbose', action='store_true', default=False,
                         help='Verbose output')
diff --git a/Lib/test/test_tarfile.py b/Lib/test/test_tarfile.py
--- a/Lib/test/test_tarfile.py
+++ b/Lib/test/test_tarfile.py
@@ -2002,16 +2002,27 @@ class CommandLineTest(unittest.TestCase)
     def test_extract_command_invalid_file(self):
         zipname = support.findfile('zipdir.zip')
         with support.temp_cwd(tarextdir):
             rc, out, err = self.tarfilecmd_failure('-e', zipname)
         self.assertIn(b' is not a tar archive.', err)
         self.assertEqual(out, b'')
         self.assertEqual(rc, 1)
 
+    def test_compression_formats(self):
+        expected = []
+        # make sure the available formats are sorted by strength
+        if lzma is not None:
+            expected.append("xz")
+        if bz2 is not None:
+            expected.append("bz2")
+        if gzip is not None:
+            expected.append("gz")
+        self.assertEqual(tarfile.compression_formats, expected)
+
 
 class ContextManagerTest(unittest.TestCase):
 
     def test_basic(self):
         with tarfile.open(tarname) as tar:
             self.assertFalse(tar.closed, "closed inside runtime context")
         self.assertTrue(tar.closed, "context manager failed")