REF/INT: concat blocks of same type with preserving block type

pandas/core/internals.py

@@ -312,6 +312,14 @@ def ftype(self):
     def merge(self, other):
         return _merge_blocks([self, other])
 
+    def concat_same_type(self, to_concat):
+        """
+        Concatenate list of single blocks of the same type.
+        """
+        values = np.concatenate([blk.values for blk in to_concat])
+        return self.make_block_same_class(
+            values, placement=slice(0, len(values), 1))
+
     def reindex_axis(self, indexer, method=None, axis=1, fill_value=None,
                      limit=None, mask_info=None):
         """
@@ -2407,6 +2415,19 @@ def to_native_types(self, slicer=None, na_rep='', quoting=None, **kwargs):
         # we are expected to return a 2-d ndarray
         return values.reshape(1, len(values))
 
+    def concat_same_type(self, to_concat):
+        """
+        Concatenate list of single blocks of the same type.
+        """
+        to_concat = [blk.values for blk in to_concat]
+        values = _concat._concat_categorical(to_concat)
+
+        if is_categorical_dtype(values.dtype):
+            return self.make_block_same_class(
+                values, placement=slice(0, len(values), 1))
+        else:
+            return make_block(values, placement=slice(0, len(values), 1))
+
 
 class DatetimeBlock(DatetimeLikeBlockMixin, Block):
     __slots__ = ()
@@ -2684,6 +2705,19 @@ def shift(self, periods, axis=0, mgr=None):
         return [self.make_block_same_class(new_values,
                                            placement=self.mgr_locs)]
 
+    def concat_same_type(self, to_concat):
+        """
+        Concatenate list of single blocks of the same type.
+        """
+        to_concat = [blk.values for blk in to_concat]
+        values = _concat._concat_datetime(to_concat)
+
+        if is_datetimetz(values):
+            return self.make_block_same_class(
+                values, placement=slice(0, len(values), 1))
+        else:
+            return make_block(values, placement=slice(0, len(values), 1))
+
 
 class SparseBlock(NonConsolidatableMixIn, Block):
     """ implement as a list of sparse arrays of the same dtype """
@@ -2851,6 +2885,16 @@ def sparse_reindex(self, new_index):
         return self.make_block_same_class(values, sparse_index=new_index,
                                           placement=self.mgr_locs)
 
+    def concat_same_type(self, to_concat):
+        """
+        Concatenate list of single blocks of the same type.
+        """
+        to_concat = [blk.values for blk in to_concat]
+        values = _concat._concat_sparse(to_concat)
+
+        return self.make_block_same_class(
+            values, placement=slice(0, len(values), 1))
+
 
 def make_block(values, placement, klass=None, ndim=None, dtype=None,
                fastpath=False):

pandas/core/reshape/concat.py

@@ -3,13 +3,13 @@
 """
 
 import numpy as np
-from pandas import compat, DataFrame, Series, Index, MultiIndex
+from pandas import compat, DataFrame, Series, Index, MultiIndex, SparseSeries
 from pandas.core.index import (_get_objs_combined_axis,
                                _ensure_index, _get_consensus_names,
                                _all_indexes_same)
 from pandas.core.categorical import (_factorize_from_iterable,
                                      _factorize_from_iterables)
-from pandas.core.internals import concatenate_block_managers
+from pandas.core.internals import concatenate_block_managers, SparseBlock
 from pandas.core import common as com
 from pandas.core.generic import NDFrame
 import pandas.core.dtypes.concat as _concat
@@ -362,15 +362,30 @@ def get_result(self):
 
             # stack blocks
             if self.axis == 0:
+                name = com._consensus_name_attr(self.objs)
+
                 # concat Series with length to keep dtype as much
                 non_empties = [x for x in self.objs if len(x) > 0]
+
+                # check if all series are of the same block type:
+                if len(non_empties) > 0:
+                    blocks = [obj._data.blocks[0] for obj in non_empties]
+                    if all([type(b) is type(blocks[0]) for b in blocks[1:]]):  # noqa
+                        new_block = blocks[0].concat_same_type(blocks)
+                        if isinstance(new_block, SparseBlock):
+                            cons = SparseSeries
+                        else:
+                            cons = Series
+                        return (cons(new_block, index=self.new_axes[0],
+                                     name=name, fastpath=True)
+                                .__finalize__(self, method='concat'))
+
                 if len(non_empties) > 0:
                     values = [x._values for x in non_empties]
                 else:
                     values = [x._values for x in self.objs]
                 new_data = _concat._concat_compat(values)
 
-                name = com._consensus_name_attr(self.objs)
                 cons = _concat._get_series_result_type(new_data)
 
                 return (cons(new_data, index=self.new_axes[0],

pandas/tests/internals/test_external_block.py

@@ -27,3 +27,12 @@ def test_custom_repr():
     blk_mgr = BlockManager([block], [['col'], range(3)])
     df = pd.DataFrame(blk_mgr)
     assert repr(df) == '      col\n0  Val: 0\n1  Val: 1\n2  Val: 2'
+
+
+def test_concat_series():
+    values = np.arange(3, dtype='int64')
+    block = CustomBlock(values, placement=slice(0, 3))
+    s = pd.Series(block, pd.RangeIndex(3), fastpath=True)
+
+    res = pd.concat([s, s])
+    assert isinstance(res._data.blocks[0], CustomBlock)