Review (jreback)

pandas/tests/test_strings.py

@@ -164,27 +164,27 @@ def test_str_cat(self, box):
 
         # single array
         result = s.str.cat()
-        exp = 'aabbc'
-        assert result == exp
+        expected = 'aabbc'
+        assert result == expected
 
         result = s.str.cat(na_rep='-')
-        exp = 'aabbc-'
-        assert result == exp
+        expected = 'aabbc-'
+        assert result == expected
 
         result = s.str.cat(sep='_', na_rep='NA')
-        exp = 'a_a_b_b_c_NA'
-        assert result == exp
+        expected = 'a_a_b_b_c_NA'
+        assert result == expected
 
         t = np.array(['a', np.nan, 'b', 'd', 'foo', np.nan], dtype=object)
-        exp = box(['aa', 'a-', 'bb', 'bd', 'cfoo', '--'])
+        expected = box(['aa', 'a-', 'bb', 'bd', 'cfoo', '--'])
 
         # Series/Index with array
         result = s.str.cat(t, na_rep='-')
-        assert_series_or_index_equal(result, exp)
+        assert_series_or_index_equal(result, expected)
 
         # Series/Index with list
         result = s.str.cat(list(t), na_rep='-')
-        assert_series_or_index_equal(result, exp)
+        assert_series_or_index_equal(result, expected)
 
         # errors for incorrect lengths
         rgx = 'All arrays must be same length, except those having an index.*'
@@ -217,30 +217,30 @@ def test_str_cat_categorical(self, box, dtype_caller, dtype_target):
         s = s if box == Index else Series(s, index=s)
         t = Index(['b', 'a', 'b', 'c'], dtype=dtype_target)
 
-        exp = Index(['ab', 'aa', 'bb', 'ac'])
-        exp = exp if box == Index else Series(exp, index=s)
+        expected = Index(['ab', 'aa', 'bb', 'ac'])
+        expected = expected if box == Index else Series(expected, index=s)
 
         # Series/Index with unaligned Index
         with tm.assert_produces_warning(expected_warning=FutureWarning):
             # FutureWarning to switch to alignment by default
             result = s.str.cat(t)
-            assert_series_or_index_equal(result, exp)
+            assert_series_or_index_equal(result, expected)
 
         # Series/Index with Series having matching Index
         t = Series(t, index=s)
         result = s.str.cat(t)
-        assert_series_or_index_equal(result, exp)
+        assert_series_or_index_equal(result, expected)
 
         # Series/Index with Series.values
         result = s.str.cat(t.values)
-        assert_series_or_index_equal(result, exp)
+        assert_series_or_index_equal(result, expected)
 
         # Series/Index with Series having different Index
         t = Series(t.values, index=t)
         with tm.assert_produces_warning(expected_warning=FutureWarning):
             # FutureWarning to switch to alignment by default
             result = s.str.cat(t)
-            assert_series_or_index_equal(result, exp)
+            assert_series_or_index_equal(result, expected)
 
     @pytest.mark.parametrize('box', [Series, Index])
     def test_str_cat_mixed_inputs(self, box):
@@ -250,56 +250,57 @@ def test_str_cat_mixed_inputs(self, box):
         t = Series(['A', 'B', 'C', 'D'], index=s.values)
         d = concat([t, Series(s, index=s)], axis=1)
 
-        exp = Index(['aAa', 'bBb', 'cCc', 'dDd'])
-        exp = exp if box == Index else Series(exp.values, index=s.values)
+        expected = Index(['aAa', 'bBb', 'cCc', 'dDd'])
+        expected = expected if box == Index else Series(expected.values,
+                                                        index=s.values)
 
         # Series/Index with DataFrame
         result = s.str.cat(d)
-        assert_series_or_index_equal(result, exp)
+        assert_series_or_index_equal(result, expected)
 
         # Series/Index with two-dimensional ndarray
         result = s.str.cat(d.values)
-        assert_series_or_index_equal(result, exp)
+        assert_series_or_index_equal(result, expected)
 
         # Series/Index with list of Series
         result = s.str.cat([t, s])
-        assert_series_or_index_equal(result, exp)
+        assert_series_or_index_equal(result, expected)
 
         # Series/Index with mixed list of Series/array
         result = s.str.cat([t, s.values])
-        assert_series_or_index_equal(result, exp)
+        assert_series_or_index_equal(result, expected)
 
         # Series/Index with list of list-likes
         with tm.assert_produces_warning(expected_warning=FutureWarning):
             # nested list-likes will be deprecated
             result = s.str.cat([t.values, list(s)])
-            assert_series_or_index_equal(result, exp)
+            assert_series_or_index_equal(result, expected)
 
         # Series/Index with list of Series; different indexes
         t.index = ['b', 'c', 'd', 'a']
         with tm.assert_produces_warning(expected_warning=FutureWarning):
             # FutureWarning to switch to alignment by default
             result = s.str.cat([t, s])
-            assert_series_or_index_equal(result, exp)
+            assert_series_or_index_equal(result, expected)
 
         # Series/Index with mixed list; different indexes
         with tm.assert_produces_warning(expected_warning=FutureWarning):
             # FutureWarning to switch to alignment by default
             result = s.str.cat([t, s.values])
