ENH: add decimal and thousands args to Styler.format()

pandas/io/formats/style.py

@@ -114,6 +114,16 @@ class Styler:
 
         .. versionadded:: 1.2.0
 
+    decimal : str, default "."
+        Character used as decimal separator for floats, complex and integers
+
+        .. versionadded:: 1.3.0
+
+    thousands : str, optional, default None
+        Character used as thousands separator for floats, complex and integers
+
+        .. versionadded:: 1.3.0
+
     escape : bool, default False
         Replace the characters ``&``, ``<``, ``>``, ``'``, and ``"`` in cell display
         strings with HTML-safe sequences.
@@ -176,6 +186,8 @@ def __init__(
         cell_ids: bool = True,
         na_rep: Optional[str] = None,
         uuid_len: int = 5,
+        decimal: str = ".",
+        thousands: Optional[str] = None,
         escape: bool = False,
     ):
         # validate ordered args
@@ -210,7 +222,14 @@ def __init__(
         ] = defaultdict(lambda: partial(_default_formatter, precision=def_precision))
         self.precision = precision  # can be removed on set_precision depr cycle
         self.na_rep = na_rep  # can be removed on set_na_rep depr cycle
-        self.format(formatter=None, precision=precision, na_rep=na_rep, escape=escape)
+        self.format(
+            formatter=None,
+            precision=precision,
+            na_rep=na_rep,
+            escape=escape,
+            decimal=decimal,
+            thousands=thousands,
+        )
 
     def _repr_html_(self) -> str:
         """
@@ -552,6 +571,8 @@ def format(
         subset: Optional[Union[slice, Sequence[Any]]] = None,
         na_rep: Optional[str] = None,
         precision: Optional[int] = None,
+        decimal: str = ".",
+        thousands: Optional[str] = None,
         escape: bool = False,
     ) -> Styler:
         """
