def product(self, axis: Optional[Axis]=None, numeric_only: bool=None, min_count: int=0) -> Union[(Scalar, 'Series')]:
    '\n        Return the product of the values.\n\n        .. note:: unlike pandas\', pandas-on-Spark\'s emulates product by ``exp(sum(log(...)))``\n            trick. Therefore, it only works for positive numbers.\n\n        Parameters\n        ----------\n        axis : {index (0), columns (1)}\n            Axis for the function to be applied on.\n        numeric_only : bool, default None\n            Include only float, int, boolean columns. False is not supported. This parameter\n            is mainly for pandas compatibility.\n        min_count : int, default 0\n            The required number of valid values to perform the operation. If fewer than\n            ``min_count`` non-NA values are present the result will be NA.\n\n        Examples\n        --------\n        On a DataFrame:\n\n        Non-numeric type column is not included to the result.\n\n        >>> psdf = ps.DataFrame({\'A\': [1, 2, 3, 4, 5],\n        ...                     \'B\': [10, 20, 30, 40, 50],\n        ...                     \'C\': [\'a\', \'b\', \'c\', \'d\', \'e\']})\n        >>> psdf\n           A   B  C\n        0  1  10  a\n        1  2  20  b\n        2  3  30  c\n        3  4  40  d\n        4  5  50  e\n\n        >>> psdf.prod()\n        A         120\n        B    12000000\n        dtype: int64\n\n        If there is no numeric type columns, returns empty Series.\n\n        >>> ps.DataFrame({"key": [\'a\', \'b\', \'c\'], "val": [\'x\', \'y\', \'z\']}).prod()\n        Series([], dtype: float64)\n\n        On a Series:\n\n        >>> ps.Series([1, 2, 3, 4, 5]).prod()\n        120\n\n        By default, the product of an empty or all-NA Series is ``1``\n\n        >>> ps.Series([]).prod()\n        1.0\n\n        This can be controlled with the ``min_count`` parameter\n\n        >>> ps.Series([]).prod(min_count=1)\n        nan\n        '
    axis = validate_axis(axis)
    if ((numeric_only is None) and (axis == 0)):
        numeric_only = True
    elif ((numeric_only is True) and (axis == 1)):
        numeric_only = None

    def prod(spark_column: Column, spark_type: DataType) -> Column:
        if isinstance(spark_type, BooleanType):
            scol = F.min(F.coalesce(spark_column, SF.lit(True))).cast(LongType())
        elif isinstance(spark_type, NumericType):
            num_zeros = F.sum(F.when((spark_column == 0), 1).otherwise(0))
            sign = F.when(((F.sum(F.when((spark_column < 0), 1).otherwise(0)) % 2) == 0), 1).otherwise((- 1))
            scol = F.when((num_zeros > 0), 0).otherwise((sign * F.exp(F.sum(F.log(F.abs(spark_column))))))
            if isinstance(spark_type, IntegralType):
                scol = F.round(scol).cast(LongType())
        else:
            raise TypeError('Could not convert {} ({}) to numeric'.format(spark_type_to_pandas_dtype(spark_type), spark_type.simpleString()))
        return F.coalesce(scol, SF.lit(1))
    return self._reduce_for_stat_function(prod, name='prod', axis=axis, numeric_only=numeric_only, min_count=min_count)
Return the product of the values.

.. note:: unlike pandas', pandas-on-Spark's emulates product by ``exp(sum(log(...)))``
    trick. Therefore, it only works for positive numbers.

Parameters
----------
axis : {index (0), columns (1)}
    Axis for the function to be applied on.
numeric_only : bool, default None
    Include only float, int, boolean columns. False is not supported. This parameter
    is mainly for pandas compatibility.
min_count : int, default 0
    The required number of valid values to perform the operation. If fewer than
    ``min_count`` non-NA values are present the result will be NA.

Examples
--------
On a DataFrame:

Non-numeric type column is not included to the result.

>>> psdf = ps.DataFrame({'A': [1, 2, 3, 4, 5],
...                     'B': [10, 20, 30, 40, 50],
...                     'C': ['a', 'b', 'c', 'd', 'e']})
>>> psdf
   A   B  C