-            assert_series_or_index_equal(result, exp)
+            assert_series_or_index_equal(result, expected)
 
         # Series/Index with DataFrame; different indexes
         d.index = ['b', 'c', 'd', 'a']
         with tm.assert_produces_warning(expected_warning=FutureWarning):
             # FutureWarning to switch to alignment by default
             result = s.str.cat(d)
-            assert_series_or_index_equal(result, exp)
+            assert_series_or_index_equal(result, expected)
 
         # Series/Index with iterator of list-likes
         with tm.assert_produces_warning(expected_warning=FutureWarning):
             # nested list-likes will be deprecated
             result = s.str.cat(iter([t.values, list(s)]))
-            assert_series_or_index_equal(result, exp)
+            assert_series_or_index_equal(result, expected)
 
         # errors for incorrect lengths
         rgx = 'All arrays must be same length, except those having an index.*'
@@ -359,50 +360,50 @@ def test_str_cat_align_indexed(self, box, join):
         t = Series(['D', 'A', 'E', 'B'], index=['d', 'a', 'e', 'b'])
         sa, ta = s.align(t, join=join)
         # result after manual alignment of inputs
-        exp = sa.str.cat(ta, na_rep='-')
+        expected = sa.str.cat(ta, na_rep='-')
 
         if box == Index:
             s = Index(s)
             sa = Index(sa)
-            exp = Index(exp)
+            expected = Index(expected)
 
         result = s.str.cat(t, join=join, na_rep='-')
-        assert_series_or_index_equal(result, exp)
+        assert_series_or_index_equal(result, expected)
 
     @pytest.mark.parametrize('join', ['left', 'outer', 'inner', 'right'])
     def test_str_cat_align_mixed_inputs(self, join):
         s = Series(['a', 'b', 'c', 'd'])
         t = Series(['d', 'a', 'e', 'b'], index=[3, 0, 4, 1])
         d = concat([t, t], axis=1)
 
-        exp_outer = Series(['aaa', 'bbb', 'c--', 'ddd', '-ee'])
-        exp = exp_outer.loc[s.index.join(t.index, how=join)]
+        expected_outer = Series(['aaa', 'bbb', 'c--', 'ddd', '-ee'])
+        expected = expected_outer.loc[s.index.join(t.index, how=join)]
 
         # list of Series
         result = s.str.cat([t, t], join=join, na_rep='-')
-        tm.assert_series_equal(result, exp)
+        tm.assert_series_equal(result, expected)
 
         # DataFrame
         result = s.str.cat(d, join=join, na_rep='-')
-        tm.assert_series_equal(result, exp)
+        tm.assert_series_equal(result, expected)
 
         # mixed list of indexed/unindexed
         u = np.array(['A', 'B', 'C', 'D'])
-        exp_outer = Series(['aaA', 'bbB', 'c-C', 'ddD', '-e-'])
+        expected_outer = Series(['aaA', 'bbB', 'c-C', 'ddD', '-e-'])
         # joint index of rhs [t, u]; u will be forced have index of s
         rhs_idx = t.index & s.index if join == 'inner' else t.index | s.index
 
-        exp = exp_outer.loc[s.index.join(rhs_idx, how=join)]
+        expected = expected_outer.loc[s.index.join(rhs_idx, how=join)]
         result = s.str.cat([t, u], join=join, na_rep='-')
-        tm.assert_series_equal(result, exp)
+        tm.assert_series_equal(result, expected)
 
         with tm.assert_produces_warning(expected_warning=FutureWarning):
             # nested list-likes will be deprecated
             result = s.str.cat([t, list(u)], join=join, na_rep='-')
-            tm.assert_series_equal(result, exp)
+            tm.assert_series_equal(result, expected)
 
         # errors for incorrect lengths
-        rgx = 'If `others` contains arrays or lists \(or other list-likes.*'
+        rgx = r'If `others` contains arrays or lists \(or other list-likes.*'
         z = Series(['1', '2', '3']).values
 
         # unindexed object of wrong length
@@ -418,14 +419,14 @@ def test_str_cat_special_cases(self):
         t = Series(['d', 'a', 'e', 'b'], index=[3, 0, 4, 1])
 
         # iterator of elements with different types
-        exp = Series(['aaa', 'bbb', 'c-c', 'ddd', '-e-'])
+        expected = Series(['aaa', 'bbb', 'c-c', 'ddd', '-e-'])
         result = s.str.cat(iter([t, s.values]), join='outer', na_rep='-')
-        tm.assert_series_equal(result, exp)
+        tm.assert_series_equal(result, expected)
 
         # right-align with different indexes in others
-        exp = Series(['aa-', 'd-d'], index=[0, 3])
+        expected = Series(['aa-', 'd-d'], index=[0, 3])
         result = s.str.cat([t.loc[[0]], t.loc[[3]]], join='right', na_rep='-')
-        tm.assert_series_equal(result, exp)
+        tm.assert_series_equal(result, expected)
 
     def test_cat_on_filtered_index(self):
         df = DataFrame(index=MultiIndex.from_product(