STY: Giant comma spacing fixup.

Run the 2to3 ws_comma fixer on *.py files. Some lines are now too long
and will need to be broken at some point. OTOH, some lines were already
too long and need to be broken at some point. Now seems as good a time
as any to do this with open PRs at a minimum.

9 files changed, 304 insertions, 304 deletions

diff --git a/numpy/ma/bench.py b/numpy/ma/bench.py
index b8d085130..75e6d90c8 100644
--- a/numpy/ma/bench.py
+++ b/numpy/ma/bench.py
@@ -17,8 +17,8 @@ import numpy
 #####---------------------------------------------------------------------------
 
 # Small arrays ..................................
-xs = numpy.random.uniform(-1,1,6).reshape(2,3)
-ys = numpy.random.uniform(-1,1,6).reshape(2,3)
+xs = numpy.random.uniform(-1, 1, 6).reshape(2, 3)
+ys = numpy.random.uniform(-1, 1, 6).reshape(2, 3)
 zs = xs + 1j * ys
 m1 = [[True, False, False], [False, False, True]]
 m2 = [[True, False, True], [False, False, True]]
@@ -26,8 +26,8 @@ nmxs = numpy.ma.array(xs, mask=m1)
 nmys = numpy.ma.array(ys, mask=m2)
 nmzs = numpy.ma.array(zs, mask=m1)
 # Big arrays ....................................
-xl = numpy.random.uniform(-1,1,100*100).reshape(100,100)
-yl = numpy.random.uniform(-1,1,100*100).reshape(100,100)
+xl = numpy.random.uniform(-1, 1, 100*100).reshape(100, 100)
+yl = numpy.random.uniform(-1, 1, 100*100).reshape(100, 100)
 zl = xl + 1j * yl
 maskx = xl > 0.8
 masky = yl < -0.8
@@ -42,7 +42,7 @@ nmzl = numpy.ma.array(zl, mask=maskx)
 def timer(s, v='', nloop=500, nrep=3):
     units = ["s", "ms", "µs", "ns"]
     scaling = [1, 1e3, 1e6, 1e9]
-    print("%s : %-50s : " % (v,s), end=' ')
+    print("%s : %-50s : " % (v, s), end=' ')
     varnames = ["%ss,nm%ss,%sl,nm%sl" % tuple(x*4) for x in 'xyz']
     setup = 'from __main__ import numpy, ma, %s' % ','.join(varnames)
     Timer = timeit.Timer(stmt=s, setup=setup)
