DEVOCEAN

    @final
    @Substitution(name="groupby")
    @Substitution(see_also=_common_see_also)
    def mean(
        self,
        #lib.no_default는 false랑 다르게, cython에서 default값이 없다고 알려주는 용도로 보임
        numeric_only: bool | lib.NoDefault = lib.no_default,
        engine: str = "cython",
        engine_kwargs: dict[str, bool] | None = None,
    ):        
        #DataFrame의 Data가 Numeric인지 여부를 사전에 체크
        #numeric_only가 일반적으로 lib.no_default로 들어오기 때문에
        #bool로된 값을 별도로 가져감
        numeric_only_bool = self._resolve_numeric_only("mean", numeric_only, axis=0)

        if maybe_use_numba(engine):
            from pandas.core._numba.kernels import sliding_mean

            return self._numba_agg_general(sliding_mean, engine_kwargs)
        else:
            result = self._cython_agg_general(
                "mean",
                alt=lambda x: Series(x).mean(numeric_only=numeric_only_bool),
                numeric_only=numeric_only,
            )
            return result.__finalize__(self.obj, method="groupby")

    @final
    def _cython_agg_general(
        self,
        how: str,
        alt: Callable,
        numeric_only: bool | lib.NoDefault,
        min_count: int = -1,
        ignore_failures: bool = True,
        **kwargs,
    ):
        numeric_only_bool = self._resolve_numeric_only(how, numeric_only, axis=0)
        
        #type of data = Manager2D
        data = self._get_data_to_aggregate()
        is_ser = data.ndim == 1

        orig_len = len(data)
        if numeric_only_bool:
            if is_ser and not is_numeric_dtype(self._selected_obj.dtype):
                #input 이상에 따른 예외처리 Code
            elif not is_ser:
                data = data.get_numeric_data(copy=False)

        def array_func(values: ArrayLike) -> ArrayLike:
            try:
                result = self.grouper._cython_operation(
                    "aggregate",
                    values,
                    how,
                    axis=data.ndim - 1,
                    min_count=min_count,
                    **kwargs,
                )
            except NotImplementedError:
                result = self._agg_py_fallback(values, ndim=data.ndim, alt=alt)

            return result

        new_mgr = data.grouped_reduce(array_func, ignore_failures=ignore_failures)

        if not is_ser and len(new_mgr) < orig_len:
            warn_dropping_nuisance_columns_deprecated(type(self), how, numeric_only)

        res = self._wrap_agged_manager(new_mgr)
        if is_ser:
            res.index = self.grouper.result_index
            return self._reindex_output(res)
        else:
            return res

    def grouped_reduce(self: T, func: Callable, ignore_failures: bool = False) -> T:  
        result_blocks: list[Block] = []
        dropped_any = False

        for blk in self.blocks:
            # blk's type is object
            if blk.is_object:
                # object 값이 있을경우 mean()에서 에러가 발생 하므로
                # column 단위로 나눠서 apply를 진행
                # -> object type이나, 실제 값은 float or int인 경우
                for sb in blk._split():
                    try:
                        applied = sb.apply(func)
                    except (TypeError, NotImplementedError):
                        if not ignore_failures:
                            raise
                        dropped_any = True
                        continue
                    result_blocks = extend_blocks(applied, result_blocks)
            # not type of object
            else:
                # object type이 아닌 경우
                # 이경우 apply(mean)이 실패하면 전체 불가능이므로 예외처리
                # 아닌경우 float / int이므로 정상 처리
                try:
                    applied = blk.apply(func)
                except (TypeError, NotImplementedError):
                    if not ignore_failures:
                        raise
                    dropped_any = True
                    continue
                result_blocks = extend_blocks(applied, result_blocks)

        if len(result_blocks) == 0:
            index = Index([None])  # placeholder
        else:
            index = Index(range(result_blocks[0].values.shape[-1]))

        if dropped_any:
            # faster to skip _combine if we haven't dropped any blocks
            return self._combine(result_blocks, copy=False, index=index)

        return type(self).from_blocks(result_blocks, [self.axes[0], index])

    @final
    def _split(self) -> list[Block]:
        """
        self가 2차원 block일 때 col단위로 쪼개서 list형태로 반환
        """
        assert self.ndim == 2

        new_blocks = []
        for i, ref_loc in enumerate(self._mgr_locs):
            vals = self.values[slice(i, i + 1)]

            bp = BlockPlacement(ref_loc)
            nb = type(self)(vals, placement=bp, ndim=2)
            new_blocks.append(nb)
        return new_blocks
        
def extend_blocks(result, blocks=None) -> list[Block]:
    """return a new extended blocks, given the result"""
    if blocks is None:
        blocks = []
    if isinstance(result, list):
        for r in result:
            if isinstance(r, list):
                blocks.extend(r)
            else:
                blocks.append(r)
    else:
        assert isinstance(result, Block), type(result)
        blocks.append(result)
    return blocks