diff --git a/contrib/pyzfs/libzfs_core/__init__.py b/contrib/pyzfs/libzfs_core/__init__.py
index 6ad9fa1295c6..a195b05f524f 100644
--- a/contrib/pyzfs/libzfs_core/__init__.py
+++ b/contrib/pyzfs/libzfs_core/__init__.py
@@ -38,6 +38,7 @@
 
     Maximum length of any ZFS name.
 '''
+from __future__ import absolute_import, division, print_function
 
 from ._constants import (
     MAXNAMELEN,
diff --git a/contrib/pyzfs/libzfs_core/_constants.py b/contrib/pyzfs/libzfs_core/_constants.py
index 4e1af55d7b1e..917feee015ae 100644
--- a/contrib/pyzfs/libzfs_core/_constants.py
+++ b/contrib/pyzfs/libzfs_core/_constants.py
@@ -18,10 +18,12 @@
 Important `libzfs_core` constants.
 """
 
+from __future__ import absolute_import, division, print_function
+
 
 # https://stackoverflow.com/a/1695250
 def enum(*sequential, **named):
-    enums = dict(zip(sequential, range(len(sequential))), **named)
+    enums = dict(((b, a) for a, b in enumerate(sequential)), **named)
     return type('Enum', (), enums)
 
 
diff --git a/contrib/pyzfs/libzfs_core/_error_translation.py b/contrib/pyzfs/libzfs_core/_error_translation.py
index b9db026d7dcf..98d3bb22ae5a 100644
--- a/contrib/pyzfs/libzfs_core/_error_translation.py
+++ b/contrib/pyzfs/libzfs_core/_error_translation.py
@@ -26,6 +26,7 @@
 
 The parameters and exceptions are documented in the `libzfs_core` interfaces.
 """
+from __future__ import absolute_import, division, print_function
 
 import errno
 import re
@@ -102,8 +103,9 @@ def lzc_snapshot_translate_errors(ret, errlist, snaps, props):
 
     def _map(ret, name):
         if ret == errno.EXDEV:
-            pool_names = map(_pool_name, snaps)
-            same_pool = all(x == pool_names[0] for x in pool_names)
+            pool_names = iter(map(_pool_name, snaps))
+            pool_name = next(pool_names, None)
+            same_pool = all(x == pool_name for x in pool_names)
             if same_pool:
                 return lzc_exc.DuplicateSnapshots(name)
             else:
@@ -270,7 +272,8 @@ def _map(ret, name):
 def lzc_release_translate_errors(ret, errlist, holds):
     if ret == 0:
         return
-    for _, hold_list in holds.iteritems():
+    for snap in holds:
+        hold_list = holds[snap]
         if not isinstance(hold_list, list):
             raise lzc_exc.TypeError('holds must be in a list')
 
@@ -705,15 +708,17 @@ def _handle_err_list(ret, errlist, names, exception, mapper):
 
     if len(errlist) == 0:
         suppressed_count = 0
+        names = list(zip(names, range(2)))
         if len(names) == 1:
-            name = names[0]
+            name, _ = names[0]
         else:
             name = None
         errors = [mapper(ret, name)]
     else:
         errors = []
         suppressed_count = errlist.pop('N_MORE_ERRORS', 0)
-        for name, err in errlist.iteritems():
+        for name in errlist:
+            err = errlist[name]
             errors.append(mapper(err, name))
 
     raise exception(errors, suppressed_count)
diff --git a/contrib/pyzfs/libzfs_core/_libzfs_core.py b/contrib/pyzfs/libzfs_core/_libzfs_core.py
index 157dc16e9a75..aa387dbb3cab 100644
--- a/contrib/pyzfs/libzfs_core/_libzfs_core.py
+++ b/contrib/pyzfs/libzfs_core/_libzfs_core.py
@@ -26,6 +26,7 @@
 are directly returned.  Error conditions are signalled by exceptions
 rather than by integer error codes.
 """
+from __future__ import absolute_import, division, print_function
 
 import errno
 import functools
@@ -485,8 +486,8 @@ def lzc_hold(holds, fd=None):
     errors.lzc_hold_translate_errors(ret, errlist, holds, fd)
     # If there is no error (no exception raised by _handleErrList), but errlist
     # is not empty, then it contains missing snapshots.
-    assert all(x == errno.ENOENT for x in errlist.itervalues())
-    return errlist.keys()
+    assert all(errlist[x] == errno.ENOENT for x in errlist)
+    return list(errlist.keys())
 
 
 def lzc_release(holds):
@@ -521,7 +522,8 @@ def lzc_release(holds):
     '''
     errlist = {}
     holds_dict = {}
-    for snap, hold_list in holds.iteritems():
+    for snap in holds:
+        hold_list = holds[snap]
         if not isinstance(hold_list, list):
             raise TypeError('holds must be in a list')
         holds_dict[snap] = {hold: None for hold in hold_list}
@@ -531,8 +533,8 @@ def lzc_release(holds):
     errors.lzc_release_translate_errors(ret, errlist, holds)
     # If there is no error (no exception raised by _handleErrList), but errlist
     # is not empty, then it contains missing snapshots and tags.
-    assert all(x == errno.ENOENT for x in errlist.itervalues())
-    return errlist.keys()
+    assert all(errlist[x] == errno.ENOENT for x in errlist)
+    return list(errlist.keys())
 
 
 def lzc_get_holds(snapname):
@@ -1873,9 +1875,9 @@ def lzc_get_props(name):
         mountpoint_val = '/' + name
     else:
         mountpoint_val = None
-    result = {k: v['value'] for k, v in result.iteritems()}
+    result = {k: result[k]['value'] for k in result}
     if 'clones' in result:
-        result['clones'] = result['clones'].keys()
+        result['clones'] = list(result['clones'].keys())
     if mountpoint_val is not None:
         result['mountpoint'] = mountpoint_val
     return result
