DF.__setitem__ creates extension column when given extension scalar

doc/source/whatsnew/v1.0.0.rst

@@ -1259,6 +1259,7 @@ ExtensionArray
 - Bug in :class:`arrays.PandasArray` when setting a scalar string (:issue:`28118`, :issue:`28150`).
 - Bug where nullable integers could not be compared to strings (:issue:`28930`)
 - Bug where :class:`DataFrame` constructor raised ``ValueError`` with list-like data and ``dtype`` specified (:issue:`30280`)
+- Bug where :class:`Series` set to scalar extension type was considered an object type rather than the extension type (:issue:`34832`)
 
 Other
 ^^^^^

pandas/core/frame.py

@@ -75,6 +75,7 @@
 from pandas.core.dtypes.cast import (
     cast_scalar_to_array,
     coerce_to_dtypes,
+    construct_1d_arraylike_from_scalar,
     find_common_type,
     infer_dtype_from_scalar,
     invalidate_string_dtypes,
@@ -515,24 +516,38 @@ def __init__(
             else:
                 mgr = init_dict({}, index, columns, dtype=dtype)
         else:
-            try:
-                arr = np.array(data, dtype=dtype, copy=copy)
-            except (ValueError, TypeError) as err:
-                exc = TypeError(
-                    "DataFrame constructor called with "
-                    f"incompatible data and dtype: {err}"
-                )
-                raise exc from err
+            if not dtype:
+                dtype, _ = infer_dtype_from_scalar(data, pandas_dtype=True)
 
-            if arr.ndim == 0 and index is not None and columns is not None:
-                values = cast_scalar_to_array(
-                    (len(index), len(columns)), data, dtype=dtype
-                )
-                mgr = init_ndarray(
-                    values, index, columns, dtype=values.dtype, copy=False
-                )
+            if is_extension_array_dtype(dtype):
+                if index is None or columns is None:
+                    raise ValueError("DataFrame constructor not properly called!")
+
+                values = [
+                    construct_1d_arraylike_from_scalar(data, len(index), dtype)
+                    for _ in range(len(columns))
+                ]
+                mgr = arrays_to_mgr(values, columns, index, columns, dtype=None)
             else:
-                raise ValueError("DataFrame constructor not properly called!")
+                try:
+                    arr = np.array(data, dtype=dtype, copy=copy)
+                except (ValueError, TypeError) as err:
+                    exc = TypeError(
+                        "DataFrame constructor called with "
+                        f"incompatible data and dtype: {err}"
+                    )
+                    raise exc from err
+
+                if arr.ndim == 0 and index is not None and columns is not None:
+                    values = cast_scalar_to_array(
+                        (len(index), len(columns)), data, dtype=dtype
+                    )
+
+                    mgr = init_ndarray(
+                        values, index, columns, dtype=values.dtype, copy=False
+                    )
+                else:
+                    raise ValueError("DataFrame constructor not properly called!")
 
         NDFrame.__init__(self, mgr)
 
@@ -3730,7 +3745,13 @@ def reindexer(value):
             infer_dtype, _ = infer_dtype_from_scalar(value, pandas_dtype=True)
 
             # upcast
-            value = cast_scalar_to_array(len(self.index), value)
+            if is_extension_array_dtype(infer_dtype):
+                value = construct_1d_arraylike_from_scalar(
+                    value, len(self.index), infer_dtype
+                )
+            else:
+                value = cast_scalar_to_array(len(self.index), value)
+
             value = maybe_cast_to_datetime(value, infer_dtype)
 
         # return internal types directly

pandas/tests/frame/indexing/test_setitem.py

@@ -1,7 +1,18 @@
 import numpy as np
 import pytest
 
-from pandas import Categorical, DataFrame, Index, Series, Timestamp, date_range
+from pandas.core.dtypes.dtypes import IntervalDtype, PeriodDtype
+
+from pandas import (
+    Categorical,
+    DataFrame,
+    Index,
+    Interval,
+    Period,
+    Series,
+    Timestamp,
+    date_range,
+)
 import pandas._testing as tm
 from pandas.core.arrays import SparseArray
 
@@ -150,3 +161,22 @@ def test_setitem_dict_preserves_dtypes(self):
                 "c": float(b),
             }
         tm.assert_frame_equal(df, expected)
+
+    def test_setitem_extension_types(self):
+        # GH: 34832
+        period_val = Period("2020-01")
+        interval_val = Interval(left=0, right=5)
+
+        expected = DataFrame(
+            {
+                "idx": [1, 2, 3],
+                "period": Series([period_val] * 3, dtype=PeriodDtype("M")),
+                "interval": Series([interval_val] * 3, dtype=IntervalDtype("int64")),
+            }
+        )
+
+        df = DataFrame({"idx": [1, 2, 3]})
+        df["period"] = period_val
+        df["interval"] = interval_val
+
+        tm.assert_frame_equal(df, expected)

pandas/tests/frame/methods/test_combine_first.py

@@ -199,12 +199,14 @@ def test_combine_first_timezone(self):
             columns=["UTCdatetime", "abc"],
             data=data1,
             index=pd.date_range("20140627", periods=1),
+            dtype="object",
         )
         data2 = pd.to_datetime("20121212 12:12").tz_localize("UTC")
         df2 = pd.DataFrame(
             columns=["UTCdatetime", "xyz"],
             data=data2,
             index=pd.date_range("20140628", periods=1),
+            dtype="object",
         )
         res = df2[["UTCdatetime"]].combine_first(df1)
         exp = pd.DataFrame(
@@ -217,10 +219,13 @@ def test_combine_first_timezone(self):
             },
             columns=["UTCdatetime", "abc"],
             index=pd.date_range("20140627", periods=2, freq="D"),
+            dtype="object",
         )
-        tm.assert_frame_equal(res, exp)
         assert res["UTCdatetime"].dtype == "datetime64[ns, UTC]"
         assert res["abc"].dtype == "datetime64[ns, UTC]"
+        # GH Issue 7509
+        res = res.astype("object")
+        tm.assert_frame_equal(res, exp)
 
         # see gh-10567
         dts1 = pd.date_range("2015-01-01", "2015-01-05", tz="UTC")

pandas/tests/frame/test_constructors.py

@@ -14,6 +14,7 @@
 from pandas.compat.numpy import _is_numpy_dev
 
 from pandas.core.dtypes.common import is_integer_dtype
+from pandas.core.dtypes.dtypes import PeriodDtype
 
 import pandas as pd
 from pandas import (
@@ -723,6 +724,12 @@ def test_constructor_period(self):
         assert df["a"].dtype == a.dtype
         assert df["b"].dtype == b.dtype
 
+        data = pd.Period("2012-01", freq="M")
+        df = DataFrame(index=[0, 1], columns=["a", "b"], data=data)
+
+        assert df["a"].dtype == PeriodDtype("M")
+        assert df["b"].dtype == PeriodDtype("M")
+
     def test_nested_dict_frame_constructor(self):
         rng = pd.period_range("1/1/2000", periods=5)
         df = DataFrame(np.random.randn(10, 5), columns=rng)