fixed requested changes

Author: Anurag-Varma

doc/source/whatsnew/v3.0.0.rst

@@ -699,7 +699,7 @@ MultiIndex
 - :meth:`MultiIndex.insert` would not insert NA value correctly at unified location of index -1 (:issue:`59003`)
 - :func:`MultiIndex.get_level_values` accessing a :class:`DatetimeIndex` does not carry the frequency attribute along (:issue:`58327`, :issue:`57949`)
 - Bug in :class:`DataFrame` arithmetic operations in case of unaligned MultiIndex columns (:issue:`60498`)
-- Bug in :meth:`MultiIndex.from_tuples` causing wrong output with input of type tuples having NaN values (:issue:`60695`)
+- Bug in :meth:`MultiIndex.from_tuples` causing wrong output with input of type tuples having NaN values (:issue:`60695`, :issue:`60988`)
 
 I/O
 ^^^

pandas/core/algorithms.py

@@ -1647,6 +1647,8 @@ def map_array(
         If the function returns a tuple with more than one element
         a MultiIndex will be returned.
     """
+    from pandas import Index
+
     if na_action not in (None, "ignore"):
         msg = f"na_action must either be 'ignore' or None, {na_action} was passed"
         raise ValueError(msg)
@@ -1676,6 +1678,10 @@ def map_array(
 
             if len(mapper) == 0:
                 mapper = Series(mapper, dtype=np.float64)
+            elif isinstance(mapper, dict):
+                mapper = Series(
+                    mapper.values(), index=Index(mapper.keys(), tupleize_cols=False)
+                )
             else:
                 mapper = Series(mapper)
 

pandas/tests/indexes/multi/test_constructors.py

@@ -412,7 +412,7 @@ def test_from_tuples_with_tuple_label():
 
 @pytest.mark.parametrize(
     "keys, expected",
-    (
+    [
         ((("l1",), ("l1", "l2")), (("l1", np.nan), ("l1", "l2"))),
         (
             (
@@ -424,7 +424,7 @@ def test_from_tuples_with_tuple_label():
             ),
             (("l1", "l2"), ("l1", np.nan)),
         ),
-    ),
+    ],
 )
 def test_from_tuples_with_various_tuple_lengths(keys, expected):
     # GH 60695

pandas/tests/series/methods/test_map.py

@@ -288,9 +288,7 @@ def test_map_dict_with_tuple_keys():
     df = DataFrame({"a": [(1,), (2,), (3, 4), (5, 6)]})
     label_mappings = {(1,): "A", (2,): "B", (3, 4): "A", (5, 6): "B"}
 
-    # GH 60695
-    df["labels"] = df["a"].apply(lambda x: label_mappings.get(x, None))
-
+    df["labels"] = df["a"].map(label_mappings)
     df["expected_labels"] = Series(["A", "B", "A", "B"], index=df.index)
     # All labels should be filled now
     tm.assert_series_equal(df["labels"], df["expected_labels"], check_names=False)

pandas/tests/series/test_constructors.py

@@ -1441,16 +1441,17 @@ def test_constructor_tuple_of_tuples(self):
         s = Series(data)
         assert tuple(s) == data
 
-    def test_constructor_dict_of_tuples(self):
-        data = {(1, 2): 3, (None, 5): 6}
-        result = Series(data).sort_values()
-        expected = Series([3, 6], index=MultiIndex.from_tuples([(1, 2), (None, 5)]))
-        tm.assert_series_equal(result, expected)
-
-        # GH 60695
-        data = {(1,): 3, (4, 5): 6}
+    @pytest.mark.parametrize(
+        "data, expected_values, expected_index",
+        [
+            ({(1, 2): 3, (None, 5): 6}, [3, 6], [(1, 2), (None, 5)]),
+            # GH 60695 test case
+            ({(1,): 3, (4, 5): 6}, [3, 6], [(1, None), (4, 5)]),
+        ],
+    )
+    def test_constructor_dict_of_tuples(self, data, expected_values, expected_index):
         result = Series(data).sort_values()
-        expected = Series([3, 6], index=MultiIndex.from_tuples([(1, None), (4, 5)]))
+        expected = Series(expected_values, index=MultiIndex.from_tuples(expected_index))
         tm.assert_series_equal(result, expected)
 
     # https://github.com/pandas-dev/pandas/issues/22698
@@ -1866,32 +1867,40 @@ class A(OrderedDict):
         series = Series(A(data))
         tm.assert_series_equal(series, expected)
 
-    def test_constructor_dict_multiindex(self):
-        d = {("a", "a"): 0.0, ("b", "a"): 1.0, ("b", "c"): 2.0}
-        _d = sorted(d.items())
-        result = Series(d)
-        expected = Series(
-            [x[1] for x in _d], index=MultiIndex.from_tuples([x[0] for x in _d])
-        )
-        tm.assert_series_equal(result, expected)
+    @pytest.mark.parametrize(
+        "data, expected_index_multi, expected_index_single",
+        [
+            (
+                {("a", "a"): 0.0, ("b", "a"): 1.0, ("b", "c"): 2.0},
+                MultiIndex.from_tuples([("a", "a"), ("b", "a"), ("b", "c")]),
+                None,
+            ),
+            (
+                {("a",): 0.0, ("a", "b"): 1.0},
+                MultiIndex.from_tuples([("a",), ("a", "b")]),
+                None,
+            ),
+            (
+                {("a", "a"): 0.0, ("b", "a"): 1.0, ("b", "c"): 2.0, "z": 111.0},
+                None,
+                Index(["z", ("a", "a"), ("b", "a"), ("b", "c")], tupleize_cols=False),
+            ),
+        ],
+    )
+    def test_constructor_dict_multiindex(
+        data, expected_index_multi, expected_index_single
+    ):
+        _d = sorted(data.items())
 
-        d["z"] = 111.0
-        _d.insert(0, ("z", d["z"]))
-        result = Series(d)
-        expected = Series(
-            [x[1] for x in _d], index=Index([x[0] for x in _d], tupleize_cols=False)
-        )
-        result = result.reindex(index=expected.index)
-        tm.assert_series_equal(result, expected)
+        result = Series(data)
+        if expected_index_multi:
+            expected = Series([x[1] for x in _d], index=expected_index_multi)
+            tm.assert_series_equal(result, expected)
 
-        # GH 60695
-        d = {("a",): 0.0, ("a", "b"): 1.0}
-        _d = sorted(d.items())
-        result = Series(d)
-        expected = Series(
-            [x[1] for x in _d], index=MultiIndex.from_tuples([x[0] for x in _d])
-        )
-        tm.assert_series_equal(result, expected)
+        if expected_index_single:
+            result = result.reindex(index=expected_index_single)
+            expected = Series([x[1] for x in _d], index=expected_index_single)
+            tm.assert_series_equal(result, expected)
 
     def test_constructor_dict_multiindex_reindex_flat(self):
         # construction involves reindexing with a MultiIndex corner case