BUG: Bug in loc did not change dtype when complete column was assigned

doc/source/whatsnew/v1.2.0.rst

@@ -477,6 +477,7 @@ Indexing
 - Bug in :meth:`DataFrame.loc` returned requested key plus missing values when ``loc`` was applied to single level from :class:`MultiIndex` (:issue:`27104`)
 - Bug in indexing on a :class:`Series` or :class:`DataFrame` with a :class:`CategoricalIndex` using a listlike indexer containing NA values (:issue:`37722`)
 - Bug in :meth:`DataFrame.xs` ignored ``droplevel=False`` for columns (:issue:`19056`)
+- Bug in :meth:`DataFrame.loc` did not preserve dtype of new values, when complete columns was assigned (:issue:`20635`)
 
 Missing
 ^^^^^^^

pandas/core/indexing.py

@@ -13,6 +13,7 @@
 
 from pandas.core.dtypes.common import (
     is_array_like,
+    is_dtype_equal,
     is_hashable,
     is_integer,
     is_iterator,
@@ -1550,6 +1551,14 @@ def _setitem_with_indexer(self, indexer, value):
                 val = list(value.values()) if isinstance(value, dict) else value
                 blk = self.obj._mgr.blocks[0]
                 take_split_path = not blk._can_hold_element(val)
+                if not take_split_path:
+                    if isinstance(value, ABCSeries):
+                        take_split_path = not (is_dtype_equal(value.dtype, blk.dtype))
+                    elif isinstance(value, ABCDataFrame):
+                        dtypes = list(value.dtypes.unique())
+                        take_split_path = not (
+                            len(dtypes) == 1 and is_dtype_equal(dtypes[0], blk.dtype)
+                        )
 
         # if we have any multi-indexes that have non-trivial slices
         # (not null slices) then we must take the split path, xref

pandas/tests/frame/indexing/test_setitem.py

@@ -16,6 +16,7 @@
     date_range,
     notna,
     period_range,
+    to_datetime,
 )
 import pandas._testing as tm
 from pandas.core.arrays import SparseArray
@@ -298,6 +299,40 @@ def test_iloc_setitem_bool_indexer(self, klass):
         expected = DataFrame({"flag": ["x", "y", "z"], "value": [2, 3, 4]})
         tm.assert_frame_equal(df, expected)
 
+    @pytest.mark.parametrize("dtype", ["int64", "Int64"])
+    def test_setitem_complete_columns_different_dtypes(self, dtype):
+        # GH: 20635
+        df = DataFrame({"A": ["a", "b"], "B": ["1", "2"], "C": ["3", "4"], "D": [1, 2]})
+        rhs = df.loc[:, ["B", "C"]].astype("int64").astype(dtype)
+        df.loc[:, ["B", "C"]] = rhs
+        expected = DataFrame({"A": ["a", "b"], "B": [1, 2], "C": [3, 4], "D": [1, 2]})
+        expected[["B", "C"]] = expected[["B", "C"]].astype(dtype)
+        tm.assert_frame_equal(df, expected)
+
+    def test_setitem_single_column_as_series_different_dtype(self):
+        # GH: 20635
+        df = DataFrame({"A": ["a", "b"], "B": ["1", "2"], "C": ["3", "4"]})
+        df.loc[:, "C"] = df.loc[:, "C"].astype("int64")
+        expected = DataFrame({"A": ["a", "b"], "B": ["1", "2"], "C": [3, 4]})
+        tm.assert_frame_equal(df, expected)
+
+    def test_setitem_conversion_to_datetime(self):
+        # GH: 20511
+        df = DataFrame(
+            [["2015-01-01", "2016-01-01"], ["2016-01-01", "2015-01-01"]],
+            columns=["date0", "date1"],
+        )
+        df.iloc[:, [0]] = df.iloc[:, [0]].apply(
+            lambda x: to_datetime(x, errors="coerce")
+        )
+        expected = DataFrame(
+            {
+                "date0": [to_datetime("2015-01-01"), to_datetime("2016-01-01")],
+                "date1": ["2016-01-01", "2015-01-01"],
+            }
+        )
+        tm.assert_frame_equal(df, expected)
+
 
 class TestDataFrameSetItemSlicing:
     def test_setitem_slice_position(self):

pandas/tests/series/indexing/test_setitem.py

@@ -210,6 +210,14 @@ def test_setitem_nan_casts(self):
         ser[:5] = np.nan
         tm.assert_series_equal(ser, expected)
 
+    @pytest.mark.parametrize("dtype", ["int64", "Int64"])
+    def test_setitem_assigning_different_dtype(self, dtype):
+        # GH: 20635
+        ser = Series(["3", "4"], name="A")
+        ser.loc[:] = ser.loc[:].astype("int64").astype(dtype)
+        expected = Series([3, 4], name="A", dtype=dtype)
+        tm.assert_series_equal(ser, expected)
+
 
 class TestSetitemWithExpansion:
     def test_setitem_empty_series(self):