@@ -576,6 +597,16 @@ def format(
 
             .. versionadded:: 1.3.0
 
+        decimal : str, default "."
+            Character used as decimal separator for floats and complex.
+
+            .. versionadded:: 1.3.0
+
+        thousands : str, optional, default None
+            Character used as thousands separator for floats, complex and integers
+
+            .. versionadded:: 1.3.0
+
         escape : bool, default False
             Replace the characters ``&``, ``<``, ``>``, ``'``, and ``"`` in cell display
             string with HTML-safe sequences. Escaping is done before ``formatter``.
@@ -600,7 +631,9 @@ def format(
         The default formatter currently expresses floats and complex numbers with the
         pandas display precision unless using the ``precision`` argument here. The
         default formatter does not adjust the representation of missing values unless
-        the ``na_rep`` argument is used.
+        the ``na_rep`` argument is used. The default formatter will alter the display
+        of ``decimal`` and ``thousands`` separators only if the respective arguments
+        are used.
 
         The ``subset`` argument defines which region to apply the formatting function
         to. If the ``formatter`` argument is given in dict form but does not include
@@ -662,13 +695,28 @@ def format(
         <td .. ><a href="a.com/&#34;A&amp;B&#34;">&#34;A&amp;B&#34;</a></td>
         <td .. >NA</td>
         ...
+
+        Using a given ``formatter`` and the default formatter with ``decimal`` and
+        ``thousands``.
+
+        >>> df = pd.DataFrame([[1000, 10000], [100.123, 1000000]])
+        >>> s = df.style.format(precision=2, thousands="-", decimal="*")
+                   0           1
+        0   1-000*00      10-000
+        1     100*12   1-000-000
+        >>> s = df.style.format({0: "{:,.1f}", 1: "{:.0f}"}, thousands=" ", decimal=",")
+                  0         1
+        0   1 000,0     10000
+        1     100,1   1000000
         """
         if all(
             (
                 formatter is None,
                 subset is None,
                 precision is None,
                 na_rep is None,
+                decimal == ".",
+                thousands is None,
                 escape is False,
             )
         ):
@@ -689,7 +737,12 @@ def format(
             except KeyError:
                 format_func = None
             format_func = _maybe_wrap_formatter(
-                format_func, na_rep=na_rep, precision=precision, escape=escape
+                format_func,
+                na_rep=na_rep,
+                precision=precision,
+                escape=escape,
+                decimal=decimal,
+                thousands=thousands,
             )
 
             for row, value in data[[col]].itertuples():
@@ -2201,7 +2254,7 @@ def _get_level_lengths(index, hidden_elements=None):
     return non_zero_lengths
 
 
-def _default_formatter(x: Any, precision: int) -> Any:
+def _default_formatter(x: Any, precision: int, thousands: bool = False) -> Any:
     """
     Format the display of a value
 
@@ -2211,21 +2264,60 @@ def _default_formatter(x: Any, precision: int) -> Any:
         Input variable to be formatted
     precision : Int
         Floating point precision used if ``x`` is float or complex.
+    thousands : bool
+        Whether to group digits with thousands separated with ",".
 
     Returns
     -------
     value : Any
-        Matches input type, or string if input is float or complex.
+        Matches input type, or string if input is float or complex or int with sep.
     """
     if isinstance(x, (float, complex)):
+        if thousands:
+            return f"{x:,.{precision}f}"
         return f"{x:.{precision}f}"
+    elif isinstance(x, int) and thousands:
+        return f"{x:,.0f}"
     return x
 
 
+def _maybe_wrap_deci_thou(
+    formatter: Callable, decimal: str = ".", thousands: Optional[str] = None
+) -> Callable:
+    """
+    Takes a string formatting function and wraps logic to deal with thousands and
+    decimal parameters, in the case that they are non-standard and that the input
+    is a (float, complex).
+    """
+
+    def wrapper(x):
+        default_thousands = thousands is None or thousands == ","
+        default_decimal = decimal == "."
+        if isinstance(x, (float, complex, int)):
+            if default_thousands and default_decimal:
+                return formatter(x)
+            elif default_thousands and not default_decimal:
+                return formatter(x).replace(".", decimal)
+            elif not default_thousands and default_decimal:
+                return formatter(x).replace(",", thousands)
+            else:
+                return (
+                    formatter(x)
+                    .replace(",", "§_§-")  # rare string to avoid "," <-> "." clash.
+                    .replace(".", decimal)
+                    .replace("§_§-", thousands)
+                )
+        return formatter(x)
+
+    return wrapper
+
+
 def _maybe_wrap_formatter(
     formatter: Optional[BaseFormatter] = None,
     na_rep: Optional[str] = None,
     precision: Optional[int] = None,
+    decimal: str = ".",
+    thousands: Optional[str] = None,
     escape: bool = False,
 ) -> Callable:
     """
@@ -2234,15 +2326,19 @@ def _maybe_wrap_formatter(
     available.
     """
     if isinstance(formatter, str):
-        formatter_func = lambda x: formatter.format(x)
+        func = lambda x: formatter.format(x)
     elif callable(formatter):
-        formatter_func = formatter
+        func = formatter
     elif formatter is None:
         precision = get_option("display.precision") if precision is None else precision
-        formatter_func = partial(_default_formatter, precision=precision)
+        func = partial(
+            _default_formatter, precision=precision, thousands=(thousands is not None)
+        )
     else:
         raise TypeError(f"'formatter' expected str or callable, got {type(formatter)}")
 
+    formatter_func = _maybe_wrap_deci_thou(func, decimal=decimal, thousands=thousands)
+
     def _str_escape(x, escape: bool):
         """if escaping: only use on str, else return input"""
         if escape and isinstance(x, str):

pandas/tests/io/formats/style/test_style.py

@@ -678,6 +678,44 @@ def test_format_escape_floats(self):
         for expected in [">0<", ">1<", ">-1.2<", ">-0.6<"]:
             assert expected in s.render()
 
+    @pytest.mark.parametrize("formatter", [None, "{:,.1f}"])
+    @pytest.mark.parametrize("decimal", [".", "*"])
+    @pytest.mark.parametrize("precision", [None, 2])
+    def test_format_thousands(self, formatter, decimal, precision):
+        s = DataFrame([[1000000.123456789]]).style  # test float
+        result = s.format(
+            thousands="_", formatter=formatter, decimal=decimal, precision=precision
+        )._translate()
+        assert "1_000_000" in result["body"][0][1]["display_value"]
+
+        s = DataFrame([[1000000]]).style  # test int
+        result = s.format(
+            thousands="_", formatter=formatter, decimal=decimal, precision=precision
+        )._translate()
+        assert "1_000_000" in result["body"][0][1]["display_value"]
+
+        s = DataFrame([[1 + 1000000.123456789j]]).style  # test complex
+        result = s.format(
+            thousands="_", formatter=formatter, decimal=decimal, precision=precision
+        )._translate()
+        assert "1_000_000" in result["body"][0][1]["display_value"]
+
+    @pytest.mark.parametrize("formatter", [None, "{:,.4f}"])
+    @pytest.mark.parametrize("thousands", [None, ",", "*"])
+    @pytest.mark.parametrize("precision", [None, 4])
+    def test_format_decimal(self, formatter, thousands, precision):
+        s = DataFrame([[1000000.123456789]]).style  # test float
+        result = s.format(
+            decimal="_", formatter=formatter, thousands=thousands, precision=precision
+        )._translate()
+        assert "000_123" in result["body"][0][1]["display_value"]
+
+        s = DataFrame([[1 + 1000000.123456789j]]).style  # test complex
+        result = s.format(
+            decimal="_", formatter=formatter, thousands=thousands, precision=precision
+        )._translate()
+        assert "000_123" in result["body"][0][1]["display_value"]
+
     def test_nonunique_raises(self):
         df = DataFrame([[1, 2]], columns=["A", "A"])
         msg = "style is not supported for non-unique indices."