diff --git a/contrib/pyzfs/libzfs_core/_nvlist.py b/contrib/pyzfs/libzfs_core/_nvlist.py
index 75c2e20f374f..d7451bfe3967 100644
--- a/contrib/pyzfs/libzfs_core/_nvlist.py
+++ b/contrib/pyzfs/libzfs_core/_nvlist.py
@@ -47,6 +47,7 @@
 - a value can be a list of dictionaries that adhere to this format
 - all elements of a list value must be of the same type
 """
+from __future__ import absolute_import, division, print_function
 
 import numbers
 from collections import namedtuple
diff --git a/contrib/pyzfs/libzfs_core/bindings/__init__.py b/contrib/pyzfs/libzfs_core/bindings/__init__.py
index f1b75620838a..4bdd9ea3115e 100644
--- a/contrib/pyzfs/libzfs_core/bindings/__init__.py
+++ b/contrib/pyzfs/libzfs_core/bindings/__init__.py
@@ -19,6 +19,7 @@
 `libzfs_core` uses.  The modules expose CFFI objects required
 to make calls to functions in the libraries.
 """
+from __future__ import absolute_import, division, print_function
 
 import threading
 import importlib
@@ -47,7 +48,7 @@ def __getattr__(self, name):
     ffi = FFI()
 
     for module_name in MODULES:
-        module = importlib.import_module("." + module_name, __package__)
+        module = importlib.import_module("." + module_name, __name__)
         ffi.cdef(module.CDEF)
         lib = LazyLibrary(ffi, module.LIBRARY)
         setattr(module, "ffi", ffi)
diff --git a/contrib/pyzfs/libzfs_core/bindings/libnvpair.py b/contrib/pyzfs/libzfs_core/bindings/libnvpair.py
index 03cc75f7fcf2..3cd72d4908de 100644
--- a/contrib/pyzfs/libzfs_core/bindings/libnvpair.py
+++ b/contrib/pyzfs/libzfs_core/bindings/libnvpair.py
@@ -17,6 +17,7 @@
 """
 Python bindings for ``libnvpair``.
 """
+from __future__ import absolute_import, division, print_function
 
 CDEF = """
     typedef ... nvlist_t;
diff --git a/contrib/pyzfs/libzfs_core/bindings/libzfs_core.py b/contrib/pyzfs/libzfs_core/bindings/libzfs_core.py
index 658394a3fe55..ce2d9d62c34f 100644
--- a/contrib/pyzfs/libzfs_core/bindings/libzfs_core.py
+++ b/contrib/pyzfs/libzfs_core/bindings/libzfs_core.py
@@ -17,6 +17,7 @@
 """
 Python bindings for ``libzfs_core``.
 """
+from __future__ import absolute_import, division, print_function
 
 CDEF = """
 
diff --git a/contrib/pyzfs/libzfs_core/ctypes.py b/contrib/pyzfs/libzfs_core/ctypes.py
index 8e6dfa622f47..eab1602196d6 100644
--- a/contrib/pyzfs/libzfs_core/ctypes.py
+++ b/contrib/pyzfs/libzfs_core/ctypes.py
@@ -17,6 +17,7 @@
 """
 Utility functions for casting to a specific C type.
 """
+from __future__ import absolute_import, division, print_function
 
 from .bindings.libnvpair import ffi as _ffi
 
diff --git a/contrib/pyzfs/libzfs_core/exceptions.py b/contrib/pyzfs/libzfs_core/exceptions.py
index d274b5b06b92..c54459ec8b47 100644
--- a/contrib/pyzfs/libzfs_core/exceptions.py
+++ b/contrib/pyzfs/libzfs_core/exceptions.py
@@ -17,6 +17,7 @@
 """
 Exceptions that can be raised by libzfs_core operations.
 """