@@ -64,11 +64,11 @@ def compare_functions_1v(func, nloop=500,
     funcname = func.__name__
     print("-"*50)
     print("%s on small arrays" % funcname)
-    module, data = "numpy.ma","nmxs"
+    module, data = "numpy.ma", "nmxs"
     timer("%(module)s.%(funcname)s(%(data)s)" % locals(), v="%11s" % module, nloop=nloop)
     #
     print("%s on large arrays" % funcname)
-    module, data = "numpy.ma","nmxl"
+    module, data = "numpy.ma", "nmxl"
     timer("%(module)s.%(funcname)s(%(data)s)" % locals(), v="%11s" % module, nloop=nloop)
     return
 
@@ -92,11 +92,11 @@ def compare_functions_2v(func, nloop=500, test=True,
     funcname = func.__name__
     print("-"*50)
     print("%s on small arrays" % funcname)
-    module, data = "numpy.ma","nmxs,nmys"
+    module, data = "numpy.ma", "nmxs,nmys"
     timer("%(module)s.%(funcname)s(%(data)s)" % locals(), v="%11s" % module, nloop=nloop)
     #
     print("%s on large arrays" % funcname)
-    module, data = "numpy.ma","nmxl,nmyl"
+    module, data = "numpy.ma", "nmxl,nmyl"
     timer("%(module)s.%(funcname)s(%(data)s)" % locals(), v="%11s" % module, nloop=nloop)
     return
 
@@ -139,28 +139,28 @@ if __name__ == '__main__':
     compare_functions_2v(numpy.divide)
     compare_functions_2v(numpy.power)
     #....................................................................
-    compare_methods('ravel','', nloop=1000)
-    compare_methods('conjugate','','z', nloop=1000)
-    compare_methods('transpose','', nloop=1000)
-    compare_methods('compressed','', nloop=1000)
-    compare_methods('__getitem__','0', nloop=1000)
-    compare_methods('__getitem__','(0,0)', nloop=1000)
-    compare_methods('__getitem__','[0,-1]', nloop=1000)
-    compare_methods('__setitem__','0, 17', nloop=1000, test=False)
-    compare_methods('__setitem__','(0,0), 17', nloop=1000, test=False)
+    compare_methods('ravel', '', nloop=1000)
+    compare_methods('conjugate', '', 'z', nloop=1000)
+    compare_methods('transpose', '', nloop=1000)
+    compare_methods('compressed', '', nloop=1000)
+    compare_methods('__getitem__', '0', nloop=1000)
+    compare_methods('__getitem__', '(0,0)', nloop=1000)
+    compare_methods('__getitem__', '[0,-1]', nloop=1000)
+    compare_methods('__setitem__', '0, 17', nloop=1000, test=False)
+    compare_methods('__setitem__', '(0,0), 17', nloop=1000, test=False)
     #....................................................................
     print("-"*50)
     print("__setitem__ on small arrays")
-    timer('nmxs.__setitem__((-1,0),numpy.ma.masked)', 'numpy.ma   ',nloop=10000)
+    timer('nmxs.__setitem__((-1,0),numpy.ma.masked)', 'numpy.ma   ', nloop=10000)
 
     print("-"*50)
     print("__setitem__ on large arrays")
-    timer('nmxl.__setitem__((-1,0),numpy.ma.masked)', 'numpy.ma   ',nloop=10000)
+    timer('nmxl.__setitem__((-1,0),numpy.ma.masked)', 'numpy.ma   ', nloop=10000)
 
     #....................................................................
     print("-"*50)
     print("where on small arrays")
-    timer('numpy.ma.where(nmxs>2,nmxs,nmys)', 'numpy.ma   ',nloop=1000)
+    timer('numpy.ma.where(nmxs>2,nmxs,nmys)', 'numpy.ma   ', nloop=1000)
     print("-"*50)
     print("where on large arrays")
-    timer('numpy.ma.where(nmxl>2,nmxl,nmyl)', 'numpy.ma   ',nloop=100)
+    timer('numpy.ma.where(nmxl>2,nmxl,nmyl)', 'numpy.ma   ', nloop=100)
diff --git a/numpy/ma/setup.py b/numpy/ma/setup.py
index 2175628d6..5486ff46a 100644
--- a/numpy/ma/setup.py
+++ b/numpy/ma/setup.py
@@ -10,7 +10,7 @@ import os
 
 def configuration(parent_package='',top_path=None):
     from numpy.distutils.misc_util import Configuration
-    config = Configuration('ma',parent_package,top_path)
+    config = Configuration('ma', parent_package, top_path)
     config.add_data_dir('tests')
     return config
 
diff --git a/numpy/ma/tests/test_core.py b/numpy/ma/tests/test_core.py
index 088e203b2..6c7baa48e 100644
--- a/numpy/ma/tests/test_core.py
+++ b/numpy/ma/tests/test_core.py
@@ -34,7 +34,7 @@ class TestMaskedArray(TestCase):
         y = np.array([5., 0., 3., 2., -1., -4., 0., -10., 10., 1., 0., 3.])
         a10 = 10.
         m1 = [1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0]
-        m2 = [0, 0, 1, 0, 0, 1, 1, 0, 0, 0 , 0, 1]
+        m2 = [0, 0, 1, 0, 0, 1, 1, 0, 0, 0, 0, 1]
         xm = masked_array(x, mask=m1)
         ym = masked_array(y, mask=m2)
         z = np.array([-.5, 0., .5, .8])
@@ -79,8 +79,8 @@ class TestMaskedArray(TestCase):
         assert_equal(xm.shape, s)
         assert_equal(xm.dtype, x.dtype)
         assert_equal(zm.dtype, z.dtype)
-        assert_equal(xm.size , reduce(lambda x, y:x * y, s))
-        assert_equal(count(xm) , len(m1) - reduce(lambda x, y:x + y, m1))
+        assert_equal(xm.size, reduce(lambda x, y:x * y, s))
+        assert_equal(count(xm), len(m1) - reduce(lambda x, y:x + y, m1))
         assert_array_equal(xm, xf)
         assert_array_equal(filled(xm, 1.e20), xf)
         assert_array_equal(x, xm)
@@ -100,8 +100,8 @@ class TestMaskedArray(TestCase):
             self.assertTrue(isMaskedArray(xm))
             assert_equal(shape(xm), s)
             assert_equal(xm.shape, s)
-            assert_equal(xm.size , reduce(lambda x, y:x * y, s))
-            assert_equal(count(xm) , len(m1) - reduce(lambda x, y:x + y, m1))
+            assert_equal(xm.size, reduce(lambda x, y:x * y, s))
+            assert_equal(count(xm), len(m1) - reduce(lambda x, y:x + y, m1))
             assert_equal(xm, xf)
             assert_equal(filled(xm, 1.e20), xf)
             assert_equal(x, xm)
@@ -658,7 +658,7 @@ class TestMaskedArrayArithmetic(TestCase):
         y = np.array([5., 0., 3., 2., -1., -4., 0., -10., 10., 1., 0., 3.])
         a10 = 10.
         m1 = [1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0]
-        m2 = [0, 0, 1, 0, 0, 1, 1, 0, 0, 0 , 0, 1]
+        m2 = [0, 0, 1, 0, 0, 1, 1, 0, 0, 0, 0, 1]
         xm = masked_array(x, mask=m1)
         ym = masked_array(y, mask=m2)
         z = np.array([-.5, 0., .5, .8])
@@ -717,7 +717,7 @@ class TestMaskedArrayArithmetic(TestCase):
         assert_equal(z, [[-1., 1., 1.], [-1., 4., 2.5]])
         assert_equal(z.mask, [[1, 0, 0], [1, 0, 0]])
         #
-        z = x / y[None, :]
+        z = x / y[None,:]
         assert_equal(z, [[-1., 1., 1.], [-1., 4., 2.5]])
         assert_equal(z.mask, [[1, 0, 0], [1, 0, 0]])
         #
@@ -1547,7 +1547,7 @@ class TestFillingValues(TestCase):
         "Test the behavior of fill_value in view"
 
         # Create initial masked array
-        x = array([1,2,3], fill_value=1, dtype=np.int64)
+        x = array([1, 2, 3], fill_value=1, dtype=np.int64)
 
         # Check that fill_value is preserved by default
         y = x.view()
@@ -1778,7 +1778,7 @@ class TestMaskedArrayInPlaceArithmetics(TestCase):
         x = [1., 1., 1., -2., pi / 2., 4., 5., -10., 10., 1., 2., 3.]
         y = [5., 0., 3., 2., -1., -4., 0., -10., 10., 1., 0., 3.]
         m1 = [1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0]
-        m2 = [0, 0, 1, 0, 0, 1, 1, 0, 0, 0 , 0, 1]
+        m2 = [0, 0, 1, 0, 0, 1, 1, 0, 0, 0, 0, 1]
         xm = masked_array(x, mask=m1)
         ym = masked_array(y, mask=m2)
         #
@@ -1952,10 +1952,10 @@ class TestMaskedArrayMethods(TestCase):
     "Test class for miscellaneous MaskedArrays methods."
     def setUp(self):
         "Base data definition."
-        x = np.array([ 8.375, 7.545, 8.828, 8.5  , 1.757, 5.928,
-                      8.43 , 7.78 , 9.865, 5.878, 8.979, 4.732,
+        x = np.array([ 8.375, 7.545, 8.828, 8.5, 1.757, 5.928,
+                      8.43, 7.78, 9.865, 5.878, 8.979, 4.732,
                       3.012, 6.022, 5.095, 3.116, 5.238, 3.957,
-                      6.04 , 9.63 , 7.712, 3.382, 4.489, 6.479,
+                      6.04, 9.63, 7.712, 3.382, 4.489, 6.479,
                       7.189, 9.645, 5.395, 4.961, 9.894, 2.893,
                       7.357, 9.828, 6.272, 3.758, 6.693, 0.993])
         X = x.reshape(6, 6)
@@ -2125,10 +2125,10 @@ class TestMaskedArrayMethods(TestCase):
 
     def test_clip(self):
         "Tests clip on MaskedArrays."
-        x = np.array([ 8.375, 7.545, 8.828, 8.5  , 1.757, 5.928,
-                       8.43 , 7.78 , 9.865, 5.878, 8.979, 4.732,
+        x = np.array([ 8.375, 7.545, 8.828, 8.5, 1.757, 5.928,
+                       8.43, 7.78, 9.865, 5.878, 8.979, 4.732,
                        3.012, 6.022, 5.095, 3.116, 5.238, 3.957,
-                       6.04 , 9.63 , 7.712, 3.382, 4.489, 6.479,
+                       6.04, 9.63, 7.712, 3.382, 4.489, 6.479,
                        7.189, 9.645, 5.395, 4.961, 9.894, 2.893,
                        7.357, 9.828, 6.272, 3.758, 6.693, 0.993])
         m = np.array([0, 1, 0, 1, 0, 0, 1, 0, 1, 1, 0, 1,
@@ -2428,10 +2428,10 @@ class TestMaskedArrayMethods(TestCase):
 
     def test_swapaxes(self):
         "Tests swapaxes on MaskedArrays."
-        x = np.array([ 8.375, 7.545, 8.828, 8.5  , 1.757, 5.928,
-                      8.43 , 7.78 , 9.865, 5.878, 8.979, 4.732,
+        x = np.array([ 8.375, 7.545, 8.828, 8.5, 1.757, 5.928,
+                      8.43, 7.78, 9.865, 5.878, 8.979, 4.732,
                       3.012, 6.022, 5.095, 3.116, 5.238, 3.957,
-                      6.04 , 9.63 , 7.712, 3.382, 4.489, 6.479,
+                      6.04, 9.63, 7.712, 3.382, 4.489, 6.479,
                       7.189, 9.645, 5.395, 4.961, 9.894, 2.893,
                       7.357, 9.828, 6.272, 3.758, 6.693, 0.993])
         m = np.array([0, 1, 0, 1, 0, 0,
@@ -2467,7 +2467,7 @@ class TestMaskedArrayMethods(TestCase):
     def test_take_masked_indices(self):
         "Test take w/ masked indices"
         a = np.array((40, 18, 37, 9, 22))
-        indices = np.arange(3)[None, :] + np.arange(5)[:, None]
+        indices = np.arange(3)[None,:] + np.arange(5)[:, None]
         mindices = array(indices, mask=(indices >= len(a)))
         # No mask
         test = take(a, mindices, mode='clip')
@@ -2615,10 +2615,10 @@ class TestMaskedArrayMathMethods(TestCase):
 
     def setUp(self):
         "Base data definition."
-        x = np.array([ 8.375, 7.545, 8.828, 8.5  , 1.757, 5.928,
-                      8.43 , 7.78 , 9.865, 5.878, 8.979, 4.732,
+        x = np.array([ 8.375, 7.545, 8.828, 8.5, 1.757, 5.928,
+                      8.43, 7.78, 9.865, 5.878, 8.979, 4.732,
                       3.012, 6.022, 5.095, 3.116, 5.238, 3.957,
-                      6.04 , 9.63 , 7.712, 3.382, 4.489, 6.479,
+                      6.04, 9.63, 7.712, 3.382, 4.489, 6.479,
                       7.189, 9.645, 5.395, 4.961, 9.894, 2.893,
                       7.357, 9.828, 6.272, 3.758, 6.693, 0.993])
         X = x.reshape(6, 6)
@@ -2840,10 +2840,10 @@ class TestMaskedArrayMathMethodsComplex(TestCase):
     "Test class for miscellaneous MaskedArrays methods."
     def setUp(self):
         "Base data definition."
-        x = np.array([ 8.375j, 7.545j, 8.828j, 8.5j  , 1.757j, 5.928,
-                      8.43 , 7.78 , 9.865, 5.878, 8.979, 4.732,
+        x = np.array([ 8.375j, 7.545j, 8.828j, 8.5j, 1.757j, 5.928,
+                      8.43, 7.78, 9.865, 5.878, 8.979, 4.732,
                       3.012, 6.022, 5.095, 3.116, 5.238, 3.957,
-                      6.04 , 9.63 , 7.712, 3.382, 4.489, 6.479j,
+                      6.04, 9.63, 7.712, 3.382, 4.489, 6.479j,
                       7.189j, 9.645, 5.395, 4.961, 9.894, 2.893,
                       7.357, 9.828, 6.272, 3.758, 6.693, 0.993j])
         X = x.reshape(6, 6)
@@ -2897,7 +2897,7 @@ class TestMaskedArrayFunctions(TestCase):
         y = np.array([5., 0., 3., 2., -1., -4., 0., -10., 10., 1., 0., 3.])
         a10 = 10.
         m1 = [1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0]
-        m2 = [0, 0, 1, 0, 0, 1, 1, 0, 0, 0 , 0, 1]
+        m2 = [0, 0, 1, 0, 0, 1, 1, 0, 0, 0, 0, 1]
         xm = masked_array(x, mask=m1)
         ym = masked_array(y, mask=m2)
         z = np.array([-.5, 0., .5, .8])
@@ -3079,7 +3079,7 @@ class TestMaskedArrayFunctions(TestCase):
         y = np.array([5., 0., 3., 2., -1., -4., 0., -10., 10., 1., 0., 3.])
         a10 = 10.
         m1 = [1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0]
-        m2 = [0, 0, 1, 0, 0, 1, 1, 0, 0, 0 , 0, 1]
+        m2 = [0, 0, 1, 0, 0, 1, 1, 0, 0, 0, 0, 1]
         xm = masked_array(x, mask=m1)
         ym = masked_array(y, mask=m2)
         z = np.array([-.5, 0., .5, .8])
@@ -3110,7 +3110,7 @@ class TestMaskedArrayFunctions(TestCase):
         x[3] = masked
         c = x >= 8
         # Set False to masked
-        z = where(c , x, masked)
+        z = where(c, x, masked)
         assert_(z.dtype is x.dtype)
         assert_(z[3] is masked)
         assert_(z[4] is masked)
@@ -3119,7 +3119,7 @@ class TestMaskedArrayFunctions(TestCase):
         assert_(z[9] is not masked)
         assert_equal(x, z)
         # Set True to masked
-        z = where(c , masked, x)
+        z = where(c, masked, x)
         assert_(z.dtype is x.dtype)
         assert_(z[3] is masked)
         assert_(z[4] is not masked)
@@ -3369,7 +3369,7 @@ class TestMaskedArrayFunctions(TestCase):
         # Test compress function on ndarray and masked array
         # Address Github #2495.
         arr = np.arange(8)
-        arr.shape = 4,2
+        arr.shape = 4, 2
         cond = np.array([True, False, True, True])
         control = arr[[0, 2, 3]]
         test = np.ma.compress(cond, arr, axis=0)
@@ -3457,11 +3457,11 @@ class TestMaskedFields(TestCase):
         ndtype = [('a', int), ('b', float)]
         test = empty(3, dtype=ndtype)
         assert_equal(getmaskarray(test),
-                     np.array([(0, 0) , (0, 0), (0, 0)],
+                     np.array([(0, 0), (0, 0), (0, 0)],
                               dtype=[('a', '|b1'), ('b', '|b1')]))
         test[:] = masked
         assert_equal(getmaskarray(test),
-                     np.array([(1, 1) , (1, 1), (1, 1)],
+                     np.array([(1, 1), (1, 1), (1, 1)],
                               dtype=[('a', '|b1'), ('b', '|b1')]))
     #
     def test_view(self):
diff --git a/numpy/ma/tests/test_extras.py b/numpy/ma/tests/test_extras.py
index 4b30813b2..d1886f84a 100644
--- a/numpy/ma/tests/test_extras.py
+++ b/numpy/ma/tests/test_extras.py
@@ -277,8 +277,8 @@ class TestConcatenator(TestCase):
         assert_array_equal(d.mask, np.r_['1', m_1, m_2])
         d = mr_[b_1, b_2]
         self.assertTrue(d.shape == (10, 5))
-        assert_array_equal(d[:5, :], b_1)
-        assert_array_equal(d[5:, :], b_2)
+        assert_array_equal(d[:5,:], b_1)
+        assert_array_equal(d[5:,:], b_2)
         assert_array_equal(d.mask, np.r_[m_1, m_2])
 
 
@@ -688,7 +688,7 @@ class TestPolynomial(TestCase):
             assert_almost_equal(a, a_)
         #
         (C, R, K, S, D) = polyfit(x, y, 3, full=True)
-        (c, r, k, s, d) = np.polyfit(x[1:-1], y[1:-1, :], 3, full=True)
+        (c, r, k, s, d) = np.polyfit(x[1:-1], y[1:-1,:], 3, full=True)
         for (a, a_) in zip((C, R, K, S, D), (c, r, k, s, d)):
             assert_almost_equal(a, a_)
         #
diff --git a/numpy/ma/tests/test_mrecords.py b/numpy/ma/tests/test_mrecords.py
index 9938e55de..866979041 100644
--- a/numpy/ma/tests/test_mrecords.py
+++ b/numpy/ma/tests/test_mrecords.py
@@ -39,12 +39,12 @@ class TestMRecords(TestCase):
 
     def setup(self):
         "Generic setup"
-        ilist = [1,2,3,4,5]
-        flist = [1.1,2.2,3.3,4.4,5.5]
-        slist = asbytes_nested(['one','two','three','four','five'])
-        ddtype = [('a',int),('b',float),('c','|S8')]
-        mask = [0,1,0,0,1]
-        self.base = ma.array(list(zip(ilist,flist,slist)),
+        ilist = [1, 2, 3, 4, 5]
+        flist = [1.1, 2.2, 3.3, 4.4, 5.5]
+        slist = asbytes_nested(['one', 'two', 'three', 'four', 'five'])
+        ddtype = [('a', int), ('b', float), ('c', '|S8')]
+        mask = [0, 1, 0, 0, 1]
+        self.base = ma.array(list(zip(ilist, flist, slist)),
                              mask=mask, dtype=ddtype)
 
     def test_byview(self):
@@ -55,7 +55,7 @@ class TestMRecords(TestCase):
         assert_equal_records(mbase._mask, base._mask)
         assert_(isinstance(mbase._data, recarray))
         assert_equal_records(mbase._data, base._data.view(recarray))
-        for field in ('a','b','c'):
+        for field in ('a', 'b', 'c'):
             assert_equal(base[field], mbase[field])
         assert_equal_records(mbase.view(mrecarray), mbase)
 
@@ -64,14 +64,14 @@ class TestMRecords(TestCase):
         base = self.base.copy()
         mbase = base.view(mrecarray)
         # As fields..........
-        for field in ('a','b','c'):
-            assert_equal(getattr(mbase,field), mbase[field])
+        for field in ('a', 'b', 'c'):
+            assert_equal(getattr(mbase, field), mbase[field])
             assert_equal(base[field], mbase[field])
         # as elements .......
         mbase_first = mbase[0]
         assert_(isinstance(mbase_first, mrecarray))
         assert_equal(mbase_first.dtype, mbase.dtype)
-        assert_equal(mbase_first.tolist(), (1,1.1,asbytes('one')))
+        assert_equal(mbase_first.tolist(), (1, 1.1, asbytes('one')))
         # Used to be mask, now it's recordmask
         assert_equal(mbase_first.recordmask, nomask)
         assert_equal(mbase_first._mask.item(), (False, False, False))
@@ -79,7 +79,7 @@ class TestMRecords(TestCase):
         mbase_last = mbase[-1]
         assert_(isinstance(mbase_last, mrecarray))
         assert_equal(mbase_last.dtype, mbase.dtype)
-        assert_equal(mbase_last.tolist(), (None,None,None))
+        assert_equal(mbase_last.tolist(), (None, None, None))
         # Used to be mask, now it's recordmask
         assert_equal(mbase_last.recordmask, True)
         assert_equal(mbase_last._mask.item(), (True, True, True))
@@ -90,24 +90,24 @@ class TestMRecords(TestCase):
         assert_(isinstance(mbase_sl, mrecarray))
         assert_equal(mbase_sl.dtype, mbase.dtype)
         # Used to be mask, now it's recordmask
-        assert_equal(mbase_sl.recordmask, [0,1])
+        assert_equal(mbase_sl.recordmask, [0, 1])
         assert_equal_records(mbase_sl.mask,
-                             np.array([(False,False,False),(True,True,True)],
+                             np.array([(False, False, False), (True, True, True)],
                                       dtype=mbase._mask.dtype))
         assert_equal_records(mbase_sl, base[:2].view(mrecarray))
-        for field in ('a','b','c'):
-            assert_equal(getattr(mbase_sl,field), base[:2][field])
+        for field in ('a', 'b', 'c'):
+            assert_equal(getattr(mbase_sl, field), base[:2][field])
 
     def test_set_fields(self):
         "Tests setting fields."
         base = self.base.copy()
         mbase = base.view(mrecarray)
         mbase = mbase.copy()
-        mbase.fill_value = (999999,1e20,'N/A')
+        mbase.fill_value = (999999, 1e20, 'N/A')
         # Change the data, the mask should be conserved
         mbase.a._data[:] = 5
-        assert_equal(mbase['a']._data, [5,5,5,5,5])
-        assert_equal(mbase['a']._mask, [0,1,0,0,1])
+        assert_equal(mbase['a']._data, [5, 5, 5, 5, 5])
+        assert_equal(mbase['a']._mask, [0, 1, 0, 0, 1])
         # Change the elements, and the mask will follow
         mbase.a = 1
         assert_equal(mbase['a']._data, [1]*5)
@@ -115,7 +115,7 @@ class TestMRecords(TestCase):
         # Use to be _mask, now it's recordmask
         assert_equal(mbase.recordmask, [False]*5)
         assert_equal(mbase._mask.tolist(),
-                     np.array([(0,0,0),(0,1,1),(0,0,0),(0,0,0),(0,1,1)],
+                     np.array([(0, 0, 0), (0, 1, 1), (0, 0, 0), (0, 0, 0), (0, 1, 1)],
                               dtype=bool))
         # Set a field to mask ........................
         mbase.c = masked
@@ -125,27 +125,27 @@ class TestMRecords(TestCase):
         assert_equal(ma.getmaskarray(mbase['c']), [1]*5)
         assert_equal(ma.getdata(mbase['c']), [asbytes('N/A')]*5)
         assert_equal(mbase._mask.tolist(),
-                     np.array([(0,0,1),(0,1,1),(0,0,1),(0,0,1),(0,1,1)],
+                     np.array([(0, 0, 1), (0, 1, 1), (0, 0, 1), (0, 0, 1), (0, 1, 1)],
                               dtype=bool))
         # Set fields by slices .......................
         mbase = base.view(mrecarray).copy()
         mbase.a[3:] = 5
-        assert_equal(mbase.a, [1,2,3,5,5])
-        assert_equal(mbase.a._mask, [0,1,0,0,0])
+        assert_equal(mbase.a, [1, 2, 3, 5, 5])
+        assert_equal(mbase.a._mask, [0, 1, 0, 0, 0])
         mbase.b[3:] = masked
         assert_equal(mbase.b, base['b'])
-        assert_equal(mbase.b._mask, [0,1,0,1,1])
+        assert_equal(mbase.b._mask, [0, 1, 0, 1, 1])
         # Set fields globally..........................
-        ndtype = [('alpha','|S1'),('num',int)]
-        data = ma.array([('a',1),('b',2),('c',3)], dtype=ndtype)
+        ndtype = [('alpha', '|S1'), ('num', int)]
+        data = ma.array([('a', 1), ('b', 2), ('c', 3)], dtype=ndtype)
         rdata = data.view(MaskedRecords)
-        val = ma.array([10,20,30], mask=[1,0,0])
+        val = ma.array([10, 20, 30], mask=[1, 0, 0])
         #
         with warnings.catch_warnings():
             warnings.simplefilter("ignore")
             rdata['num'] = val
             assert_equal(rdata.num, val)
-            assert_equal(rdata.num.mask, [1,0,0])
+            assert_equal(rdata.num.mask, [1, 0, 0])
 
     def test_set_fields_mask(self):
         "Tests setting the mask of a field."
@@ -153,14 +153,14 @@ class TestMRecords(TestCase):
         # This one has already a mask....
         mbase = base.view(mrecarray)
         mbase['a'][-2] = masked
-        assert_equal(mbase.a, [1,2,3,4,5])
-        assert_equal(mbase.a._mask, [0,1,0,1,1])
+        assert_equal(mbase.a, [1, 2, 3, 4, 5])
+        assert_equal(mbase.a._mask, [0, 1, 0, 1, 1])
         # This one has not yet
         mbase = fromarrays([np.arange(5), np.random.rand(5)],
-                           dtype=[('a',int),('b',float)])
+                           dtype=[('a', int), ('b', float)])
         mbase['a'][-2] = masked
-        assert_equal(mbase.a, [0,1,2,3,4])
-        assert_equal(mbase.a._mask, [0,0,0,1,0])
+        assert_equal(mbase.a, [0, 1, 2, 3, 4])
+        assert_equal(mbase.a._mask, [0, 0, 0, 1, 0])
     #
     def test_set_mask(self):
         base = self.base.copy()
@@ -171,42 +171,42 @@ class TestMRecords(TestCase):
         assert_equal(mbase['a']._mask, mbase['b']._mask)
         assert_equal(mbase['a']._mask, mbase['c']._mask)
         assert_equal(mbase._mask.tolist(),
-                     np.array([(1,1,1)]*5, dtype=bool))
+                     np.array([(1, 1, 1)]*5, dtype=bool))
         # Delete the mask ............................
         mbase.mask = nomask
         assert_equal(ma.getmaskarray(mbase['c']), [0]*5)
         assert_equal(mbase._mask.tolist(),
-                     np.array([(0,0,0)]*5, dtype=bool))
+                     np.array([(0, 0, 0)]*5, dtype=bool))
     #
     def test_set_mask_fromarray(self):
         base = self.base.copy()
         mbase = base.view(mrecarray)
         # Sets the mask w/ an array
-        mbase.mask = [1,0,0,0,1]
-        assert_equal(mbase.a.mask, [1,0,0,0,1])
-        assert_equal(mbase.b.mask, [1,0,0,0,1])
-        assert_equal(mbase.c.mask, [1,0,0,0,1])
+        mbase.mask = [1, 0, 0, 0, 1]
+        assert_equal(mbase.a.mask, [1, 0, 0, 0, 1])
+        assert_equal(mbase.b.mask, [1, 0, 0, 0, 1])
+        assert_equal(mbase.c.mask, [1, 0, 0, 0, 1])
         # Yay, once more !
-        mbase.mask = [0,0,0,0,1]
-        assert_equal(mbase.a.mask, [0,0,0,0,1])
-        assert_equal(mbase.b.mask, [0,0,0,0,1])
-        assert_equal(mbase.c.mask, [0,0,0,0,1])
+        mbase.mask = [0, 0, 0, 0, 1]
+        assert_equal(mbase.a.mask, [0, 0, 0, 0, 1])
+        assert_equal(mbase.b.mask, [0, 0, 0, 0, 1])
+        assert_equal(mbase.c.mask, [0, 0, 0, 0, 1])
     #
     def test_set_mask_fromfields(self):
         mbase = self.base.copy().view(mrecarray)
         #
-        nmask = np.array([(0,1,0),(0,1,0),(1,0,1),(1,0,1),(0,0,0)],
-                         dtype=[('a',bool),('b',bool),('c',bool)])
+        nmask = np.array([(0, 1, 0), (0, 1, 0), (1, 0, 1), (1, 0, 1), (0, 0, 0)],
+                         dtype=[('a', bool), ('b', bool), ('c', bool)])
         mbase.mask = nmask
-        assert_equal(mbase.a.mask, [0,0,1,1,0])
-        assert_equal(mbase.b.mask, [1,1,0,0,0])
-        assert_equal(mbase.c.mask, [0,0,1,1,0])
+        assert_equal(mbase.a.mask, [0, 0, 1, 1, 0])
+        assert_equal(mbase.b.mask, [1, 1, 0, 0, 0])
+        assert_equal(mbase.c.mask, [0, 0, 1, 1, 0])
         # Reinitalizes and redo
         mbase.mask = False
         mbase.fieldmask = nmask
-        assert_equal(mbase.a.mask, [0,0,1,1,0])
-        assert_equal(mbase.b.mask, [1,1,0,0,0])
-        assert_equal(mbase.c.mask, [0,0,1,1,0])
+        assert_equal(mbase.a.mask, [0, 0, 1, 1, 0])
+        assert_equal(mbase.b.mask, [1, 1, 0, 0, 0])
+        assert_equal(mbase.c.mask, [0, 0, 1, 1, 0])
     #
     def test_set_elements(self):
         base = self.base.copy()
@@ -214,30 +214,30 @@ class TestMRecords(TestCase):
         mbase = base.view(mrecarray).copy()
         mbase[-2] = masked
         assert_equal(mbase._mask.tolist(),
-                     np.array([(0,0,0),(1,1,1),(0,0,0),(1,1,1),(1,1,1)],
+                     np.array([(0, 0, 0), (1, 1, 1), (0, 0, 0), (1, 1, 1), (1, 1, 1)],
                               dtype=bool))
         # Used to be mask, now it's recordmask!
-        assert_equal(mbase.recordmask, [0,1,0,1,1])
+        assert_equal(mbase.recordmask, [0, 1, 0, 1, 1])
         # Set slices .................................
         mbase = base.view(mrecarray).copy()
-        mbase[:2] = (5,5,5)
-        assert_equal(mbase.a._data, [5,5,3,4,5])
-        assert_equal(mbase.a._mask, [0,0,0,0,1])
-        assert_equal(mbase.b._data, [5.,5.,3.3,4.4,5.5])
-        assert_equal(mbase.b._mask, [0,0,0,0,1])
+        mbase[:2] = (5, 5, 5)
+        assert_equal(mbase.a._data, [5, 5, 3, 4, 5])
+        assert_equal(mbase.a._mask, [0, 0, 0, 0, 1])
+        assert_equal(mbase.b._data, [5., 5., 3.3, 4.4, 5.5])
+        assert_equal(mbase.b._mask, [0, 0, 0, 0, 1])
         assert_equal(mbase.c._data,
-                     asbytes_nested(['5','5','three','four','five']))
-        assert_equal(mbase.b._mask, [0,0,0,0,1])
+                     asbytes_nested(['5', '5', 'three', 'four', 'five']))
+        assert_equal(mbase.b._mask, [0, 0, 0, 0, 1])
         #
         mbase = base.view(mrecarray).copy()
         mbase[:2] = masked
-        assert_equal(mbase.a._data, [1,2,3,4,5])
-        assert_equal(mbase.a._mask, [1,1,0,0,1])
-        assert_equal(mbase.b._data, [1.1,2.2,3.3,4.4,5.5])
-        assert_equal(mbase.b._mask, [1,1,0,0,1])
+        assert_equal(mbase.a._data, [1, 2, 3, 4, 5])
+        assert_equal(mbase.a._mask, [1, 1, 0, 0, 1])
+        assert_equal(mbase.b._data, [1.1, 2.2, 3.3, 4.4, 5.5])
+        assert_equal(mbase.b._mask, [1, 1, 0, 0, 1])
         assert_equal(mbase.c._data,
-                     asbytes_nested(['one','two','three','four','five']))
-        assert_equal(mbase.b._mask, [1,1,0,0,1])
+                     asbytes_nested(['one', 'two', 'three', 'four', 'five']))
+        assert_equal(mbase.b._mask, [1, 1, 0, 0, 1])
     #
     def test_setslices_hardmask(self):
         "Tests setting slices w/ hardmask."
@@ -245,12 +245,12 @@ class TestMRecords(TestCase):
         mbase = base.view(mrecarray)
         mbase.harden_mask()
         try:
-            mbase[-2:] = (5,5,5)
-            assert_equal(mbase.a._data, [1,2,3,5,5])
-            assert_equal(mbase.b._data, [1.1,2.2,3.3,5,5.5])
+            mbase[-2:] = (5, 5, 5)
+            assert_equal(mbase.a._data, [1, 2, 3, 5, 5])
+            assert_equal(mbase.b._data, [1.1, 2.2, 3.3, 5, 5.5])
             assert_equal(mbase.c._data,
-                         asbytes_nested(['one','two','three','5','five']))
-            assert_equal(mbase.a._mask, [0,1,0,0,1])
+                         asbytes_nested(['one', 'two', 'three', '5', 'five']))
+            assert_equal(mbase.a._mask, [0, 1, 0, 0, 1])
             assert_equal(mbase.b._mask, mbase.a._mask)
             assert_equal(mbase.b._mask, mbase.c._mask)
         except NotImplementedError:
@@ -282,9 +282,9 @@ class TestMRecords(TestCase):
         mbase.mask = nomask
         # So, the mask of a field is no longer set to nomask...
         assert_equal_records(mbase._mask,
-                             ma.make_mask_none(base.shape,base.dtype))
+                             ma.make_mask_none(base.shape, base.dtype))
         self.assertTrue(ma.make_mask(mbase['b']._mask) is nomask)
-        assert_equal(mbase['a']._mask,mbase['b']._mask)
+        assert_equal(mbase['a']._mask, mbase['b']._mask)
     #
     def test_pickling(self):
         "Test pickling"
@@ -299,29 +299,29 @@ class TestMRecords(TestCase):
     #
     def test_filled(self):
         "Test filling the array"
-        _a = ma.array([1,2,3],mask=[0,0,1],dtype=int)
-        _b = ma.array([1.1,2.2,3.3],mask=[0,0,1],dtype=float)
-        _c = ma.array(['one','two','three'],mask=[0,0,1],dtype='|S8')
-        ddtype = [('a',int),('b',float),('c','|S8')]
-        mrec = fromarrays([_a,_b,_c], dtype=ddtype,
-                          fill_value=(99999,99999.,'N/A'))
+        _a = ma.array([1, 2, 3], mask=[0, 0, 1], dtype=int)
+        _b = ma.array([1.1, 2.2, 3.3], mask=[0, 0, 1], dtype=float)
+        _c = ma.array(['one', 'two', 'three'], mask=[0, 0, 1], dtype='|S8')
+        ddtype = [('a', int), ('b', float), ('c', '|S8')]
+        mrec = fromarrays([_a, _b, _c], dtype=ddtype,
+                          fill_value=(99999, 99999., 'N/A'))
         mrecfilled = mrec.filled()
-        assert_equal(mrecfilled['a'], np.array((1,2,99999), dtype=int))
-        assert_equal(mrecfilled['b'], np.array((1.1,2.2,99999.), dtype=float))
-        assert_equal(mrecfilled['c'], np.array(('one','two','N/A'), dtype='|S8'))
+        assert_equal(mrecfilled['a'], np.array((1, 2, 99999), dtype=int))
+        assert_equal(mrecfilled['b'], np.array((1.1, 2.2, 99999.), dtype=float))
+        assert_equal(mrecfilled['c'], np.array(('one', 'two', 'N/A'), dtype='|S8'))
     #
     def test_tolist(self):
         "Test tolist."
-        _a = ma.array([1,2,3],mask=[0,0,1],dtype=int)
-        _b = ma.array([1.1,2.2,3.3],mask=[0,0,1],dtype=float)
-        _c = ma.array(['one','two','three'],mask=[1,0,0],dtype='|S8')
-        ddtype = [('a',int),('b',float),('c','|S8')]
-        mrec = fromarrays([_a,_b,_c], dtype=ddtype,
-                          fill_value=(99999,99999.,'N/A'))
+        _a = ma.array([1, 2, 3], mask=[0, 0, 1], dtype=int)
+        _b = ma.array([1.1, 2.2, 3.3], mask=[0, 0, 1], dtype=float)
+        _c = ma.array(['one', 'two', 'three'], mask=[1, 0, 0], dtype='|S8')
+        ddtype = [('a', int), ('b', float), ('c', '|S8')]
+        mrec = fromarrays([_a, _b, _c], dtype=ddtype,
+                          fill_value=(99999, 99999., 'N/A'))
         #
         assert_equal(mrec.tolist(),
-                     [(1,1.1,None),(2,2.2,asbytes('two')),
-                      (None,None,asbytes('three'))])
+                     [(1, 1.1, None), (2, 2.2, asbytes('two')),
+                      (None, None, asbytes('three'))])
 
 
     #
@@ -333,9 +333,9 @@ class TestMRecords(TestCase):
     #
     def test_exotic_formats(self):
         "Test that 'exotic' formats are processed properly"
-        easy = mrecarray(1, dtype=[('i',int), ('s','|S8'), ('f',float)])
+        easy = mrecarray(1, dtype=[('i', int), ('s', '|S8'), ('f', float)])
         easy[0] = masked
-        assert_equal(easy.filled(1).item(), (1,asbytes('1'),1.))
+        assert_equal(easy.filled(1).item(), (1, asbytes('1'), 1.))
         #
         solo = mrecarray(1, dtype=[('f0', '<f8', (2, 2))])
         solo[0] = masked
@@ -347,19 +347,19 @@ class TestMRecords(TestCase):
         mult[1] = (1, 1, 1)
         mult.filled(0)
         assert_equal_records(mult.filled(0),
-                             np.array([(0,0,0),(1,1,1)], dtype=mult.dtype))
+                             np.array([(0, 0, 0), (1, 1, 1)], dtype=mult.dtype))
 
 
 class TestView(TestCase):
     #
     def setUp(self):
         (a, b) = (np.arange(10), np.random.rand(10))
-        ndtype = [('a',np.float), ('b',np.float)]
-        arr = np.array(list(zip(a,b)), dtype=ndtype)
+        ndtype = [('a', np.float), ('b', np.float)]
+        arr = np.array(list(zip(a, b)), dtype=ndtype)
         rec = arr.view(np.recarray)
         #
-        marr = ma.array(list(zip(a,b)), dtype=ndtype, fill_value=(-9., -99.))
-        mrec = fromarrays([a,b], dtype=ndtype, fill_value=(-9., -99.))
+        marr = ma.array(list(zip(a, b)), dtype=ndtype, fill_value=(-9., -99.))
+        mrec = fromarrays([a, b], dtype=ndtype, fill_value=(-9., -99.))
         mrec.mask[3] = (False, True)
         self.data = (mrec, a, b, arr)
     #
@@ -375,12 +375,12 @@ class TestView(TestCase):
         ntype = (np.float, 2)
         test = mrec.view(ntype)
         self.assertTrue(isinstance(test, ma.MaskedArray))
-        assert_equal(test, np.array(list(zip(a,b)), dtype=np.float))
-        self.assertTrue(test[3,1] is ma.masked)
+        assert_equal(test, np.array(list(zip(a, b)), dtype=np.float))
+        self.assertTrue(test[3, 1] is ma.masked)
     #
     def test_view_flexible_type(self):
         (mrec, a, b, arr) = self.data
-        alttype = [('A',np.float), ('B',np.float)]
+        alttype = [('A', np.float), ('B', np.float)]
         test = mrec.view(alttype)
         self.assertTrue(isinstance(test, MaskedRecords))
         assert_equal_records(test, arr.view(alttype))
@@ -398,26 +398,26 @@ class TestMRecordsImport(TestCase):
 
     def setup(self):
         "Generic setup"
-        _a = ma.array([1,2,3],mask=[0,0,1],dtype=int)
-        _b = ma.array([1.1,2.2,3.3],mask=[0,0,1],dtype=float)
-        _c = ma.array(list(map(asbytes,['one','two','three'])),
-                      mask=[0,0,1],dtype='|S8')
-        ddtype = [('a',int),('b',float),('c','|S8')]
-        mrec = fromarrays([_a,_b,_c], dtype=ddtype,
-                          fill_value=(asbytes('99999'),asbytes('99999.'),
+        _a = ma.array([1, 2, 3], mask=[0, 0, 1], dtype=int)
+        _b = ma.array([1.1, 2.2, 3.3], mask=[0, 0, 1], dtype=float)
+        _c = ma.array(list(map(asbytes, ['one', 'two', 'three'])),
+                      mask=[0, 0, 1], dtype='|S8')
+        ddtype = [('a', int), ('b', float), ('c', '|S8')]
+        mrec = fromarrays([_a, _b, _c], dtype=ddtype,
+                          fill_value=(asbytes('99999'), asbytes('99999.'),
                                       asbytes('N/A')))
-        nrec = recfromarrays((_a._data,_b._data,_c._data), dtype=ddtype)
+        nrec = recfromarrays((_a._data, _b._data, _c._data), dtype=ddtype)
         self.data = (mrec, nrec, ddtype)
 
     def test_fromarrays(self):
-        _a = ma.array([1,2,3],mask=[0,0,1],dtype=int)
-        _b = ma.array([1.1,2.2,3.3],mask=[0,0,1],dtype=float)
-        _c = ma.array(['one','two','three'],mask=[0,0,1],dtype='|S8')
+        _a = ma.array([1, 2, 3], mask=[0, 0, 1], dtype=int)
+        _b = ma.array([1.1, 2.2, 3.3], mask=[0, 0, 1], dtype=float)
+        _c = ma.array(['one', 'two', 'three'], mask=[0, 0, 1], dtype='|S8')
         (mrec, nrec, _) = self.data
-        for (f,l) in zip(('a','b','c'),(_a,_b,_c)):
-            assert_equal(getattr(mrec,f)._mask, l._mask)
+        for (f, l) in zip(('a', 'b', 'c'), (_a, _b, _c)):
+            assert_equal(getattr(mrec, f)._mask, l._mask)
         # One record only
-        _x = ma.array([1,1.1,'one'], mask=[1,0,0],)
+        _x = ma.array([1, 1.1, 'one'], mask=[1, 0, 0],)
         assert_equal_records(fromarrays(_x, dtype=mrec.dtype), mrec[0])
 
 
@@ -431,7 +431,7 @@ class TestMRecordsImport(TestCase):
                   (0, ' ', 0.40000000596046448, 0)]
         pa = recfromrecords(palist, names='c1, c2, c3, c4')
         mpa = fromrecords(palist, names='c1, c2, c3, c4')
-        assert_equal_records(pa,mpa)
+        assert_equal_records(pa, mpa)
         #.....
         _mrec = fromrecords(nrec)
         assert_equal(_mrec.dtype, mrec.dtype)
@@ -439,9 +439,9 @@ class TestMRecordsImport(TestCase):
             assert_equal(getattr(_mrec, field), getattr(mrec._data, field))
         #
         _mrec = fromrecords(nrec.tolist(), names='c1,c2,c3')
-        assert_equal(_mrec.dtype, [('c1',int),('c2',float),('c3','|S5')])
-        for (f,n) in zip(('c1','c2','c3'), ('a','b','c')):
-            assert_equal(getattr(_mrec,f), getattr(mrec._data, n))
+        assert_equal(_mrec.dtype, [('c1', int), ('c2', float), ('c3', '|S5')])
+        for (f, n) in zip(('c1', 'c2', 'c3'), ('a', 'b', 'c')):
+            assert_equal(getattr(_mrec, f), getattr(mrec._data, n))
         #
         _mrec = fromrecords(mrec)
         assert_equal(_mrec.dtype, mrec.dtype)
@@ -452,13 +452,13 @@ class TestMRecordsImport(TestCase):
         "Tests construction from records w/ mask."
         (mrec, nrec, ddtype) = self.data
         #
-        _mrec = fromrecords(nrec.tolist(), dtype=ddtype, mask=[0,1,0,])
+        _mrec = fromrecords(nrec.tolist(), dtype=ddtype, mask=[0, 1, 0,])
         assert_equal_records(_mrec._data, mrec._data)
-        assert_equal(_mrec._mask.tolist(), [(0,0,0),(1,1,1),(0,0,0)])
+        assert_equal(_mrec._mask.tolist(), [(0, 0, 0), (1, 1, 1), (0, 0, 0)])
         #
         _mrec = fromrecords(nrec.tolist(), dtype=ddtype, mask=True)
         assert_equal_records(_mrec._data, mrec._data)
-        assert_equal(_mrec._mask.tolist(), [(1,1,1),(1,1,1),(1,1,1)])
+        assert_equal(_mrec._mask.tolist(), [(1, 1, 1), (1, 1, 1), (1, 1, 1)])
         #
         _mrec = fromrecords(nrec.tolist(), dtype=ddtype, mask=mrec._mask)
         assert_equal_records(_mrec._data, mrec._data)
@@ -480,21 +480,21 @@ class TestMRecordsImport(TestCase):
 """)
         import os
         import tempfile
-        (tmp_fd,tmp_fl) = tempfile.mkstemp()
+        (tmp_fd, tmp_fl) = tempfile.mkstemp()
         os.write(tmp_fd, fcontent)
         os.close(tmp_fd)
-        mrectxt = fromtextfile(tmp_fl, delimitor=',',varnames='ABCDEFG')
+        mrectxt = fromtextfile(tmp_fl, delimitor=',', varnames='ABCDEFG')
         os.remove(tmp_fl)
         #
         self.assertTrue(isinstance(mrectxt, MaskedRecords))
-        assert_equal(mrectxt.F, [1,1,1,1])
-        assert_equal(mrectxt.E._mask, [1,1,1,1])
-        assert_equal(mrectxt.C, [1,2,3.e+5,-1e-10])
+        assert_equal(mrectxt.F, [1, 1, 1, 1])
+        assert_equal(mrectxt.E._mask, [1, 1, 1, 1])
+        assert_equal(mrectxt.C, [1, 2, 3.e+5, -1e-10])
 
     def test_addfield(self):
         "Tests addfield"
         (mrec, nrec, ddtype) = self.data
-        (d,m) = ([100,200,300], [1,0,0])
+        (d, m) = ([100, 200, 300], [1, 0, 0])
         mrec = addfield(mrec, ma.array(d, mask=m))
         assert_equal(mrec.f3, d)
         assert_equal(mrec.f3._mask, m)
@@ -505,7 +505,7 @@ def test_record_array_with_object_field():
     Trac #1839
     """
     y = ma.masked_array(
-        [(1,'2'), (3, '4')],
+        [(1, '2'), (3, '4')],
         mask=[(0, 0), (0, 1)],
         dtype=[('a', int), ('b', np.object)])
     x = y[1]
diff --git a/numpy/ma/tests/test_old_ma.py b/numpy/ma/tests/test_old_ma.py
index 50247df37..d0864436c 100644
--- a/numpy/ma/tests/test_old_ma.py
+++ b/numpy/ma/tests/test_old_ma.py
@@ -26,7 +26,7 @@ class TestMa(TestCase):
         y = np.array([5., 0., 3., 2., -1., -4., 0., -10., 10., 1., 0., 3.])
         a10 = 10.
         m1 = [1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0]
-        m2 = [0, 0, 1, 0, 0, 1, 1, 0, 0, 0 , 0, 1]
+        m2 = [0, 0, 1, 0, 0, 1, 1, 0, 0, 0, 0, 1]
         xm = array(x, mask=m1)
         ym = array(y, mask=m2)
         z = np.array([-.5, 0., .5, .8])
@@ -44,8 +44,8 @@ class TestMa(TestCase):
         self.assertEqual(shape(xm), s)
         self.assertEqual(xm.shape, s)
         self.assertEqual(xm.dtype, x.dtype)
-        self.assertEqual(xm.size , reduce(lambda x, y:x * y, s))
-        self.assertEqual(count(xm) , len(m1) - reduce(lambda x, y:x + y, m1))
+        self.assertEqual(xm.size, reduce(lambda x, y:x * y, s))
+        self.assertEqual(count(xm), len(m1) - reduce(lambda x, y:x + y, m1))
         self.assertTrue(eq(xm, xf))
         self.assertTrue(eq(filled(xm, 1.e20), xf))
         self.assertTrue(eq(x, xm))
@@ -64,8 +64,8 @@ class TestMa(TestCase):
             self.assertTrue(isMaskedArray(xm))
             self.assertEqual(shape(xm), s)
             self.assertEqual(xm.shape, s)
-            self.assertEqual(xm.size , reduce(lambda x, y:x * y, s))
-            self.assertEqual(count(xm) , len(m1) - reduce(lambda x, y:x + y, m1))
+            self.assertEqual(xm.size, reduce(lambda x, y:x * y, s))
+            self.assertEqual(count(xm), len(m1) - reduce(lambda x, y:x + y, m1))
             self.assertTrue(eq(xm, xf))
             self.assertTrue(eq(filled(xm, 1.e20), xf))
             self.assertTrue(eq(x, xm))
@@ -333,7 +333,7 @@ class TestMa(TestCase):
         c = x >= 8
         assert_(count(where(c, masked, masked)) == 0)
         assert_(shape(where(c, masked, masked)) == c.shape)
-        z = where(c , x, masked)
+        z = where(c, x, masked)
         assert_(z.dtype is x.dtype)
         assert_(z[3] is masked)
         assert_(z[4] is masked)
@@ -341,7 +341,7 @@ class TestMa(TestCase):
         assert_(z[8] is not masked)
         assert_(z[9] is not masked)
         assert_(eq(x, z))
-        z = where(c , masked, x)
+        z = where(c, masked, x)
         assert_(z.dtype is x.dtype)
         assert_(z[3] is masked)
         assert_(z[4] is not masked)
@@ -574,12 +574,12 @@ class TestMa(TestCase):
         a = arange(6)
         b = arange(6) * 3
         r1, w1 = average([[a, b], [b, a]], axis=1, returned=1)
-        self.assertEqual(shape(r1) , shape(w1))
-        self.assertEqual(r1.shape , w1.shape)
+        self.assertEqual(shape(r1), shape(w1))
+        self.assertEqual(r1.shape, w1.shape)
         r2, w2 = average(ones((2, 2, 3)), axis=0, weights=[3, 1], returned=1)
-        self.assertEqual(shape(w2) , shape(r2))
+        self.assertEqual(shape(w2), shape(r2))
         r2, w2 = average(ones((2, 2, 3)), returned=1)
-        self.assertEqual(shape(w2) , shape(r2))
+        self.assertEqual(shape(w2), shape(r2))
         r2, w2 = average(ones((2, 2, 3)), weights=ones((2, 2, 3)), returned=1)
         self.assertTrue(shape(w2) == shape(r2))
         a2d = array([[1, 2], [0, 4]], float)
@@ -722,10 +722,10 @@ class TestUfuncs(TestCase):
 class TestArrayMethods(TestCase):
 
     def setUp(self):
-        x = np.array([ 8.375, 7.545, 8.828, 8.5  , 1.757, 5.928,
-                          8.43 , 7.78 , 9.865, 5.878, 8.979, 4.732,
+        x = np.array([ 8.375, 7.545, 8.828, 8.5, 1.757, 5.928,
+                          8.43, 7.78, 9.865, 5.878, 8.979, 4.732,
                           3.012, 6.022, 5.095, 3.116, 5.238, 3.957,
-                          6.04 , 9.63 , 7.712, 3.382, 4.489, 6.479,
+                          6.04, 9.63, 7.712, 3.382, 4.489, 6.479,
                           7.189, 9.645, 5.395, 4.961, 9.894, 2.893,
                           7.357, 9.828, 6.272, 3.758, 6.693, 0.993])
         X = x.reshape(6, 6)
diff --git a/numpy/ma/tests/test_regression.py b/numpy/ma/tests/test_regression.py
index eb301aa05..1274833b2 100644
--- a/numpy/ma/tests/test_regression.py
+++ b/numpy/ma/tests/test_regression.py
@@ -10,32 +10,32 @@ rlevel = 1
 class TestRegression(TestCase):
     def test_masked_array_create(self,level=rlevel):
         """Ticket #17"""
-        x = np.ma.masked_array([0,1,2,3,0,4,5,6],mask=[0,0,0,1,1,1,0,0])
-        assert_array_equal(np.ma.nonzero(x),[[1,2,6,7]])
+        x = np.ma.masked_array([0, 1, 2, 3, 0, 4, 5, 6], mask=[0, 0, 0, 1, 1, 1, 0, 0])
+        assert_array_equal(np.ma.nonzero(x), [[1, 2, 6, 7]])
 
     def test_masked_array(self,level=rlevel):
         """Ticket #61"""
-        x = np.ma.array(1,mask=[1])
+        x = np.ma.array(1, mask=[1])
 
     def test_mem_masked_where(self,level=rlevel):
         """Ticket #62"""
         from numpy.ma import masked_where, MaskType
-        a = np.zeros((1,1))
+        a = np.zeros((1, 1))
         b = np.zeros(a.shape, MaskType)
-        c = masked_where(b,a)
+        c = masked_where(b, a)
         a-c
 
     def test_masked_array_multiply(self,level=rlevel):
         """Ticket #254"""
-        a = np.ma.zeros((4,1))
-        a[2,0] = np.ma.masked
-        b = np.zeros((4,2))
+        a = np.ma.zeros((4, 1))
+        a[2, 0] = np.ma.masked
+        b = np.zeros((4, 2))
         a*b
         b*a
 
     def test_masked_array_repeat(self, level=rlevel):
         """Ticket #271"""
-        np.ma.array([1],mask=False).repeat(10)
+        np.ma.array([1], mask=False).repeat(10)
 
     def test_masked_array_repr_unicode(self):
         """Ticket #1256"""
@@ -63,8 +63,8 @@ class TestRegression(TestCase):
 
     def test_ddof_corrcoef(self):
         # See gh-3336
-        x = np.ma.masked_equal([1,2,3,4,5], 4)
-        y = np.array([2,2.5,3.1,3,5])
+        x = np.ma.masked_equal([1, 2, 3, 4, 5], 4)
+        y = np.array([2, 2.5, 3.1, 3, 5])
         r0 = np.ma.corrcoef(x, y, ddof=0)
         r1 = np.ma.corrcoef(x, y, ddof=1)
         # ddof should not have an effect (it gets cancelled out)
diff --git a/numpy/ma/tests/test_subclassing.py b/numpy/ma/tests/test_subclassing.py
index 7014246d4..19058fec2 100644
--- a/numpy/ma/tests/test_subclassing.py
+++ b/numpy/ma/tests/test_subclassing.py
@@ -26,23 +26,23 @@ class SubArray(np.ndarray):
         x.info = info
         return x
     def __array_finalize__(self, obj):
-        self.info = getattr(obj,'info',{})
+        self.info = getattr(obj, 'info', {})
         return
     def __add__(self, other):
         result = np.ndarray.__add__(self, other)
-        result.info.update({'added':result.info.pop('added',0)+1})
+        result.info.update({'added':result.info.pop('added', 0)+1})
         return result
 
 subarray = SubArray
 
-class MSubArray(SubArray,MaskedArray):
+class MSubArray(SubArray, MaskedArray):
     def __new__(cls, data, info={}, mask=nomask):
         subarr = SubArray(data, info)
         _data = MaskedArray.__new__(cls, data=subarr, mask=mask)
         _data.info = subarr.info
         return _data
-    def __array_finalize__(self,obj):
-        MaskedArray.__array_finalize__(self,obj)
+    def __array_finalize__(self, obj):
+        MaskedArray.__array_finalize__(self, obj)
         SubArray.__array_finalize__(self, obj)
         return
     def _get_series(self):
@@ -58,9 +58,9 @@ class MMatrix(MaskedArray, np.matrix,):
         mat = np.matrix(data)
         _data = MaskedArray.__new__(cls, data=mat, mask=mask)
         return _data
-    def __array_finalize__(self,obj):
+    def __array_finalize__(self, obj):
         np.matrix.__array_finalize__(self, obj)
-        MaskedArray.__array_finalize__(self,obj)
+        MaskedArray.__array_finalize__(self, obj)
         return
     def _get_series(self):
         _view = self.view(MaskedArray)
@@ -81,7 +81,7 @@ class TestSubclassing(TestCase):
     def test_data_subclassing(self):
         "Tests whether the subclass is kept."
         x = np.arange(5)
-        m = [0,0,1,0,0]
+        m = [0, 0, 1, 0, 0]
         xsub = SubArray(x)
         xmsub = masked_array(xsub, mask=m)
         self.assertTrue(isinstance(xmsub, MaskedArray))
@@ -104,21 +104,21 @@ class TestSubclassing(TestCase):
         "Tests masked_binary_operation"
         (x, mx) = self.data
         # Result should be a mmatrix
-        self.assertTrue(isinstance(add(mx,mx), mmatrix))
-        self.assertTrue(isinstance(add(mx,x), mmatrix))
+        self.assertTrue(isinstance(add(mx, mx), mmatrix))
+        self.assertTrue(isinstance(add(mx, x), mmatrix))
         # Result should work
-        assert_equal(add(mx,x), mx+x)
-        self.assertTrue(isinstance(add(mx,mx)._data, np.matrix))
-        self.assertTrue(isinstance(add.outer(mx,mx), mmatrix))
-        self.assertTrue(isinstance(hypot(mx,mx), mmatrix))
-        self.assertTrue(isinstance(hypot(mx,x), mmatrix))
+        assert_equal(add(mx, x), mx+x)
+        self.assertTrue(isinstance(add(mx, mx)._data, np.matrix))
+        self.assertTrue(isinstance(add.outer(mx, mx), mmatrix))
+        self.assertTrue(isinstance(hypot(mx, mx), mmatrix))
+        self.assertTrue(isinstance(hypot(mx, x), mmatrix))
 
     def test_masked_binary_operations2(self):
         "Tests domained_masked_binary_operation"
         (x, mx) = self.data
         xmx = masked_array(mx.data.__array__(), mask=mx.mask)
-        self.assertTrue(isinstance(divide(mx,mx), mmatrix))
-        self.assertTrue(isinstance(divide(mx,x), mmatrix))
+        self.assertTrue(isinstance(divide(mx, mx), mmatrix))
+        self.assertTrue(isinstance(divide(mx, x), mmatrix))
         assert_equal(divide(mx, mx), divide(xmx, xmx))
 
     def test_attributepropagation(self):
@@ -127,7 +127,7 @@ class TestSubclassing(TestCase):
         ym = msubarray(x)
         #
         z = (my+1)
-        self.assertTrue(isinstance(z,MaskedArray))
+        self.assertTrue(isinstance(z, MaskedArray))
         self.assertTrue(not isinstance(z, MSubArray))
         self.assertTrue(isinstance(z._data, SubArray))
         assert_equal(z._data.info, {})
@@ -138,10 +138,10 @@ class TestSubclassing(TestCase):
         self.assertTrue(isinstance(z._data, SubArray))
         self.assertTrue(z._data.info['added'] > 0)
         #
-        ym._set_mask([1,0,0,0,1])
-        assert_equal(ym._mask, [1,0,0,0,1])
-        ym._series._set_mask([0,0,0,0,1])
-        assert_equal(ym._mask, [0,0,0,0,1])
+        ym._set_mask([1, 0, 0, 0, 1])
+        assert_equal(ym._mask, [1, 0, 0, 0, 1])
+        ym._series._set_mask([0, 0, 0, 0, 1])
+        assert_equal(ym._mask, [0, 0, 0, 0, 1])
         #
         xsub = subarray(x, info={'name':'x'})
         mxsub = masked_array(xsub)
@@ -151,8 +151,8 @@ class TestSubclassing(TestCase):
     def test_subclasspreservation(self):
         "Checks that masked_array(...,subok=True) preserves the class."
         x = np.arange(5)
-        m = [0,0,1,0,0]
-        xinfo = [(i,j) for (i,j) in zip(x,m)]
+        m = [0, 0, 1, 0, 0]
+        xinfo = [(i, j) for (i, j) in zip(x, m)]
         xsub = MSubArray(x, mask=m, info={'xsub':xinfo})
         #
         mxsub = masked_array(xsub, subok=False)
diff --git a/numpy/ma/timer_comparison.py b/numpy/ma/timer_comparison.py
index 350412b85..b1c056cfc 100644
--- a/numpy/ma/timer_comparison.py
+++ b/numpy/ma/timer_comparison.py
@@ -83,7 +83,7 @@ class moduletester(object):
                                     header=header,
                                     names=('x', 'y'))
                 assert cond, msg
-            val = comparison(x,y)
+            val = comparison(x, y)
             if m is not self.nomask and fill_value:
                 val = self.masked_array(val, mask=m)
             if isinstance(val, bool):
@@ -112,45 +112,45 @@ class moduletester(object):
 
     def test_0(self):
         "Tests creation"
-        x = np.array([1.,1.,1.,-2., pi/2.0, 4., 5., -10., 10., 1., 2., 3.])
+        x = np.array([1., 1., 1., -2., pi/2.0, 4., 5., -10., 10., 1., 2., 3.])
         m = [1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0]
         xm = self.masked_array(x, mask=m)
         xm[0]
 
     def test_1(self):
         "Tests creation"
-        x = np.array([1.,1.,1.,-2., pi/2.0, 4., 5., -10., 10., 1., 2., 3.])
-        y = np.array([5.,0.,3., 2., -1., -4., 0., -10., 10., 1., 0., 3.])
+        x = np.array([1., 1., 1., -2., pi/2.0, 4., 5., -10., 10., 1., 2., 3.])
+        y = np.array([5., 0., 3., 2., -1., -4., 0., -10., 10., 1., 0., 3.])
         a10 = 10.
         m1 = [1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0]
-        m2 = [0, 0, 1, 0, 0, 1, 1, 0, 0, 0 ,0, 1]
+        m2 = [0, 0, 1, 0, 0, 1, 1, 0, 0, 0, 0, 1]
         xm = self.masked_array(x, mask=m1)
         ym = self.masked_array(y, mask=m2)
         z = np.array([-.5, 0., .5, .8])
-        zm = self.masked_array(z, mask=[0,1,0,0])
+        zm = self.masked_array(z, mask=[0, 1, 0, 0])
         xf = np.where(m1, 1.e+20, x)
         xm.set_fill_value(1.e+20)
 
         assert((xm-ym).filled(0).any())
         #fail_if_equal(xm.mask.astype(int_), ym.mask.astype(int_))
         s = x.shape
-        assert(xm.size == reduce(lambda x,y:x*y, s))
-        assert(self.count(xm) == len(m1) - reduce(lambda x,y:x+y, m1))
+        assert(xm.size == reduce(lambda x, y:x*y, s))
+        assert(self.count(xm) == len(m1) - reduce(lambda x, y:x+y, m1))
 
-        for s in [(4,3), (6,2)]:
+        for s in [(4, 3), (6, 2)]:
             x.shape = s
             y.shape = s
             xm.shape = s
             ym.shape = s
             xf.shape = s
 
-            assert(self.count(xm) == len(m1) - reduce(lambda x,y:x+y, m1))
+            assert(self.count(xm) == len(m1) - reduce(lambda x, y:x+y, m1))
 
     def test_2(self):
         "Tests conversions and indexing"
-        x1 = np.array([1,2,4,3])
-        x2 = self.array(x1, mask=[1,0,0,0])
-        x3 = self.array(x1, mask=[0,1,0,1])
+        x1 = np.array([1, 2, 4, 3])
+        x2 = self.array(x1, mask=[1, 0, 0, 0])
+        x3 = self.array(x1, mask=[0, 1, 0, 1])
         x4 = self.array(x1)
     # test conversion to strings
         junk, garbage = str(x2), repr(x2)
@@ -164,7 +164,7 @@ class moduletester(object):
 #        assert self.allequal(x1[1:], x3[1:])
         x1[2] = 9
         x2[2] = 9
-        self.assert_array_equal(x1,x2)
+        self.assert_array_equal(x1, x2)
         x1[1:3] = 99
         x2[1:3] = 99
 #        assert self.allequal(x1,x2)
@@ -175,22 +175,22 @@ class moduletester(object):
         x2[:] = x1
         x2[1] = self.masked
 #        assert self.allequal(self.getmask(x2),self.array([0,1,0,0]))
-        x3[:] = self.masked_array([1,2,3,4],[0,1,1,0])
+        x3[:] = self.masked_array([1, 2, 3, 4], [0, 1, 1, 0])
 #        assert self.allequal(self.getmask(x3), self.array([0,1,1,0]))
-        x4[:] = self.masked_array([1,2,3,4],[0,1,1,0])
+        x4[:] = self.masked_array([1, 2, 3, 4], [0, 1, 1, 0])
 #        assert self.allequal(self.getmask(x4), self.array([0,1,1,0]))
 #        assert self.allequal(x4, self.array([1,2,3,4]))
         x1 = np.arange(5)*1.0
         x2 = self.masked_values(x1, 3.0)
 #        assert self.allequal(x1,x2)
 #        assert self.allequal(self.array([0,0,0,1,0], self.MaskType), x2.mask)
-        x1 = self.array([1,'hello',2,3],object)
-        x2 = np.array([1,'hello',2,3],object)
+        x1 = self.array([1, 'hello', 2, 3], object)
+        x2 = np.array([1, 'hello', 2, 3], object)
         s1 = x1[1]
         s2 = x2[1]
         assert x1[1:1].shape == (0,)
         # Tests copy-size
-        n = [0,0,1,0,0]
+        n = [0, 0, 1, 0, 0]
         m = self.make_mask(n)
         m2 = self.make_mask(m)
         assert(m is m2)
@@ -203,16 +203,16 @@ class moduletester(object):
         x4 = self.arange(4)
         x4[2] = self.masked
         y4 = self.resize(x4, (8,))
-        assert self.allequal(self.concatenate([x4,x4]), y4)
-        assert self.allequal(self.getmask(y4),[0,0,1,0,0,0,1,0])
-        y5 = self.repeat(x4, (2,2,2,2), axis=0)
-        self.assert_array_equal(y5, [0,0,1,1,2,2,3,3])
+        assert self.allequal(self.concatenate([x4, x4]), y4)
+        assert self.allequal(self.getmask(y4), [0, 0, 1, 0, 0, 0, 1, 0])
+        y5 = self.repeat(x4, (2, 2, 2, 2), axis=0)
+        self.assert_array_equal(y5, [0, 0, 1, 1, 2, 2, 3, 3])
         y6 = self.repeat(x4, 2, axis=0)
         assert self.allequal(y5, y6)
-        y7 = x4.repeat((2,2,2,2), axis=0)
-        assert self.allequal(y5,y7)
-        y8 = x4.repeat(2,0)
-        assert self.allequal(y5,y8)
+        y7 = x4.repeat((2, 2, 2, 2), axis=0)
+        assert self.allequal(y5, y7)
+        y8 = x4.repeat(2, 0)
+        assert self.allequal(y5, y8)
 
     #----------------------------------
     def test_4(self):
@@ -220,17 +220,17 @@ class moduletester(object):
         x = self.arange(24)
         y = np.arange(24)
         x[5:6] = self.masked
-        x = x.reshape(2,3,4)
-        y = y.reshape(2,3,4)
-        assert self.allequal(np.transpose(y,(2,0,1)), self.transpose(x,(2,0,1)))
-        assert self.allequal(np.take(y, (2,0,1), 1), self.take(x, (2,0,1), 1))
-        assert self.allequal(np.inner(self.filled(x,0), self.filled(y,0)),
+        x = x.reshape(2, 3, 4)
+        y = y.reshape(2, 3, 4)
+        assert self.allequal(np.transpose(y, (2, 0, 1)), self.transpose(x, (2, 0, 1)))
+        assert self.allequal(np.take(y, (2, 0, 1), 1), self.take(x, (2, 0, 1), 1))
+        assert self.allequal(np.inner(self.filled(x, 0), self.filled(y, 0)),
                             self.inner(x, y))
-        assert self.allequal(np.outer(self.filled(x,0), self.filled(y,0)),
+        assert self.allequal(np.outer(self.filled(x, 0), self.filled(y, 0)),
                             self.outer(x, y))
         y = self.array(['abc', 1, 'def', 2, 3], object)
         y[2] = self.masked
-        t = self.take(y,[0,3,4])
+        t = self.take(y, [0, 3, 4])
         assert t[0] == 'abc'
         assert t[1] == 2
         assert t[2] == 3
@@ -300,9 +300,9 @@ class moduletester(object):
         a[-1] = self.masked
         x += a
         xm += a
-        assert self.allequal(x,y+a)
-        assert self.allequal(xm,y+a)
-        assert self.allequal(xm.mask, self.mask_or(m,a.mask))
+        assert self.allequal(x, y+a)
+        assert self.allequal(xm, y+a)
+        assert self.allequal(xm.mask, self.mask_or(m, a.mask))
 
         x = self.arange(10, dtype=float_)
         xm = self.arange(10, dtype=float_)
@@ -312,9 +312,9 @@ class moduletester(object):
         a[-1] = self.masked
         x -= a
         xm -= a
-        assert self.allequal(x,y-a)
-        assert self.allequal(xm,y-a)
-        assert self.allequal(xm.mask, self.mask_or(m,a.mask))
+        assert self.allequal(x, y-a)
+        assert self.allequal(xm, y-a)
+        assert self.allequal(xm.mask, self.mask_or(m, a.mask))
 
         x = self.arange(10, dtype=float_)
         xm = self.arange(10, dtype=float_)
@@ -324,9 +324,9 @@ class moduletester(object):
         a[-1] = self.masked
         x *= a
         xm *= a
-        assert self.allequal(x,y*a)
-        assert self.allequal(xm,y*a)
-        assert self.allequal(xm.mask, self.mask_or(m,a.mask))
+        assert self.allequal(x, y*a)
+        assert self.allequal(xm, y*a)
+        assert self.allequal(xm.mask, self.mask_or(m, a.mask))
 
         x = self.arange(10, dtype=float_)
         xm = self.arange(10, dtype=float_)
@@ -340,8 +340,8 @@ class moduletester(object):
     #----------------------------------
     def test_7(self):
         "Tests ufunc"
-        d = (self.array([1.0, 0, -1, pi/2]*2, mask=[0,1]+[0]*6),
-             self.array([1.0, 0, -1, pi/2]*2, mask=[1,0]+[0]*6),)
+        d = (self.array([1.0, 0, -1, pi/2]*2, mask=[0, 1]+[0]*6),
+             self.array([1.0, 0, -1, pi/2]*2, mask=[1, 0]+[0]*6),)
         for f in ['sqrt', 'log', 'log10', 'exp', 'conjugate',
 #                  'sin', 'cos', 'tan',
 #                  'arcsin', 'arccos', 'arctan',
@@ -376,55 +376,55 @@ class moduletester(object):
     #----------------------------------
     def test_99(self):
         # test average
-        ott = self.array([0.,1.,2.,3.], mask=[1,0,0,0])
-        self.assert_array_equal(2.0, self.average(ott,axis=0))
+        ott = self.array([0., 1., 2., 3.], mask=[1, 0, 0, 0])
+        self.assert_array_equal(2.0, self.average(ott, axis=0))
         self.assert_array_equal(2.0, self.average(ott, weights=[1., 1., 2., 1.]))
-        result, wts = self.average(ott, weights=[1.,1.,2.,1.], returned=1)
+        result, wts = self.average(ott, weights=[1., 1., 2., 1.], returned=1)
         self.assert_array_equal(2.0, result)
         assert(wts == 4.0)
         ott[:] = self.masked
-        assert(self.average(ott,axis=0) is self.masked)
-        ott = self.array([0.,1.,2.,3.], mask=[1,0,0,0])
-        ott = ott.reshape(2,2)
-        ott[:,1] = self.masked
-        self.assert_array_equal(self.average(ott,axis=0), [2.0, 0.0])
-        assert(self.average(ott,axis=1)[0] is self.masked)
-        self.assert_array_equal([2.,0.], self.average(ott, axis=0))
+        assert(self.average(ott, axis=0) is self.masked)
+        ott = self.array([0., 1., 2., 3.], mask=[1, 0, 0, 0])
+        ott = ott.reshape(2, 2)
+        ott[:, 1] = self.masked
+        self.assert_array_equal(self.average(ott, axis=0), [2.0, 0.0])
+        assert(self.average(ott, axis=1)[0] is self.masked)
+        self.assert_array_equal([2., 0.], self.average(ott, axis=0))
         result, wts = self.average(ott, axis=0, returned=1)
         self.assert_array_equal(wts, [1., 0.])
-        w1 = [0,1,1,1,1,0]
-        w2 = [[0,1,1,1,1,0],[1,0,0,0,0,1]]
+        w1 = [0, 1, 1, 1, 1, 0]
+        w2 = [[0, 1, 1, 1, 1, 0], [1, 0, 0, 0, 0, 1]]
         x = self.arange(6)
         self.assert_array_equal(self.average(x, axis=0), 2.5)
         self.assert_array_equal(self.average(x, axis=0, weights=w1), 2.5)
         y = self.array([self.arange(6), 2.0*self.arange(6)])
         self.assert_array_equal(self.average(y, None), np.add.reduce(np.arange(6))*3./12.)
         self.assert_array_equal(self.average(y, axis=0), np.arange(6) * 3./2.)
-        self.assert_array_equal(self.average(y, axis=1), [self.average(x,axis=0), self.average(x,axis=0) * 2.0])
+        self.assert_array_equal(self.average(y, axis=1), [self.average(x, axis=0), self.average(x, axis=0) * 2.0])
         self.assert_array_equal(self.average(y, None, weights=w2), 20./6.)
-        self.assert_array_equal(self.average(y, axis=0, weights=w2), [0.,1.,2.,3.,4.,10.])
-        self.assert_array_equal(self.average(y, axis=1), [self.average(x,axis=0), self.average(x,axis=0) * 2.0])
+        self.assert_array_equal(self.average(y, axis=0, weights=w2), [0., 1., 2., 3., 4., 10.])
+        self.assert_array_equal(self.average(y, axis=1), [self.average(x, axis=0), self.average(x, axis=0) * 2.0])
         m1 = self.zeros(6)
-        m2 = [0,0,1,1,0,0]
-        m3 = [[0,0,1,1,0,0],[0,1,1,1,1,0]]
+        m2 = [0, 0, 1, 1, 0, 0]
+        m3 = [[0, 0, 1, 1, 0, 0], [0, 1, 1, 1, 1, 0]]
         m4 = self.ones(6)
         m5 = [0, 1, 1, 1, 1, 1]
-        self.assert_array_equal(self.average(self.masked_array(x, m1),axis=0), 2.5)
-        self.assert_array_equal(self.average(self.masked_array(x, m2),axis=0), 2.5)
+        self.assert_array_equal(self.average(self.masked_array(x, m1), axis=0), 2.5)
+        self.assert_array_equal(self.average(self.masked_array(x, m2), axis=0), 2.5)
     #    assert(self.average(masked_array(x, m4),axis=0) is masked)
-        self.assert_array_equal(self.average(self.masked_array(x, m5),axis=0), 0.0)
-        self.assert_array_equal(self.count(self.average(self.masked_array(x, m4),axis=0)), 0)
+        self.assert_array_equal(self.average(self.masked_array(x, m5), axis=0), 0.0)
+        self.assert_array_equal(self.count(self.average(self.masked_array(x, m4), axis=0)), 0)
         z = self.masked_array(y, m3)
         self.assert_array_equal(self.average(z, None), 20./6.)
-        self.assert_array_equal(self.average(z, axis=0), [0.,1.,99.,99.,4.0, 7.5])
+        self.assert_array_equal(self.average(z, axis=0), [0., 1., 99., 99., 4.0, 7.5])
         self.assert_array_equal(self.average(z, axis=1), [2.5, 5.0])
-        self.assert_array_equal(self.average(z,axis=0, weights=w2), [0.,1., 99., 99., 4.0, 10.0])
+        self.assert_array_equal(self.average(z, axis=0, weights=w2), [0., 1., 99., 99., 4.0, 10.0])
     #------------------------
     def test_A(self):
         x = self.arange(24)
         y = np.arange(24)
         x[5:6] = self.masked
-        x = x.reshape(2,3,4)
+        x = x.reshape(2, 3, 4)
 
 
 ################################################################################
@@ -441,7 +441,7 @@ if __name__ == '__main__':
     (nrepeat, nloop) = (10, 10)
 
     if 1:
-        for i in range(1,8):
+        for i in range(1, 8):
             func = 'tester.test_%i()' % i
 #            new = timeit.Timer(func, setup_new).repeat(nrepeat, nloop*10)
             cur = timeit.Timer(func, setup_cur).repeat(nrepeat, nloop*10)