0  1  10  a
1  2  20  b
2  3  30  c
3  4  40  d
4  5  50  e

>>> psdf.prod()
A         120
B    12000000
dtype: int64

If there is no numeric type columns, returns empty Series.

>>> ps.DataFrame({"key": ['a', 'b', 'c'], "val": ['x', 'y', 'z']}).prod()
Series([], dtype: float64)

On a Series:

>>> ps.Series([1, 2, 3, 4, 5]).prod()
120

By default, the product of an empty or all-NA Series is ``1``

>>> ps.Series([]).prod()
1.0

This can be controlled with the ``min_count`` parameter

>>> ps.Series([]).prod(min_count=1)
nan
def product(self, axis: Optional[Axis]=None, numeric_only: bool=None, min_count: int=0) -> Union[(Scalar, 'Series')]:
    '\n        Return the product of the values.\n\n        .. note:: unlike pandas\', pandas-on-Spark\'s emulates product by ``exp(sum(log(...)))``\n            trick. Therefore, it only works for positive numbers.\n\n        Parameters\n        ----------\n        axis : {index (0), columns (1)}\n            Axis for the function to be applied on.\n        numeric_only : bool, default None\n            Include only float, int, boolean columns. False is not supported. This parameter\n            is mainly for pandas compatibility.\n        min_count : int, default 0\n            The required number of valid values to perform the operation. If fewer than\n            ``min_count`` non-NA values are present the result will be NA.\n\n        Examples\n        --------\n        On a DataFrame:\n\n        Non-numeric type column is not included to the result.\n\n        >>> psdf = ps.DataFrame({\'A\': [1, 2, 3, 4, 5],\n        ...                     \'B\': [10, 20, 30, 40, 50],\n        ...                     \'C\': [\'a\', \'b\', \'c\', \'d\', \'e\']})\n        >>> psdf\n           A   B  C\n        0  1  10  a\n        1  2  20  b\n        2  3  30  c\n        3  4  40  d\n        4  5  50  e\n\n        >>> psdf.prod()\n        A         120\n        B    12000000\n        dtype: int64\n\n        If there is no numeric type columns, returns empty Series.\n\n        >>> ps.DataFrame({"key": [\'a\', \'b\', \'c\'], "val": [\'x\', \'y\', \'z\']}).prod()\n        Series([], dtype: float64)\n\n        On a Series:\n\n        >>> ps.Series([1, 2, 3, 4, 5]).prod()\n        120\n\n        By default, the product of an empty or all-NA Series is ``1``\n\n        >>> ps.Series([]).prod()\n        1.0\n\n        This can be controlled with the ``min_count`` parameter\n\n        >>> ps.Series([]).prod(min_count=1)\n        nan\n        '
    axis = validate_axis(axis)
    if ((numeric_only is None) and (axis == 0)):
        numeric_only = True
    elif ((numeric_only is True) and (axis == 1)):
        numeric_only = None

    def prod(spark_column: Column, spark_type: DataType) -> Column:
        if isinstance(spark_type, BooleanType):
            scol = F.min(F.coalesce(spark_column, SF.lit(True))).cast(LongType())
        elif isinstance(spark_type, NumericType):
            num_zeros = F.sum(F.when((spark_column == 0), 1).otherwise(0))
            sign = F.when(((F.sum(F.when((spark_column < 0), 1).otherwise(0)) % 2) == 0), 1).otherwise((- 1))
            scol = F.when((num_zeros > 0), 0).otherwise((sign * F.exp(F.sum(F.log(F.abs(spark_column))))))
            if isinstance(spark_type, IntegralType):
                scol = F.round(scol).cast(LongType())
        else:
            raise TypeError('Could not convert {} ({}) to numeric'.format(spark_type_to_pandas_dtype(spark_type), spark_type.simpleString()))
        return F.coalesce(scol, SF.lit(1))
    return self._reduce_for_stat_function(prod, name='prod', axis=axis, numeric_only=numeric_only, min_count=min_count)