Addressed review comments

Author: ssche

pandas/core/algorithms.py

@@ -2061,32 +2061,32 @@ def sort_tuples(values):
         def cmp_func(index_x, index_y):
             x = values[index_x]
             y = values[index_y]
+            # shortcut loop in case both tuples are the same
             if x == y:
                 return 0
-            len_x = len(x)
-            len_y = len(y)
-            for i in range(max(len_x, len_y)):
+            # lexicographic sorting
+            for i in range(max(len(x), len(y))):
                 # check if the tuples have different lengths (shorter tuples
                 # first)
-                if i >= len_x:
+                if i >= len(x):
                     return -1
-                if i >= len_y:
+                if i >= len(y):
                     return +1
-                x_i_na = isna(x[i])
-                y_i_na = isna(y[i])
+                x_is_na = isna(x[i])
+                y_is_na = isna(y[i])
                 # values are the same -> resolve tie with next element
-                if (x_i_na and y_i_na) or (x[i] == y[i]):
+                if (x_is_na and y_is_na) or (x[i] == y[i]):
                     continue
-                # check for nan values (sort nan to the end which is consistent
-                # with numpy
-                if x_i_na and not y_i_na:
+                # check for nan values (sort nan to the end)
+                if x_is_na and not y_is_na:
                     return +1
-                if not x_i_na and y_i_na:
+                if not x_is_na and y_is_na:
                     return -1
                 # normal greater/less than comparison
                 if x[i] < y[i]:
                     return -1
                 return +1
+            # both values are the same (should already have been caught)
             return 0
 
         ixs = np.arange(len(values))
@@ -2095,12 +2095,10 @@ def cmp_func(index_x, index_y):
 
     sorter = None
 
-    ext_arr = is_extension_array_dtype(values)
-    if not ext_arr and lib.infer_dtype(values, skipna=False) == "mixed-integer":
-        # unorderable in py3 if mixed str/int
+    is_ea = is_extension_array_dtype(values)
+    if not is_ea and lib.infer_dtype(values, skipna=False) == "mixed-integer":
         ordered = sort_mixed(values)
-    elif not ext_arr and values.size and isinstance(values[0], tuple):
-        # 1-D arrays with tuples of potentially mixed type (solves GH36562)
+    elif not is_ea and values.size and isinstance(values[0], tuple):
         ordered = sort_tuples(values)
     else:
         try:

pandas/tests/indexing/multiindex/test_multiindex.py

@@ -93,7 +93,7 @@ def test_multiindex_get_loc_list_raises(self):
             idx.get_loc([])
 
 
-def test_combine_first_with_nan_index():
+def test_combine_first_with_nan_multiindex():
     mi1 = pd.MultiIndex.from_arrays(
         [["b", "b", "c", "a", "b", np.nan], [1, 2, 3, 4, 5, 6]], names=["a", "b"]
     )
@@ -102,17 +102,19 @@ def test_combine_first_with_nan_index():
         [["a", "b", "c", "a", "b", "d"], [1, 1, 1, 1, 1, 1]], names=["a", "b"]
     )
     s = pd.Series([1, 2, 3, 4, 5, 6], index=mi2)
-    df_combined = df.combine_first(pd.DataFrame({"col": s}))
+    res = df.combine_first(pd.DataFrame({"d": s}))
     mi_expected = pd.MultiIndex.from_arrays(
         [
             ["a", "a", "a", "b", "b", "b", "b", "c", "c", "d", np.nan],
             [1, 1, 4, 1, 1, 2, 5, 1, 3, 1, 6],
         ],
         names=["a", "b"],
     )
-    assert (df_combined.index == mi_expected).all()
-    exp_col = np.asarray(
-        [1.0, 4.0, np.nan, 2.0, 5.0, np.nan, np.nan, 3.0, np.nan, 6.0, np.nan]
+    expected = pd.DataFrame(
+        {
+            "c": [np.nan, np.nan, 1, 1, 1, 1, 1, np.nan, 1, np.nan, 1],
+            "d": [1.0, 4.0, np.nan, 2.0, 5.0, np.nan, np.nan, 3.0, np.nan, 6.0, np.nan],
+        },
+        index=mi_expected,
     )
-    act_col = df_combined["col"].values
-    assert np.allclose(act_col, exp_col, rtol=0, atol=0, equal_nan=True)
+    tm.assert_frame_equal(res, expected)