ENH: add LaTeX math mode with parentheses

pandas/io/formats/style_render.py

@@ -1117,7 +1117,8 @@ def format(
         2 & \textbf{\$\%\#} \\
         \end{tabular}
 
-        Using ``escape`` in 'latex-math' mode.
+        Applying ``escape`` in 'latex-math' mode. In the example below
+        we enter math mode using the character ``$``.
 
         >>> df = pd.DataFrame([[r"$\sum_{i=1}^{10} a_i$ a~b $\alpha \
         ...     = \frac{\beta}{\zeta^2}$"], ["%#^ $ \$x^2 $"]])
@@ -1129,6 +1130,20 @@ def format(
         1 & \%\#\textasciicircum \space $ \$x^2 $ \\
         \end{tabular}
 
+        We can use the character ``\(`` to enter math mode and the character ``\)``
+        to close math mode.
+
+        >>> df = pd.DataFrame([[r"\(\sum_{i=1}^{10} a_i\) a~b \(\alpha \
+        ...     = \frac{\beta}{\zeta^2}\)"], ["%#^ \( \$x^2 \)"]])
+        >>> df.style.format(escape="latex-math").to_latex()
+        ...  # doctest: +SKIP
+        \begin{tabular}{ll}
+         & 0 \\
+        0 & \(\sum_{i=1}^{10} a_i\) a\textasciitilde b \(\alpha
+        = \frac{\beta}{\zeta^2}\) \\
+        1 & \%\#\textasciicircum \space \( \$x^2 \) \\
+        \end{tabular}
+
         Pandas defines a `number-format` pseudo CSS attribute instead of the `.format`
         method to create `to_excel` permissible formatting. Note that semi-colons are
         CSS protected characters but used as separators in Excel's format string.
@@ -2344,7 +2359,8 @@ def _escape_latex(s):
         Escaped string
     """
     return (
-        s.replace("\\", "ab2§=§8yz")  # rare string for final conversion: avoid \\ clash
+        s.replace("\\ ", "ab2§=§8yz")
+        .replace("\\", "ab2§=§8yz")  # rare string for final conversion: avoid \\ clash
         .replace("ab2§=§8yz ", "ab2§=§8yz\\space ")  # since \backslash gobbles spaces
         .replace("&", "\\&")
         .replace("%", "\\%")
@@ -2363,11 +2379,11 @@ def _escape_latex(s):
 
 def _escape_latex_math(s):
     r"""
-    All characters between two characters ``$`` are preserved.
+    All characters in LaTeX math mode are preserved.
 
-    The substrings in LaTeX math mode, which start with the character ``$``
-    and end with ``$``, are preserved without escaping. Otherwise
-    regular LaTeX escaping applies. See ``_escape_latex()``.
+    The substrings in LaTeX math mode, which either are surrounded
+    by two characters ``$`` or start with the character ``\(`` and end with ``\)``,
+    are preserved without escaping. Otherwise regular LaTeX escaping applies.
 
     Parameters
     ----------
@@ -2379,16 +2395,55 @@ def _escape_latex_math(s):
     str :
         Escaped string
     """
-    s = s.replace(r"\$", r"rt8§=§7wz")
-    pattern = re.compile(r"\$.*?\$")
-    pos = 0
-    ps = pattern.search(s, pos)
-    res = []
-    while ps:
-        res.append(_escape_latex(s[pos : ps.span()[0]]))
-        res.append(ps.group())
-        pos = ps.span()[1]
+
+    def _math_mode_with_dollar(s):
+        s = s.replace(r"\$", r"rt8§=§7wz")
+        pattern = re.compile(r"\$.*?\$")
+        pos = 0
         ps = pattern.search(s, pos)
+        res = []
+        while ps:
+            res.append(_escape_latex(s[pos : ps.span()[0]]))
+            res.append(ps.group())
+            pos = ps.span()[1]
+            ps = pattern.search(s, pos)
+
+        res.append(_escape_latex(s[pos : len(s)]))
+        return "".join(res).replace(r"rt8§=§7wz", r"\$")
+
+    def _math_mode_with_parentheses(s):
+        s = s.replace(r"\(", r"LEFT§=§6yzLEFT").replace(r"\)", r"RIGHTab5§=§RIGHT")
+        res = []
+        for item in re.split(r"LEFT§=§6yz|ab5§=§RIGHT", s):
+            if item.startswith("LEFT") and item.endswith("RIGHT"):
+                res.append(item.replace("LEFT", r"\(").replace("RIGHT", r"\)"))
+            elif "LEFT" in item and "RIGHT" in item:
+                res.append(
+                    _escape_latex(item).replace("LEFT", r"\(").replace("RIGHT", r"\)")
+                )
+            else:
+                res.append(
+                    _escape_latex(item)
+                    .replace("LEFT", r"\textbackslash (")
+                    .replace("RIGHT", r"\textbackslash )")
+                )
+        return "".join(res)
 
-    res.append(_escape_latex(s[pos : len(s)]))
-    return "".join(res).replace(r"rt8§=§7wz", r"\$")
+    s = s.replace(r"\$", r"rt8§=§7wz")
+    pattern_d = re.compile(r"\$.*?\$")
+    pattern_p = re.compile(r"\\(.*?\\)")
+    pos_d = 0
+    pos_p = 0
+    ps_d = pattern_d.search(s, pos_d)
+    ps_p = pattern_p.search(s, pos_p)
+    mode = []
+    if ps_d:
+        mode.append(ps_d.span()[0])
+    if ps_p:
+        mode.append(ps_p.span()[0])
+    if len(mode) == 0:
+        return _escape_latex(s.replace(r"\$", r"rt8§=§7wz"))
+    if s[min(mode)] == r"$":
+        return _math_mode_with_dollar(s.replace(r"\$", r"rt8§=§7wz"))
+    else:
+        return _math_mode_with_parentheses(s.replace(r"\$", r"rt8§=§7wz"))

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

@@ -167,7 +167,7 @@ def test_format_clear(styler, func, attr, kwargs):
             "latex",
             '<>\\&"\\%\\$\\#\\_\\{\\}\\textasciitilde \\textasciicircum '
             "\\textbackslash \\textasciitilde \\space \\textasciicircum \\space "
-            "\\textbackslash \\space ",
+            "\\textbackslash ",
         ),
     ],
 )
@@ -192,13 +192,47 @@ def test_format_escape_html(escape, exp):
     assert styler._translate(True, True)["head"][0][1]["display_value"] == f"&{exp}&"
 
 
-def test_format_escape_latex_math():
-    chars = r"$\frac{1}{2} \$ x^2$ ~%#^"
+@pytest.mark.parametrize(
+    "chars, expected",
+    [
+        (
+            r"$ \$&%#_{}~^\ $ &%#_{}~^\ $",
+            "".join(
+                [
+                    r"$ \$&%#_{}~^\ $ ",
+                    r"\&\%\#\_\{\}\textasciitilde \textasciicircum \textbackslash \$",
+                ]
+            ),
+        ),
+        (
+            r"\( &%#_{}~^\ \) &%#_{}~^\ \(",
+            "".join(
+                [
+                    r"\( &%#_{}~^\ \) ",
+                    r"\&\%\#\_\{\}\textasciitilde \textasciicircum ",
+                    r"\textbackslash \textbackslash (",
+                ]
+            ),
+        ),
+        (
+            r"$ \frac{1}{2} $ \( \frac{1}{2} \)",
+            "".join(
+                [
+                    r"$ \frac{1}{2} $",
+                    r" \textbackslash ( \textbackslash frac\{1\}\{2\} \textbackslash )",
+                ]
+            ),
+        ),
+    ],
+)
+def test_format_escape_latex_math(chars, expected):
+    # GH 51903
+    # latex-math escape works for each DataFrame cell separately.
+    # If we have a combination of dollar signs and brackets,
+    # the sign which occurs first would apply.
     df = DataFrame([[chars]])
-
-    expected = r"$\frac{1}{2} \$ x^2$ \textasciitilde \%\#\textasciicircum "
     s = df.style.format("{0}", escape="latex-math")
-    assert expected == s._translate(True, True)["body"][0][1]["display_value"]
+    assert s._translate(True, True)["body"][0][1]["display_value"] == expected
 
 
 def test_format_escape_na_rep():