+from __future__ import absolute_import, division, print_function
 
 import errno
 from ._constants import (
diff --git a/contrib/pyzfs/libzfs_core/test/test_libzfs_core.py b/contrib/pyzfs/libzfs_core/test/test_libzfs_core.py
index 14303871a17e..65e17734589d 100644
--- a/contrib/pyzfs/libzfs_core/test/test_libzfs_core.py
+++ b/contrib/pyzfs/libzfs_core/test/test_libzfs_core.py
@@ -21,6 +21,7 @@
 that the operations produce expected effects or fail with expected
 exceptions.
 """
+from __future__ import absolute_import, division, print_function
 
 import unittest
 import contextlib
@@ -44,8 +45,8 @@
 
 def _print(*args):
     for arg in args:
-        print arg,
-    print
+        print(arg, end=' ')
+    print()
 
 
 @contextlib.contextmanager
@@ -76,7 +77,7 @@ def _zfs_mount(fs):
             with suppress():
                 subprocess.check_output(unmount_cmd, stderr=subprocess.STDOUT)
     except subprocess.CalledProcessError as e:
-        print 'failed to mount %s @ %s : %s' % (fs, mntdir, e.output)
+        print('failed to mount %s @ %s : %s' % (fs, mntdir, e.output))
         raise
     finally:
         os.rmdir(mntdir)
@@ -444,10 +445,10 @@ def test_create_encrypted_fs(self):
             }
             key = os.urandom(lzc.WRAPPING_KEY_LEN)
             lzc.lzc_create(name, 'zfs', props=props, key=key)
-        self.assertEquals(fs.getProperty("encryption"), "aes-256-ccm")
-        self.assertEquals(fs.getProperty("encryptionroot"), name)
-        self.assertEquals(fs.getProperty("keylocation"), filename)
-        self.assertEquals(fs.getProperty("keyformat"), "raw")
+        self.assertEqual(fs.getProperty("encryption"), "aes-256-ccm")
+        self.assertEqual(fs.getProperty("encryptionroot"), name)
+        self.assertEqual(fs.getProperty("keylocation"), filename)
+        self.assertEqual(fs.getProperty("keyformat"), "raw")
 
     def test_snapshot(self):
         snapname = ZFSTest.pool.makeName("@snap")
@@ -475,7 +476,7 @@ def test_snapshot_invalid_props(self):
         with self.assertRaises(lzc_exc.SnapshotFailure) as ctx:
             lzc.lzc_snapshot(snaps, props)
 
-        self.assertEquals(len(ctx.exception.errors), len(snaps))
+        self.assertEqual(len(ctx.exception.errors), len(snaps))
         for e in ctx.exception.errors:
             self.assertIsInstance(e, lzc_exc.PropertyInvalid)
         self.assertNotExists(snapname)
@@ -489,7 +490,7 @@ def test_snapshot_ro_pool(self):
             lzc.lzc_snapshot(snaps)
 
         # NB: one common error is reported.
-        self.assertEquals(len(ctx.exception.errors), 1)
+        self.assertEqual(len(ctx.exception.errors), 1)
         for e in ctx.exception.errors:
             self.assertIsInstance(e, lzc_exc.ReadOnlyPool)
         self.assertNotExists(snapname1)
@@ -502,7 +503,7 @@ def test_snapshot_nonexistent_pool(self):
         with self.assertRaises(lzc_exc.SnapshotFailure) as ctx:
             lzc.lzc_snapshot(snaps)
 
-        self.assertEquals(len(ctx.exception.errors), 1)
+        self.assertEqual(len(ctx.exception.errors), 1)
         for e in ctx.exception.errors:
             self.assertIsInstance(e, lzc_exc.FilesystemNotFound)
 
@@ -513,7 +514,7 @@ def test_snapshot_nonexistent_fs(self):
         with self.assertRaises(lzc_exc.SnapshotFailure) as ctx:
             lzc.lzc_snapshot(snaps)
 
-        self.assertEquals(len(ctx.exception.errors), 1)
+        self.assertEqual(len(ctx.exception.errors), 1)
         for e in ctx.exception.errors:
             self.assertIsInstance(e, lzc_exc.FilesystemNotFound)
 
@@ -525,7 +526,7 @@ def test_snapshot_nonexistent_and_existent_fs(self):
         with self.assertRaises(lzc_exc.SnapshotFailure) as ctx:
             lzc.lzc_snapshot(snaps)
 
-        self.assertEquals(len(ctx.exception.errors), 1)
+        self.assertEqual(len(ctx.exception.errors), 1)
         for e in ctx.exception.errors:
             self.assertIsInstance(e, lzc_exc.FilesystemNotFound)
         self.assertNotExists(snapname1)
@@ -540,7 +541,7 @@ def test_multiple_snapshots_nonexistent_fs(self):
             lzc.lzc_snapshot(snaps)
 
         # XXX two errors should be reported but alas
-        self.assertEquals(len(ctx.exception.errors), 1)
+        self.assertEqual(len(ctx.exception.errors), 1)
         for e in ctx.exception.errors:
             self.assertIsInstance(e, lzc_exc.DuplicateSnapshots)
         self.assertNotExists(snapname1)
@@ -554,7 +555,7 @@ def test_multiple_snapshots_multiple_nonexistent_fs(self):
         with self.assertRaises(lzc_exc.SnapshotFailure) as ctx:
             lzc.lzc_snapshot(snaps)
 
-        self.assertEquals(len(ctx.exception.errors), 2)
+        self.assertEqual(len(ctx.exception.errors), 2)
         for e in ctx.exception.errors:
             self.assertIsInstance(e, lzc_exc.FilesystemNotFound)
         self.assertNotExists(snapname1)
@@ -569,7 +570,7 @@ def test_snapshot_already_exists(self):
         with self.assertRaises(lzc_exc.SnapshotFailure) as ctx:
             lzc.lzc_snapshot(snaps)
 
-        self.assertEquals(len(ctx.exception.errors), 1)
+        self.assertEqual(len(ctx.exception.errors), 1)
         for e in ctx.exception.errors:
             self.assertIsInstance(e, lzc_exc.SnapshotExists)
 
@@ -581,7 +582,7 @@ def test_multiple_snapshots_for_same_fs(self):
         with self.assertRaises(lzc_exc.SnapshotFailure) as ctx:
             lzc.lzc_snapshot(snaps)
 
-        self.assertEquals(len(ctx.exception.errors), 1)
+        self.assertEqual(len(ctx.exception.errors), 1)
         for e in ctx.exception.errors:
             self.assertIsInstance(e, lzc_exc.DuplicateSnapshots)
         self.assertNotExists(snapname1)
@@ -662,7 +663,7 @@ def test_snapshot_different_pools(self):
             lzc.lzc_snapshot(snaps)
 
         # NB: one common error is reported.
-        self.assertEquals(len(ctx.exception.errors), 1)
+        self.assertEqual(len(ctx.exception.errors), 1)
         for e in ctx.exception.errors:
             self.assertIsInstance(e, lzc_exc.PoolsDiffer)
         self.assertNotExists(snapname1)
@@ -677,7 +678,7 @@ def test_snapshot_different_pools_ro_pool(self):
             lzc.lzc_snapshot(snaps)
 
         # NB: one common error is reported.
-        self.assertEquals(len(ctx.exception.errors), 1)
+        self.assertEqual(len(ctx.exception.errors), 1)
         for e in ctx.exception.errors:
             # NB: depending on whether the first attempted snapshot is
             # for the read-only pool a different error is reported.
@@ -696,7 +697,7 @@ def test_snapshot_invalid_name(self):
             lzc.lzc_snapshot(snaps)
 
         # NB: one common error is reported.
-        self.assertEquals(len(ctx.exception.errors), 1)
+        self.assertEqual(len(ctx.exception.errors), 1)
         for e in ctx.exception.errors:
             self.assertIsInstance(e, lzc_exc.NameInvalid)
             self.assertIsNone(e.name)
@@ -710,7 +711,7 @@ def test_snapshot_too_long_complete_name(self):
         with self.assertRaises(lzc_exc.SnapshotFailure) as ctx:
             lzc.lzc_snapshot(snaps)
 
-        self.assertEquals(len(ctx.exception.errors), 2)
+        self.assertEqual(len(ctx.exception.errors), 2)
         for e in ctx.exception.errors:
             self.assertIsInstance(e, lzc_exc.NameTooLong)
             self.assertIsNotNone(e.name)
@@ -725,7 +726,7 @@ def test_snapshot_too_long_snap_name(self):
             lzc.lzc_snapshot(snaps)
 
         # NB: one common error is reported.
-        self.assertEquals(len(ctx.exception.errors), 1)
+        self.assertEqual(len(ctx.exception.errors), 1)
         for e in ctx.exception.errors:
             self.assertIsInstance(e, lzc_exc.NameTooLong)
             self.assertIsNone(e.name)
@@ -914,7 +915,7 @@ def test_destroy_cloned_fs(self):
         with self.assertRaises(lzc_exc.SnapshotDestructionFailure) as ctx:
             lzc.lzc_destroy_snaps(snaps, False)
 
-        self.assertEquals(len(ctx.exception.errors), 1)
+        self.assertEqual(len(ctx.exception.errors), 1)
         for e in ctx.exception.errors:
             self.assertIsInstance(e, lzc_exc.SnapshotIsCloned)
         for snap in snaps:
@@ -1229,19 +1230,19 @@ def test_get_bookmarks(self):
         lzc.lzc_destroy_snaps([snap1, snap2], defer=False)
 
         bmarks = lzc.lzc_get_bookmarks(ZFSTest.pool.makeName('fs1'))
-        self.assertEquals(len(bmarks), 3)
+        self.assertEqual(len(bmarks), 3)
         for b in 'bmark', 'bmark1', 'bmark2':
             self.assertIn(b, bmarks)
             self.assertIsInstance(bmarks[b], dict)
-            self.assertEquals(len(bmarks[b]), 0)
+            self.assertEqual(len(bmarks[b]), 0)
 
         bmarks = lzc.lzc_get_bookmarks(
             ZFSTest.pool.makeName('fs1'), ['guid', 'createtxg', 'creation'])
-        self.assertEquals(len(bmarks), 3)
+        self.assertEqual(len(bmarks), 3)
         for b in 'bmark', 'bmark1', 'bmark2':
             self.assertIn(b, bmarks)
             self.assertIsInstance(bmarks[b], dict)
-            self.assertEquals(len(bmarks[b]), 3)
+            self.assertEqual(len(bmarks[b]), 3)
 
     @skipUnlessBookmarksSupported
     def test_get_bookmarks_invalid_property(self):
@@ -1254,11 +1255,11 @@ def test_get_bookmarks_invalid_property(self):
 
         bmarks = lzc.lzc_get_bookmarks(
             ZFSTest.pool.makeName('fs1'), ['badprop'])
-        self.assertEquals(len(bmarks), 1)
+        self.assertEqual(len(bmarks), 1)
         for b in ('bmark', ):
             self.assertIn(b, bmarks)
             self.assertIsInstance(bmarks[b], dict)
-            self.assertEquals(len(bmarks[b]), 0)
+            self.assertEqual(len(bmarks[b]), 0)
 
     @skipUnlessBookmarksSupported
     def test_get_bookmarks_nonexistent_fs(self):
@@ -1277,7 +1278,7 @@ def test_destroy_bookmarks(self):
         lzc.lzc_destroy_bookmarks(
             [bmark, ZFSTest.pool.makeName('fs1#nonexistent')])
         bmarks = lzc.lzc_get_bookmarks(ZFSTest.pool.makeName('fs1'))
-        self.assertEquals(len(bmarks), 0)
+        self.assertEqual(len(bmarks), 0)
 
     @skipUnlessBookmarksSupported
     def test_destroy_bookmarks_invalid_name(self):
@@ -1295,7 +1296,7 @@ def test_destroy_bookmarks_invalid_name(self):
             self.assertIsInstance(e, lzc_exc.NameInvalid)
 
         bmarks = lzc.lzc_get_bookmarks(ZFSTest.pool.makeName('fs1'))
-        self.assertEquals(len(bmarks), 1)
+        self.assertEqual(len(bmarks), 1)
         self.assertIn('bmark', bmarks)
 
     @skipUnlessBookmarksSupported
@@ -1316,11 +1317,11 @@ def test_snaprange_space(self):
         lzc.lzc_snapshot([snap3])
 
         space = lzc.lzc_snaprange_space(snap1, snap2)
-        self.assertIsInstance(space, (int, long))
+        self.assertIsInstance(space, (int, int))
         space = lzc.lzc_snaprange_space(snap2, snap3)
-        self.assertIsInstance(space, (int, long))
+        self.assertIsInstance(space, (int, int))
         space = lzc.lzc_snaprange_space(snap1, snap3)
-        self.assertIsInstance(space, (int, long))
+        self.assertIsInstance(space, (int, int))
 
     def test_snaprange_space_2(self):
         snap1 = ZFSTest.pool.makeName("fs1@snap1")
@@ -1355,7 +1356,7 @@ def test_snaprange_space_same_snap(self):
 
         space = lzc.lzc_snaprange_space(snap, snap)
         self.assertGreater(space, 1024 * 1024)
-        self.assertAlmostEqual(space, 1024 * 1024, delta=1024 * 1024 / 20)
+        self.assertAlmostEqual(space, 1024 * 1024, delta=1024 * 1024 // 20)
 
     def test_snaprange_space_wrong_order(self):
         snap1 = ZFSTest.pool.makeName("fs1@snap1")
@@ -1395,11 +1396,11 @@ def test_snaprange_space_nonexistent(self):
 
         with self.assertRaises(lzc_exc.SnapshotNotFound) as ctx:
             lzc.lzc_snaprange_space(snap1, snap2)
-        self.assertEquals(ctx.exception.name, snap2)
+        self.assertEqual(ctx.exception.name, snap2)
 
         with self.assertRaises(lzc_exc.SnapshotNotFound) as ctx:
             lzc.lzc_snaprange_space(snap2, snap1)
-        self.assertEquals(ctx.exception.name, snap1)
+        self.assertEqual(ctx.exception.name, snap1)
 
     def test_snaprange_space_invalid_name(self):
         snap1 = ZFSTest.pool.makeName("fs1@snap1")
@@ -1442,17 +1443,17 @@ def test_send_space(self):
         lzc.lzc_snapshot([snap3])
 
         space = lzc.lzc_send_space(snap2, snap1)
-        self.assertIsInstance(space, (int, long))
+        self.assertIsInstance(space, (int, int))
         space = lzc.lzc_send_space(snap3, snap2)
-        self.assertIsInstance(space, (int, long))
+        self.assertIsInstance(space, (int, int))
         space = lzc.lzc_send_space(snap3, snap1)
-        self.assertIsInstance(space, (int, long))
+        self.assertIsInstance(space, (int, int))
         space = lzc.lzc_send_space(snap1)
-        self.assertIsInstance(space, (int, long))
+        self.assertIsInstance(space, (int, int))
         space = lzc.lzc_send_space(snap2)
-        self.assertIsInstance(space, (int, long))
+        self.assertIsInstance(space, (int, int))
         space = lzc.lzc_send_space(snap3)
-        self.assertIsInstance(space, (int, long))
+        self.assertIsInstance(space, (int, int))
 
     def test_send_space_2(self):
         snap1 = ZFSTest.pool.makeName("fs1@snap1")
@@ -1481,7 +1482,7 @@ def test_send_space_2(self):
         self.assertGreater(space, 1024 * 1024)
 
         space = lzc.lzc_send_space(snap3)
-        self.assertEquals(space, space_empty)
+        self.assertEqual(space, space_empty)
 
     def test_send_space_same_snap(self):
         snap1 = ZFSTest.pool.makeName("fs1@snap1")
@@ -1527,15 +1528,15 @@ def test_send_space_nonexistent(self):
 
         with self.assertRaises(lzc_exc.SnapshotNotFound) as ctx:
             lzc.lzc_send_space(snap1, snap2)
-        self.assertEquals(ctx.exception.name, snap1)
+        self.assertEqual(ctx.exception.name, snap1)
 
         with self.assertRaises(lzc_exc.SnapshotNotFound) as ctx:
             lzc.lzc_send_space(snap2, snap1)
-        self.assertEquals(ctx.exception.name, snap2)
+        self.assertEqual(ctx.exception.name, snap2)
 
         with self.assertRaises(lzc_exc.SnapshotNotFound) as ctx:
             lzc.lzc_send_space(snap2)
-        self.assertEquals(ctx.exception.name, snap2)
+        self.assertEqual(ctx.exception.name, snap2)
 
     def test_send_space_invalid_name(self):
         snap1 = ZFSTest.pool.makeName("fs1@snap1")
@@ -1545,13 +1546,13 @@ def test_send_space_invalid_name(self):
 
         with self.assertRaises(lzc_exc.NameInvalid) as ctx:
             lzc.lzc_send_space(snap2, snap1)
-        self.assertEquals(ctx.exception.name, snap2)
+        self.assertEqual(ctx.exception.name, snap2)
         with self.assertRaises(lzc_exc.NameInvalid) as ctx:
             lzc.lzc_send_space(snap2)
-        self.assertEquals(ctx.exception.name, snap2)
+        self.assertEqual(ctx.exception.name, snap2)
         with self.assertRaises(lzc_exc.NameInvalid) as ctx:
             lzc.lzc_send_space(snap1, snap2)
-        self.assertEquals(ctx.exception.name, snap2)
+        self.assertEqual(ctx.exception.name, snap2)
 
     def test_send_space_not_snap(self):
         snap1 = ZFSTest.pool.makeName("fs1@snap1")
@@ -1594,7 +1595,7 @@ def test_send_full(self):
             lzc.lzc_send(snap, None, fd)
             st = os.fstat(fd)
             # 5%, arbitrary.
-            self.assertAlmostEqual(st.st_size, estimate, delta=estimate / 20)
+            self.assertAlmostEqual(st.st_size, estimate, delta=estimate // 20)
 
     def test_send_incremental(self):
         snap1 = ZFSTest.pool.makeName("fs1@snap1")
@@ -1615,7 +1616,7 @@ def test_send_incremental(self):
             lzc.lzc_send(snap2, snap1, fd)
             st = os.fstat(fd)
             # 5%, arbitrary.
-            self.assertAlmostEqual(st.st_size, estimate, delta=estimate / 20)
+            self.assertAlmostEqual(st.st_size, estimate, delta=estimate // 20)
 
     def test_send_flags(self):
         flags = ['embedded_data', 'large_blocks', 'compress', 'raw']
@@ -1688,15 +1689,15 @@ def test_send_nonexistent(self):
             fd = output.fileno()
             with self.assertRaises(lzc_exc.SnapshotNotFound) as ctx:
                 lzc.lzc_send(snap1, snap2, fd)
-            self.assertEquals(ctx.exception.name, snap1)
+            self.assertEqual(ctx.exception.name, snap1)
 
             with self.assertRaises(lzc_exc.SnapshotNotFound) as ctx:
                 lzc.lzc_send(snap2, snap1, fd)
-            self.assertEquals(ctx.exception.name, snap2)
+            self.assertEqual(ctx.exception.name, snap2)
 
             with self.assertRaises(lzc_exc.SnapshotNotFound) as ctx:
                 lzc.lzc_send(snap2, None, fd)
-            self.assertEquals(ctx.exception.name, snap2)
+            self.assertEqual(ctx.exception.name, snap2)
 
     def test_send_invalid_name(self):
         snap1 = ZFSTest.pool.makeName("fs1@snap1")
@@ -1708,13 +1709,13 @@ def test_send_invalid_name(self):
             fd = output.fileno()
             with self.assertRaises(lzc_exc.NameInvalid) as ctx:
                 lzc.lzc_send(snap2, snap1, fd)
-            self.assertEquals(ctx.exception.name, snap2)
+            self.assertEqual(ctx.exception.name, snap2)
             with self.assertRaises(lzc_exc.NameInvalid) as ctx:
                 lzc.lzc_send(snap2, None, fd)
-            self.assertEquals(ctx.exception.name, snap2)
+            self.assertEqual(ctx.exception.name, snap2)
             with self.assertRaises(lzc_exc.NameInvalid) as ctx:
                 lzc.lzc_send(snap1, snap2, fd)
-            self.assertEquals(ctx.exception.name, snap2)
+            self.assertEqual(ctx.exception.name, snap2)
 
     # XXX Although undocumented the API allows to create an incremental
     # or full stream for a filesystem as if a temporary unnamed snapshot
@@ -1784,7 +1785,7 @@ def test_send_bad_fd(self):
 
         with self.assertRaises(lzc_exc.StreamIOError) as ctx:
             lzc.lzc_send(snap, None, bad_fd)
-        self.assertEquals(ctx.exception.errno, errno.EBADF)
+        self.assertEqual(ctx.exception.errno, errno.EBADF)
 
     def test_send_bad_fd_2(self):
         snap = ZFSTest.pool.makeName("fs1@snap")
@@ -1792,7 +1793,7 @@ def test_send_bad_fd_2(self):
 
         with self.assertRaises(lzc_exc.StreamIOError) as ctx:
             lzc.lzc_send(snap, None, -2)
-        self.assertEquals(ctx.exception.errno, errno.EBADF)
+        self.assertEqual(ctx.exception.errno, errno.EBADF)
 
     def test_send_bad_fd_3(self):
         snap = ZFSTest.pool.makeName("fs1@snap")
@@ -1805,7 +1806,7 @@ def test_send_bad_fd_3(self):
         bad_fd = hard + 1
         with self.assertRaises(lzc_exc.StreamIOError) as ctx:
             lzc.lzc_send(snap, None, bad_fd)
-        self.assertEquals(ctx.exception.errno, errno.EBADF)
+        self.assertEqual(ctx.exception.errno, errno.EBADF)
 
     def test_send_to_broken_pipe(self):
         snap = ZFSTest.pool.makeName("fs1@snap")
@@ -1815,7 +1816,7 @@ def test_send_to_broken_pipe(self):
         proc.wait()
         with self.assertRaises(lzc_exc.StreamIOError) as ctx:
             lzc.lzc_send(snap, None, proc.stdin.fileno())
-        self.assertEquals(ctx.exception.errno, errno.EPIPE)
+        self.assertEqual(ctx.exception.errno, errno.EPIPE)
 
     def test_send_to_broken_pipe_2(self):
         snap = ZFSTest.pool.makeName("fs1@snap")
@@ -1845,7 +1846,7 @@ def test_send_to_ro_file(self):
             with self.assertRaises(lzc_exc.StreamIOError) as ctx:
                 lzc.lzc_send(snap, None, fd)
             os.close(fd)
-        self.assertEquals(ctx.exception.errno, errno.EBADF)
+        self.assertEqual(ctx.exception.errno, errno.EBADF)
 
     def test_recv_full(self):
         src = ZFSTest.pool.makeName("fs1@snap")
@@ -2038,7 +2039,7 @@ def test_recv_full_but_specify_origin(self):
             lzc.lzc_receive(dst, stream.fileno(), origin=origin1)
             origin = ZFSTest.pool.getFilesystem("fs2/received-30").getProperty(
                 'origin')
-            self.assertEquals(origin, origin1)
+            self.assertEqual(origin, origin1)
             stream.seek(0)
             # because origin snap does not exist can't receive as a clone of it
             with self.assertRaises((
@@ -2745,8 +2746,8 @@ def test_recv_one_props(self):
             (header, c_header) = lzc.receive_header(stream.fileno())
             lzc.lzc_receive_one(tosnap, stream.fileno(), c_header, props=props)
             self.assertExists(tosnap)
-            self.assertEquals(fs.getProperty("compression", "received"), "on")
-            self.assertEquals(fs.getProperty("ns:prop", "received"), "val")
+            self.assertEqual(fs.getProperty("compression", "received"), "on")
+            self.assertEqual(fs.getProperty("ns:prop", "received"), "val")
 
     def test_recv_one_invalid_prop(self):
         fromsnap = ZFSTest.pool.makeName("fs1@snap1")
@@ -2766,10 +2767,10 @@ def test_recv_one_invalid_prop(self):
                 lzc.lzc_receive_one(
                     tosnap, stream.fileno(), c_header, props=props)
             self.assertExists(tosnap)
-            self.assertEquals(fs.getProperty("atime", "received"), "off")
+            self.assertEqual(fs.getProperty("atime", "received"), "off")
             for e in ctx.exception.errors:
                 self.assertIsInstance(e, lzc_exc.PropertyInvalid)
-                self.assertEquals(e.name, "exec")
+                self.assertEqual(e.name, "exec")
 
     def test_recv_with_cmdprops(self):
         fromsnap = ZFSTest.pool.makeName("fs1@snap1")
@@ -2790,8 +2791,8 @@ def test_recv_with_cmdprops(self):
                 tosnap, stream.fileno(), c_header, props=props,
                 cmdprops=cmdprops)
             self.assertExists(tosnap)
-            self.assertEquals(fs.getProperty("compression"), "on")
-            self.assertEquals(fs.getProperty("ns:prop"), "val")
+            self.assertEqual(fs.getProperty("compression"), "on")
+            self.assertEqual(fs.getProperty("ns:prop"), "val")
 
     def test_recv_with_cmdprops_and_recvprops(self):
         fromsnap = ZFSTest.pool.makeName("fs1@snap1")
@@ -2817,12 +2818,12 @@ def test_recv_with_cmdprops_and_recvprops(self):
                 tosnap, stream.fileno(), c_header, props=props,
                 cmdprops=cmdprops)
             self.assertExists(tosnap)
-            self.assertEquals(fs.getProperty("atime", True), "on")
-            self.assertEquals(fs.getProperty("exec", True), "off")
-            self.assertEquals(fs.getProperty("ns:prop", True), "abc")
-            self.assertEquals(fs.getProperty("compression"), "on")
-            self.assertEquals(fs.getProperty("ns:prop"), "def")
-            self.assertEquals(fs.getProperty("exec"), "on")
+            self.assertEqual(fs.getProperty("atime", True), "on")
+            self.assertEqual(fs.getProperty("exec", True), "off")
+            self.assertEqual(fs.getProperty("ns:prop", True), "abc")
+            self.assertEqual(fs.getProperty("compression"), "on")
+            self.assertEqual(fs.getProperty("ns:prop"), "def")
+            self.assertEqual(fs.getProperty("exec"), "on")
 
     def test_recv_incr_across_clone_branch_point_no_origin(self):
         origfs = ZFSTest.pool.makeName("fs2")
@@ -3059,7 +3060,7 @@ def test_hold_missing_fs(self):
         snap = ZFSTest.pool.getRoot().getFilesystem().getSnap()
 
         snaps = lzc.lzc_hold({snap: 'tag'})
-        self.assertEquals([snap], snaps)
+        self.assertEqual([snap], snaps)
 
     def test_hold_missing_fs_auto_cleanup(self):
         # XXX skip pre-created filesystems
@@ -3072,7 +3073,7 @@ def test_hold_missing_fs_auto_cleanup(self):
 
         with cleanup_fd() as fd:
             snaps = lzc.lzc_hold({snap: 'tag'}, fd)
-            self.assertEquals([snap], snaps)
+            self.assertEqual([snap], snaps)
 
     def test_hold_duplicate(self):
         snap = ZFSTest.pool.getRoot().getSnap()
@@ -3107,7 +3108,7 @@ def test_hold_too_long_tag(self):
                 lzc.lzc_hold({snap: tag}, fd)
         for e in ctx.exception.errors:
             self.assertIsInstance(e, lzc_exc.NameTooLong)
-            self.assertEquals(e.name, tag)
+            self.assertEqual(e.name, tag)
 
     # Apparently the full snapshot name is not checked for length
     # and this snapshot is treated as simply missing.
@@ -3119,7 +3120,7 @@ def test_hold_too_long_snap_name(self):
                 lzc.lzc_hold({snap: 'tag'}, fd)
         for e in ctx.exception.errors:
             self.assertIsInstance(e, lzc_exc.NameTooLong)
-            self.assertEquals(e.name, snap)
+            self.assertEqual(e.name, snap)
 
     def test_hold_too_long_snap_name_2(self):
         snap = ZFSTest.pool.getRoot().getTooLongSnap(True)
@@ -3128,7 +3129,7 @@ def test_hold_too_long_snap_name_2(self):
                 lzc.lzc_hold({snap: 'tag'}, fd)
         for e in ctx.exception.errors:
             self.assertIsInstance(e, lzc_exc.NameTooLong)
-            self.assertEquals(e.name, snap)
+            self.assertEqual(e.name, snap)
 
     def test_hold_invalid_snap_name(self):
         snap = ZFSTest.pool.getRoot().getSnap() + '@bad'
@@ -3137,7 +3138,7 @@ def test_hold_invalid_snap_name(self):
                 lzc.lzc_hold({snap: 'tag'}, fd)
         for e in ctx.exception.errors:
             self.assertIsInstance(e, lzc_exc.NameInvalid)
-            self.assertEquals(e.name, snap)
+            self.assertEqual(e.name, snap)
 
     def test_hold_invalid_snap_name_2(self):
         snap = ZFSTest.pool.getRoot().getFilesystem().getName()
@@ -3146,7 +3147,7 @@ def test_hold_invalid_snap_name_2(self):
                 lzc.lzc_hold({snap: 'tag'}, fd)
         for e in ctx.exception.errors:
             self.assertIsInstance(e, lzc_exc.NameInvalid)
-            self.assertEquals(e.name, snap)
+            self.assertEqual(e.name, snap)
 
     def test_get_holds(self):
         snap = ZFSTest.pool.getRoot().getSnap()
@@ -3157,10 +3158,10 @@ def test_get_holds(self):
             lzc.lzc_hold({snap: 'tag2'}, fd)
 
             holds = lzc.lzc_get_holds(snap)
-            self.assertEquals(len(holds), 2)
+            self.assertEqual(len(holds), 2)
             self.assertIn('tag1', holds)
             self.assertIn('tag2', holds)
-            self.assertIsInstance(holds['tag1'], (int, long))
+            self.assertIsInstance(holds['tag1'], (int, int))
 
     def test_get_holds_after_auto_cleanup(self):
         snap = ZFSTest.pool.getRoot().getSnap()
@@ -3171,7 +3172,7 @@ def test_get_holds_after_auto_cleanup(self):
             lzc.lzc_hold({snap: 'tag2'}, fd)
 
         holds = lzc.lzc_get_holds(snap)
-        self.assertEquals(len(holds), 0)
+        self.assertEqual(len(holds), 0)
         self.assertIsInstance(holds, dict)
 
     def test_get_holds_nonexistent_snap(self):
@@ -3208,11 +3209,11 @@ def test_release_hold(self):
 
         lzc.lzc_hold({snap: 'tag'})
         ret = lzc.lzc_release({snap: ['tag']})
-        self.assertEquals(len(ret), 0)
+        self.assertEqual(len(ret), 0)
 
     def test_release_hold_empty(self):
         ret = lzc.lzc_release({})
-        self.assertEquals(len(ret), 0)
+        self.assertEqual(len(ret), 0)
 
     def test_release_hold_complex(self):
         snap1 = ZFSTest.pool.getRoot().getSnap()
@@ -3228,11 +3229,11 @@ def test_release_hold_complex(self):
         lzc.lzc_hold({snap3: 'tag2'})
 
         holds = lzc.lzc_get_holds(snap1)
-        self.assertEquals(len(holds), 2)
+        self.assertEqual(len(holds), 2)
         holds = lzc.lzc_get_holds(snap2)
-        self.assertEquals(len(holds), 1)
+        self.assertEqual(len(holds), 1)
         holds = lzc.lzc_get_holds(snap3)
-        self.assertEquals(len(holds), 2)
+        self.assertEqual(len(holds), 2)
 
         release = {
             snap1: ['tag1', 'tag2'],
@@ -3240,19 +3241,19 @@ def test_release_hold_complex(self):
             snap3: ['tag2'],
         }
         ret = lzc.lzc_release(release)
-        self.assertEquals(len(ret), 0)
+        self.assertEqual(len(ret), 0)
 
         holds = lzc.lzc_get_holds(snap1)
-        self.assertEquals(len(holds), 0)
+        self.assertEqual(len(holds), 0)
         holds = lzc.lzc_get_holds(snap2)
-        self.assertEquals(len(holds), 0)
+        self.assertEqual(len(holds), 0)
         holds = lzc.lzc_get_holds(snap3)
-        self.assertEquals(len(holds), 1)
+        self.assertEqual(len(holds), 1)
 
         ret = lzc.lzc_release({snap3: ['tag1']})
-        self.assertEquals(len(ret), 0)
+        self.assertEqual(len(ret), 0)
         holds = lzc.lzc_get_holds(snap3)
-        self.assertEquals(len(holds), 0)
+        self.assertEqual(len(holds), 0)
 
     def test_release_hold_before_auto_cleanup(self):
         snap = ZFSTest.pool.getRoot().getSnap()
@@ -3261,7 +3262,7 @@ def test_release_hold_before_auto_cleanup(self):
         with cleanup_fd() as fd:
             lzc.lzc_hold({snap: 'tag'}, fd)
             ret = lzc.lzc_release({snap: ['tag']})
-            self.assertEquals(len(ret), 0)
+            self.assertEqual(len(ret), 0)
 
     def test_release_hold_and_snap_destruction(self):
         snap = ZFSTest.pool.getRoot().getSnap()
@@ -3301,22 +3302,22 @@ def test_release_hold_missing_tag(self):
         lzc.lzc_snapshot([snap])
 
         ret = lzc.lzc_release({snap: ['tag']})
-        self.assertEquals(len(ret), 1)
-        self.assertEquals(ret[0], snap + '#tag')
+        self.assertEqual(len(ret), 1)
+        self.assertEqual(ret[0], snap + '#tag')
 
     def test_release_hold_missing_snap(self):
         snap = ZFSTest.pool.getRoot().getSnap()
 
         ret = lzc.lzc_release({snap: ['tag']})
-        self.assertEquals(len(ret), 1)
-        self.assertEquals(ret[0], snap)
+        self.assertEqual(len(ret), 1)
+        self.assertEqual(ret[0], snap)
 
     def test_release_hold_missing_snap_2(self):
         snap = ZFSTest.pool.getRoot().getSnap()
 
         ret = lzc.lzc_release({snap: ['tag', 'another']})
-        self.assertEquals(len(ret), 1)
-        self.assertEquals(ret[0], snap)
+        self.assertEqual(len(ret), 1)
+        self.assertEqual(ret[0], snap)
 
     def test_release_hold_across_pools(self):
         snap1 = ZFSTest.pool.getRoot().getSnap()
@@ -3358,7 +3359,7 @@ def test_release_hold_too_long_snap_name_2(self):
             lzc.lzc_release({snap: ['tag']})
         for e in ctx.exception.errors:
             self.assertIsInstance(e, lzc_exc.NameTooLong)
-            self.assertEquals(e.name, snap)
+            self.assertEqual(e.name, snap)
 
     def test_release_hold_invalid_snap_name(self):
         snap = ZFSTest.pool.getRoot().getSnap() + '@bad'
@@ -3366,7 +3367,7 @@ def test_release_hold_invalid_snap_name(self):
             lzc.lzc_release({snap: ['tag']})
         for e in ctx.exception.errors:
             self.assertIsInstance(e, lzc_exc.NameInvalid)
-            self.assertEquals(e.name, snap)
+            self.assertEqual(e.name, snap)
 
     def test_release_hold_invalid_snap_name_2(self):
         snap = ZFSTest.pool.getRoot().getFilesystem().getName()
@@ -3374,7 +3375,7 @@ def test_release_hold_invalid_snap_name_2(self):
             lzc.lzc_release({snap: ['tag']})
         for e in ctx.exception.errors:
             self.assertIsInstance(e, lzc_exc.NameInvalid)
-            self.assertEquals(e.name, snap)
+            self.assertEqual(e.name, snap)
 
     def test_sync_missing_pool(self):
         pool = "nonexistent"
@@ -4062,7 +4063,7 @@ def __init__(self, size=128 * 1024 * 1024, readonly=False, filesystems=[]):
             if 'permission denied' in e.output:
                 raise unittest.SkipTest(
                     'insufficient privileges to run libzfs_core tests')
-            print 'command failed: ', e.output
+            print('command failed: ', e.output)
             raise
         except Exception:
             self.cleanUp()
@@ -4108,7 +4109,7 @@ def reset(self):
                     time.sleep(1)
                     continue
                 else:
-                    print 'command failed: ', e.output
+                    print('command failed: ', e.output)
                     raise
         for fs in self._filesystems:
             lzc.lzc_create(self.makeName(fs))
diff --git a/contrib/pyzfs/libzfs_core/test/test_nvlist.py b/contrib/pyzfs/libzfs_core/test/test_nvlist.py
index 7dab17853a07..03fc95a87d5b 100644
--- a/contrib/pyzfs/libzfs_core/test/test_nvlist.py
+++ b/contrib/pyzfs/libzfs_core/test/test_nvlist.py
@@ -21,6 +21,7 @@
 The tests also check that various error conditions like unsupported
 value types or out of bounds values are detected.
 """
+from __future__ import absolute_import, division, print_function
 
 import unittest
 
diff --git a/contrib/pyzfs/setup.py b/contrib/pyzfs/setup.py
index 3baa25c1b429..e76ffbf82173 100644
--- a/contrib/pyzfs/setup.py
+++ b/contrib/pyzfs/setup.py
@@ -13,6 +13,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
+from __future__ import absolute_import, division, print_function
 
 from setuptools import setup, find_packages