解析¶

解析函数参考¶

sympy.parsing.sympy_parser.parse_expr(s: str, local_dict: ~typing.Dict[str, ~typing.Any] | None = None, transformations: ~typing.Tuple[~typing.Callable[[~typing.List[~typing.Tuple[int, str]], ~typing.Dict[str, ~typing.Any], ~typing.Dict[str, ~typing.Any]], ~typing.List[~typing.Tuple[int, str]]], ...] | str = (<function lambda_notation>, <function auto_symbol>, <function repeated_decimals>, <function auto_number>, <function factorial_notation>), global_dict: ~typing.Dict[str, ~typing.Any] | None = None, evaluate=True)[源代码][源代码]¶

将字符串 s 转换为 SymPy 表达式，在 local_dict 中。

参数:

sstr: 要解析的字符串。
local_dictdict, 可选: 解析时使用的局部变量字典。
global_dictdict, 可选: 全局变量的字典。默认情况下，这是用 from sympy import * 初始化的；提供此参数以覆盖此行为（例如，解析 "Q & S"）。
转换元组或字符串: 用于在评估解析表达式的标记之前修改这些标记的转换函数元组。默认的转换将数值字面量转换为它们的 SymPy 等价物，将未定义的变量转换为 SymPy 符号，并允许使用标准的数学阶乘表示法（例如 x!）。可以通过字符串进行选择（见下文）。
评估bool, 可选: 当为 False 时，参数的顺序将保持为它们在字符串中的顺序，并且通常会发生的自动简化将被抑制。（参见示例）

参见

stringify_expr, eval_expr, standard_transformations
implicit_multiplication_application

示例

>>> from sympy.parsing.sympy_parser import parse_expr
>>> parse_expr("1/2")
1/2
>>> type(_)
<class 'sympy.core.numbers.Half'>
>>> from sympy.parsing.sympy_parser import standard_transformations,\
... implicit_multiplication_application
>>> transformations = (standard_transformations +
...     (implicit_multiplication_application,))
>>> parse_expr("2x", transformations=transformations)
2*x

当 evaluate=False 时，某些自动简化将不会发生：

>>> parse_expr("2**3"), parse_expr("2**3", evaluate=False)
(8, 2**3)

此外，参数的顺序将不会被规范化。这一特性允许人们准确地了解表达式是如何输入的：

>>> a = parse_expr('1 + x', evaluate=False)
>>> b = parse_expr('x + 1', evaluate=False)
>>> a == b
False
>>> a.args
(1, x)
>>> b.args
(x, 1)

然而，请注意，当这些表达式被打印时，它们将显示相同：

>>> assert str(a) == str(b)

为了方便，可以通过打印 transformations 来查看转换：

>>> from sympy.parsing.sympy_parser import transformations

>>> print(transformations)
lambda_notation
auto_symbol
repeated_decimals
auto_number
factorial_notation
implicit_multiplication_application
convert_xor
implicit_application
implicit_multiplication
convert_equals_signs
function_exponentiation
rationalize

T 对象提供了一种选择这些变换的方法：

>>> from sympy.parsing.sympy_parser import T

如果你打印它，你将会看到与上面显示的相同的列表。

>>> str(T) == str(transformations)
True

标准切片将返回一个变换元组：

>>> T[:5] == standard_transformations
True

因此，T 可以用来指定解析转换：

>>> parse_expr("2x", transformations=T[:5])
Traceback (most recent call last):
...
SyntaxError: invalid syntax
>>> parse_expr("2x", transformations=T[:6])
2*x
>>> parse_expr('.3', transformations=T[3, 11])
3/10
>>> parse_expr('.3x', transformations=T[:])
3*x/10

为了进一步方便，可以使用字符串 ‘implicit’ 和 ‘all’ 分别选择 0-5 和所有转换。

>>> parse_expr('.3x', transformations='all')
3*x/10

sympy.parsing.sympy_parser.stringify_expr( s: str, local_dict: Dict[str, Any], global_dict: Dict[str, Any], transformations: Tuple[Callable[[List[Tuple[int, str]], Dict[str, Any], Dict[str, Any]], List[Tuple[int, str]]], ...], ) → str[源代码][源代码]¶

将字符串 s 转换为 Python 代码，在 local_dict 中

通常，应使用 parse_expr。

sympy.parsing.sympy_parser.eval_expr( code, local_dict: Dict[str, Any], global_dict: Dict[str, Any], )[源代码][源代码]¶

评估由 stringify_expr 生成的 Python 代码。

通常，应使用 parse_expr。

sympy.parsing.maxima.parse_maxima(str, globals=None, name_dict={})[源代码][源代码]¶

sympy.parsing.mathematica.parse_mathematica(s)[源代码][源代码]¶

将包含 Wolfram Mathematica 表达式的字符串转换为 SymPy 表达式。

如果翻译器无法找到合适的 SymPy 表达式，Mathematica 表达式的 FullForm 将被输出，使用 SymPy 的 Function 对象作为语法树的节点。

示例

>>> from sympy.parsing.mathematica import parse_mathematica
>>> parse_mathematica("Sin[x]^2 Tan[y]")
sin(x)**2*tan(y)
>>> e = parse_mathematica("F[7,5,3]")
>>> e
F(7, 5, 3)
>>> from sympy import Function, Max, Min
>>> e.replace(Function("F"), lambda *x: Max(*x)*Min(*x))
21

支持标准输入形式和 Mathematica 完整形式：

>>> parse_mathematica("x*(a + b)")
x*(a + b)
>>> parse_mathematica("Times[x, Plus[a, b]]")
x*(a + b)

要从Wolfram的代码中获取矩阵：

>>> m = parse_mathematica("{{a, b}, {c, d}}")
>>> m
((a, b), (c, d))
>>> from sympy import Matrix
>>> Matrix(m)
Matrix([
[a, b],
[c, d]])

如果转换为等价的 SymPy 表达式失败，将创建一个等价于 Wolfram Mathematica 的 “FullForm” 的 SymPy 表达式：

>>> parse_mathematica("x_.")
Optional(Pattern(x, Blank()))
>>> parse_mathematica("Plus @@ {x, y, z}")
Apply(Plus, (x, y, z))
>>> parse_mathematica("f[x_, 3] := x^3 /; x > 0")
SetDelayed(f(Pattern(x, Blank()), 3), Condition(x**3, x > 0))

解析转换参考¶

转换是一个函数，它接受参数 tokens, local_dict, global_dict 并返回一个转换后的标记列表。它们可以通过将函数列表传递给 parse_expr() 来使用，并按给定的顺序应用。

sympy.parsing.sympy_parser.standard_transformations: Tuple[Callable[[List[Tuple[int, str]], Dict[str, Any], Dict[str, Any]], List[Tuple[int, str]]], ...] = (<function lambda_notation>, <function auto_symbol>, <function repeated_decimals>, <function auto_number>, <function factorial_notation>)¶: 用于 parse_expr() 的标准转换。插入对 Symbol、Integer 和其他 SymPy 数据类型的调用，并允许使用标准阶乘表示法（例如 x!）。

sympy.parsing.sympy_parser.split_symbols( tokens: List[Tuple[int, str]], local_dict: Dict[str, Any], global_dict: Dict[str, Any], )[源代码]¶

拆分隐式乘法的符号名称。

旨在让 xyz 这样的表达式被解析为 x*y*z。不会分割希腊字母名称，因此 theta 不会变成 t*h*e*t*a。通常应与 implicit_multiplication 一起使用。

sympy.parsing.sympy_parser.split_symbols_custom( predicate: Callable[[str], bool], )[源代码][源代码]¶

创建一个分割符号名称的转换。

predicate 如果符号名称需要被分割，则应返回 True。

例如，要保留默认行为但避免拆分某些符号名称，可以使用如下谓词：

>>> from sympy.parsing.sympy_parser import (parse_expr, _token_splittable,
... standard_transformations, implicit_multiplication,
... split_symbols_custom)
>>> def can_split(symbol):
...     if symbol not in ('list', 'of', 'unsplittable', 'names'):
...             return _token_splittable(symbol)
...     return False
...
>>> transformation = split_symbols_custom(can_split)
>>> parse_expr('unsplittable', transformations=standard_transformations +
... (transformation, implicit_multiplication))
unsplittable

sympy.parsing.sympy_parser.implicit_multiplication( tokens: List[Tuple[int, str]], local_dict: Dict[str, Any], global_dict: Dict[str, Any], ) → List[Tuple[int, str]][源代码][源代码]¶

在大多数情况下使乘法运算符可选。

在使用 implicit_application() 之前使用此方法，否则表达式如 sin 2x 将被解析为 x * sin(2) 而不是 sin(2*x)。

示例

>>> from sympy.parsing.sympy_parser import (parse_expr,
... standard_transformations, implicit_multiplication)
>>> transformations = standard_transformations + (implicit_multiplication,)
>>> parse_expr('3 x y', transformations=transformations)
3*x*y

sympy.parsing.sympy_parser.implicit_application( tokens: List[Tuple[int, str]], local_dict: Dict[str, Any], global_dict: Dict[str, Any], ) → List[Tuple[int, str]][源代码][源代码]¶

在某些情况下，使函数调用中的括号成为可选。

在 隐式乘法() 之后使用此功能，否则像 sin 2x 这样的表达式将被解析为 x * sin(2) 而不是 sin(2*x)。

示例

>>> from sympy.parsing.sympy_parser import (parse_expr,
... standard_transformations, implicit_application)
>>> transformations = standard_transformations + (implicit_application,)
>>> parse_expr('cot z + csc z', transformations=transformations)
cot(z) + csc(z)

sympy.parsing.sympy_parser.function_exponentiation( tokens: List[Tuple[int, str]], local_dict: Dict[str, Any], global_dict: Dict[str, Any], )[源代码][源代码]¶

允许函数进行指数运算，例如 cos**2(x)。

示例

>>> from sympy.parsing.sympy_parser import (parse_expr,
... standard_transformations, function_exponentiation)
>>> transformations = standard_transformations + (function_exponentiation,)
>>> parse_expr('sin**4(x)', transformations=transformations)
sin(x)**4

sympy.parsing.sympy_parser.implicit_multiplication_application( result: List[Tuple[int, str]], local_dict: Dict[str, Any], global_dict: Dict[str, Any], ) → List[Tuple[int, str]][源代码][源代码]¶

允许稍微宽松的语法。

单参数方法调用的括号是可选的。
乘法是隐含的。
符号名称可以被拆分（即符号之间不需要空格）。
函数可以取幂。

示例

>>> from sympy.parsing.sympy_parser import (parse_expr,
... standard_transformations, implicit_multiplication_application)
>>> parse_expr("10sin**2 x**2 + 3xyz + tan theta",
... transformations=(standard_transformations +
... (implicit_multiplication_application,)))
3*x*y*z + 10*sin(x**2)**2 + tan(theta)

sympy.parsing.sympy_parser.rationalize( tokens: List[Tuple[int, str]], local_dict: Dict[str, Any], global_dict: Dict[str, Any], )[源代码][源代码]¶: 将浮点数转换为 Rational。在 auto_number 之后运行。

sympy.parsing.sympy_parser.convert_xor( tokens: List[Tuple[int, str]], local_dict: Dict[str, Any], global_dict: Dict[str, Any], )[源代码][源代码]¶: 将 XOR, ^, 视为幂运算, **。

这些包含在 sympy.parsing.sympy_parser.standard_transformations 中，通常不需要用户手动添加。

sympy.parsing.sympy_parser.lambda_notation( tokens: List[Tuple[int, str]], local_dict: Dict[str, Any], global_dict: Dict[str, Any], )[源代码][源代码]¶: 将“lambda”替换为其 SymPy 等价物 Lambda()。然而，如果仅传递“lambda”，则不会进行转换，因为那是语法错误。

sympy.parsing.sympy_parser.auto_symbol( tokens: List[Tuple[int, str]], local_dict: Dict[str, Any], global_dict: Dict[str, Any], )[源代码][源代码]¶: 为未定义的变量插入 Symbol/Function 的调用。

sympy.parsing.sympy_parser.repeated_decimals( tokens: List[Tuple[int, str]], local_dict: Dict[str, Any], global_dict: Dict[str, Any], )[源代码][源代码]¶

允许使用 0.2[1] 表示法来表示重复小数 0.2111… (19/90)

在运行 auto_number 之前执行此操作。

sympy.parsing.sympy_parser.auto_number( tokens: List[Tuple[int, str]], local_dict: Dict[str, Any], global_dict: Dict[str, Any], )[源代码][源代码]¶

将数值字面量转换为使用 SymPy 的等价形式。

复数使用 I，整数文字使用 Integer，浮点数文字使用 Float。

sympy.parsing.sympy_parser.factorial_notation( tokens: List[Tuple[int, str]], local_dict: Dict[str, Any], global_dict: Dict[str, Any], )[源代码][源代码]¶: 允许使用标准表示法表示阶乘。

实验性 \(\mathrm{\LaTeX}\) 解析¶

当前的实现是实验性的。行为、解析器后端和API可能在将来发生变化。与其他一些解析器不同，\(\mathrm{\LaTeX}\) 被设计为一种排版语言，而不是 计算机代数系统，因此可能包含多种解释的排版约定。

\(\mathrm{\LaTeX}\) 解析函数参考¶

sympy.parsing.latex.parse_latex(s, strict=False, backend='antlr')[源代码][源代码]¶

将输入的 LaTeX 字符串 s 转换为 SymPy Expr。

参数:

sstr

要解析的LaTeX字符串。在包含LaTeX的Python源代码中，*原始字符串*（以``r”表示，如本例所示）是首选，因为LaTeX大量使用``字符，这会在普通Python字符串中触发转义。

后端str, 可选

目前，支持两种后端：ANTLR 和 Lark。默认设置是使用 ANTLR 后端，如果需要，可以更改为 Lark。

使用 backend="antlr" 以使用基于 ANTLR 的解析器，使用 backend="lark" 以使用基于 Lark 的解析器。

backend 选项是区分大小写的，必须全部小写。

严格bool, 可选

此选项仅在使用 ANTLR 后端时可用。

如果为 True，则在字符串无法解析为有效的 LaTeX 时引发异常。如果为 False，则尝试从常见错误中优雅地恢复。

示例

>>> from sympy.parsing.latex import parse_latex
>>> expr = parse_latex(r"\frac {1 + \sqrt {\a}} {\b}")
>>> expr
(sqrt(a) + 1)/b
>>> expr.evalf(4, subs=dict(a=5, b=2))
1.618
>>> func = parse_latex(r"\int_1^\alpha \dfrac{\mathrm{d}t}{t}", backend="lark")
>>> func.evalf(subs={"alpha": 2})
0.693147180559945

ANTLR 后端¶

基于 ANTLR 的 \(\mathrm{\LaTeX}\) 解析器是从 latex2sympy 移植过来的。虽然功能上已经实现，其 API 应保持稳定，但解析行为或后端可能在未来的版本中发生变化。

ANTLR \(\mathrm{\LaTeX}\) 解析器注意事项¶

在其当前定义中，解析器可能无法完全解析表达式，但不会抛出警告:

parse_latex(r'x -')

将简单地找到 x。这种行为所涵盖的内容几乎肯定会在不同版本之间发生变化，并且会变得更加严格、更加宽松，或两者兼而有之。

Lark 后端¶

基于 Lark 的 LaTeX 解析器是较新的，旨在最终完全取代基于 ANTLR 的解析器。它拥有基于 ANTLR 的解析器提供的绝大多数功能，并增加了一些额外的功能。

Lark \(\mathrm{\LaTeX}\) 解析器功能¶

需要注意的是，Lark 后端不支持格式错误的表达式，并且不会尝试修复任何可能发生的常见错误。例如，如前面章节所述，基于 ANTLR 的解析器如果在运行时遇到 x，它会直接找到它:

parse_latex(r'x -', backend='ANTLR')

然而，运行:

parse_latex(r'x -', backend='Lark')

将引发一个 lark.exceptions.UnexpectedEOF 异常。

除此之外，基于 Lark 的解析器支持一些基于 ANTLR 的解析器不支持的额外功能。它们是：

检测模糊表达，以及
允许用户在运行时自定义 \(\mathrm{\LaTeX}\) 语法。

\(f(x)\) 这样的表达式在技术上是模糊的 \(\mathrm{\LaTeX}\) 表达式，因为 \(f\) 可能是一个函数或变量名。Lark 有能力指出这些模糊性并通知用户，甚至返回所有可能的解释。

基于 Lark 的解析器暴露了许多内部机制，允许用户自定义解析器的行为。例如，用户可以通过在实例化解析器时将语法文件的路径传递给 LarkLaTeXParser 来指定自己的 \(\mathrm{\LaTeX}\) 语法。

用户还可以为 \(LarkLaTeXParser\) 类指定自己的自定义转换器类。

上述两个例子可以在 test_custom_latex.py 文件中找到。

Lark \(\mathrm{\LaTeX}\) 解析器功能¶

为了使用基于 Lark 的 LaTeX 解析器，了解它的功能和局限性非常重要。由于该解析器仍处于实验阶段，它支持许多功能，但某些特性仍仅部分实现，或不可用。

因此，我们将列出它可以解析的表达式类型，然后列出一些它可能失败的感兴趣的表达式类型。

以下是支持的事项列表：

由一个字母组成的符号，例如 a, b, x 等。希腊字母和带有下标的符号也受支持。数字也受支持，例如 \infty。
支持包含多个字母的符号，只要它们被包裹在 \mathit 中。
带有 \(+\), \(-\), \(*\), \(/\) 以及替代运算符如 \cdot, \times, \div 等的表达式。如果两个表达式相邻，如 \(xy\) 或 \((\sin x)(\cos t)\)，则视为隐式乘法。
与 \(<\), \(>\), \(\le\), \(\ge\), \(=\), 和 \(\ne\) 的关系。
常用的函数如
- 平方根,
- 阶乘,
- 复共轭（如 \(\overline{z}\)）
- \(\log\),
- \(\ln\),
- \(\exp\),
- 绝对值（例如，\(|x|\)）。注意，\(||x||\) 被解析为 Abs(Abs(x))。
- floor (例如，\(\lfloor x \rfloor\)) 和 ceiling (例如，\(\lceil x \rceil\)),
- \(\min\) 和 \(\max\)。
所有三角函数及其反三角函数。像 \sin^4 这样的幂次也支持。幂次 \(-1\) 被解释为反函数（即， \sin^{-1} x 被解释为 \arcsin x）。
双曲三角函数（目前仅支持 \(\sinh\)、\(\cosh\) 和 \(\tanh\)）及其反函数。如前所述，类似 \(\tanh^2\) 的幂次也受支持，并且 \(-1\) 被解释为反函数（即，\(\tanh^{-1} x\) 被解释为 \(\arctanh x\)）。
AppliedFunctions，例如 \(f(x, y, z)\)。
支持所有类型的分数（\frac、\tfrac、\dfrac、\nicefrac）和二项式（\binom、\tbinom、\dbinom）。
积分，包括定积分和不定积分。当被积函数是分数时，允许微分在分子中。微分可以是 d、\text{d} 或 \mathrm{d}。
单变量的导数。即，类似于 \(\dfrac{d}{dx} (\sin x)\) 的东西。高阶导数和偏导数目前尚不支持。
单变量的极限。例如，\(\lim\limits_{t\to 3^{+}} \sin t\)。
带有简单条件的求和与乘积。例如，\(\sum\limits_{k=0}^n k^2\) 是被允许的，因为 \(k\) 的条件很简单。像 \(\sum\limits_{d \mid n} d^2\) 这样的表达式是不被允许的，因为在下标中 \(d\) 的条件很复杂。带有在上标中指定索引变量的表达式也是允许的。例如，\(\prod\limits_{k=0}^{k=n} k^2\) 可以被正确解析。
Bra（例如，\(| x \rangle\)）和 Ket（例如，\(\langle p |\)）符号。解析内积（例如，\(\langle x | y \rangle\)）和外积（例如，\(| y \rangle \langle x |\)）也受支持。

以下是目前不支持的功能列表（不完整），未来可能会添加：

矩阵。类似于 \begin{env}...\end{env} 的内容，其中 env 可以是 matrix、bmatrix、pmatrix、smallmatrix 和 array 中的任意一个。
矩阵操作，如矩阵加法、标量矩阵乘法、矩阵乘法。
高阶导数和偏导数。
二重积分和三重积分。

Lark \(\mathrm{\LaTeX}\) 解析器函数¶

sympy.parsing.latex.parse_latex_lark(s: str)[源代码][源代码]¶

使用 Lark 的实验性 LaTeX 解析器。

此功能仍在开发中，其API可能会随着SymPy的下一个版本发布而更改。

Lark \(\mathrm{\LaTeX}\) 解析器类¶

class sympy.parsing.latex.lark.LarkLaTeXParser( print_debug_output=False, transform=True, grammar_file=None, transformer=None, )[源代码][源代码]¶

用于将输入的 \(\mathrm{\LaTeX}\) 字符串转换为 SymPy 表达式的类。它包含所有必要的内部数据以实现此功能，并公开了用于自定义其行为的钩子。

参数:

print_debug_outputbool, 可选

如果设置为 True ，则将调试输出打印到日志记录器。默认为 False 。

变换bool, 可选

如果设置为 True ，该类会在输入字符串上运行 Lark.parse 生成的解析树上运行 Transformer 类。默认为 True 。

将其设置为 False 可以帮助调试 \(\mathrm{\LaTeX}\) 语法。

grammar_filestr, 可选

解析器应使用的语法文件的路径。如果设置为 None，它将使用默认语法，该语法位于 grammar/latex.lark，相对于 sympy/parsing/latex/lark/ 目录。

变压器str, 可选

要使用的 Transformer 类的名称。如果设置为 None，则使用默认的 transformer 类，即 TransformToSymPyExpr()。

方法

doparse

class sympy.parsing.latex.lark.TransformToSymPyExpr[源代码][源代码]¶

返回一个由遍历传递给 .transform() 函数的 lark.Tree 生成的 SymPy 表达式。

参数:

visit_tokensbool, 可选

关于此选项的作用，请参见这里。

请注意，必须将选项设置为 True 以使默认解析器工作。

方法

`DIGIT`	`Integer` 的别名
`SYMBOL`	`Symbol` 的别名

CMD_INFTY
GREEK_SYMBOL_WITH_GREEK_SUBSCRIPT
希腊符号_拉丁下标
希腊符号带撇号
拉丁符号带希腊下标
LATIN_SYMBOL_WITH_LATIN_SUBSCRIPT
abs
acosh
添加
相邻表达式
伴随矩阵
arccos
arccot
arccsc
arcsec
反正弦
arctan
asinh
atanh
二项式
胸罩
ceil
共轭
cos
cos_power
cosh
cot
cot_power
csc
csc_power
导数
行列式
微分
div
eq
指数
阶乘
地板
分数
function_applied
group_curly_parentheses
group_curly_parentheses_int
group_curly_parentheses_lim
group_curly_parentheses_special
group_round_parentheses
group_square_brackets
gt
gte
内积
integral_with_special_fraction
ket
latex_string
限制
limit_dir_expr
表达式列表
日志
lt
lte
矩阵
matrix_prime
最大值
最小值
mul
多字母符号
不
normal_integral
数字
产品
sec
sec_power
sin
sin_power
sinh
特殊分数
平方根
子
求和
上标
symbol_prime
tan
tan_power
tanh
trace
变换

注释

此类不应直接使用。

为了调整这个类的行为，需要对其进行子类化，然后在完成所需的修改后，应通过构造函数中的 transformer 参数将新类的名称传递给 LarkLaTeXParser 类。

\(\mathrm{\LaTeX}\) 解析异常参考¶

class sympy.parsing.latex.LaTeXParsingError[源代码][源代码]¶

属性:

参数

方法

with_traceback

Exception.with_traceback(tb) -- 将 self.__traceback__ 设置为 tb 并返回 self。

SymPy 表达式参考¶

class sympy.parsing.sym_expr.SymPyExpression(source_code=None, mode=None)[源代码][源代码]¶

用于存储和处理 SymPy 表达式的类

此类将保存 SymPy 表达式并处理与不同语言之间转换的 API。

它与 C 和 Fortran 解析器一起工作，生成存储在这里的 SymPy 表达式，这些表达式可以转换为多种语言的源代码。

方法

`convert_to_c`()	返回一个包含SymPy表达式的C源代码的列表
`convert_to_expr`(src_code, mode)	将给定的源代码转换为 SymPy 表达式
`convert_to_fortran`()	返回一个包含SymPy表达式的Fortran源代码的列表
`convert_to_python`()	返回一个包含 SymPy 表达式 Python 代码的列表
`return_expr`()	返回表达式列表

注释

该模块及其API目前正在开发和实验阶段，开发过程中可能会发生变化。

Fortran 解析器不支持数值赋值，因此所有变量都已初始化为零。

该模块还依赖于外部依赖项：

LFortran 是使用 Fortran 解析器所必需的
Clang，这是C解析器所必需的

示例

解析C代码的示例：

>>> from sympy.parsing.sym_expr import SymPyExpression
>>> src = '''
... int a,b;
... float c = 2, d =4;
... '''
>>> a = SymPyExpression(src, 'c')
>>> a.return_expr()
[Declaration(Variable(a, type=intc)),
Declaration(Variable(b, type=intc)),
Declaration(Variable(c, type=float32, value=2.0)),
Declaration(Variable(d, type=float32, value=4.0))]

变量定义的示例：

>>> from sympy.parsing.sym_expr import SymPyExpression
>>> src2 = '''
... integer :: a, b, c, d
... real :: p, q, r, s
... '''
>>> p = SymPyExpression()
>>> p.convert_to_expr(src2, 'f')
>>> p.convert_to_c()
['int a = 0', 'int b = 0', 'int c = 0', 'int d = 0', 'double p = 0.0', 'double q = 0.0', 'double r = 0.0', 'double s = 0.0']

赋值示例：

>>> from sympy.parsing.sym_expr import SymPyExpression
>>> src3 = '''
... integer :: a, b, c, d, e
... d = a + b - c
... e = b * d + c * e / a
... '''
>>> p = SymPyExpression(src3, 'f')
>>> p.convert_to_python()
['a = 0', 'b = 0', 'c = 0', 'd = 0', 'e = 0', 'd = a + b - c', 'e = b*d + c*e/a']

函数定义的示例：

>>> from sympy.parsing.sym_expr import SymPyExpression
>>> src = '''
... integer function f(a,b)
... integer, intent(in) :: a, b
... integer :: r
... end function
... '''
>>> a = SymPyExpression(src, 'f')
>>> a.convert_to_python()
['def f(a, b):\n   f = 0\n    r = 0\n    return f']

convert_to_c()[源代码][源代码]¶

返回一个包含SymPy表达式的C源代码的列表

示例

>>> from sympy.parsing.sym_expr import SymPyExpression
>>> src2 = '''
... integer :: a, b, c, d
... real :: p, q, r, s
... c = a/b
... d = c/a
... s = p/q
... r = q/p
... '''
>>> p = SymPyExpression()
>>> p.convert_to_expr(src2, 'f')
>>> p.convert_to_c()
['int a = 0', 'int b = 0', 'int c = 0', 'int d = 0', 'double p = 0.0', 'double q = 0.0', 'double r = 0.0', 'double s = 0.0', 'c = a/b;', 'd = c/a;', 's = p/q;', 'r = q/p;']

convert_to_expr(src_code, mode)[源代码][源代码]¶

将给定的源代码转换为 SymPy 表达式

属性:

src_code字符串: 要转换的源代码或源代码文件名
模式: 字符串: 根据源代码语言确定使用哪个解析器的模式 f 或 F 表示 Fortran c 或 C 表示 C/C++

示例

>>> from sympy.parsing.sym_expr import SymPyExpression
>>> src3 = '''
... integer function f(a,b) result(r)
... integer, intent(in) :: a, b
... integer :: x
... r = a + b -x
... end function
... '''
>>> p = SymPyExpression()
>>> p.convert_to_expr(src3, 'f')
>>> p.return_expr()
[FunctionDefinition(integer, name=f, parameters=(Variable(a), Variable(b)), body=CodeBlock(
Declaration(Variable(r, type=integer, value=0)),
Declaration(Variable(x, type=integer, value=0)),
Assignment(Variable(r), a + b - x),
Return(Variable(r))
))]

convert_to_fortran()[源代码][源代码]¶

返回一个包含SymPy表达式的Fortran源代码的列表

示例

>>> from sympy.parsing.sym_expr import SymPyExpression
>>> src2 = '''
... integer :: a, b, c, d
... real :: p, q, r, s
... c = a/b
... d = c/a
... s = p/q
... r = q/p
... '''
>>> p = SymPyExpression(src2, 'f')
>>> p.convert_to_fortran()
['      integer*4 a', '      integer*4 b', '      integer*4 c', '      integer*4 d', '      real*8 p', '      real*8 q', '      real*8 r', '      real*8 s', '      c = a/b', '      d = c/a', '      s = p/q', '      r = q/p']

convert_to_python()[源代码][源代码]¶

返回一个包含 SymPy 表达式 Python 代码的列表

示例

>>> from sympy.parsing.sym_expr import SymPyExpression
>>> src2 = '''
... integer :: a, b, c, d
... real :: p, q, r, s
... c = a/b
... d = c/a
... s = p/q
... r = q/p
... '''
>>> p = SymPyExpression(src2, 'f')
>>> p.convert_to_python()
['a = 0', 'b = 0', 'c = 0', 'd = 0', 'p = 0.0', 'q = 0.0', 'r = 0.0', 's = 0.0', 'c = a/b', 'd = c/a', 's = p/q', 'r = q/p']

return_expr()[源代码][源代码]¶

返回表达式列表

示例

>>> from sympy.parsing.sym_expr import SymPyExpression
>>> src3 = '''
... integer function f(a,b)
... integer, intent(in) :: a, b
... integer :: r
... r = a+b
... f = r
... end function
... '''
>>> p = SymPyExpression()
>>> p.convert_to_expr(src3, 'f')
>>> p.return_expr()
[FunctionDefinition(integer, name=f, parameters=(Variable(a), Variable(b)), body=CodeBlock(
Declaration(Variable(f, type=integer, value=0)),
Declaration(Variable(r, type=integer, value=0)),
Assignment(Variable(f), Variable(r)),
Return(Variable(f))
))]

运行时安装¶

当前打包的 LaTeX 解析器后端部分是使用 ANTLR4 生成的，但要使用该解析器，您只需要安装 antlr4 Python 包。

根据您的包管理器，您可以使用例如 pip 安装正确的包:

$ pip install antlr4-python3-runtime==4.11

或 conda:

$ conda install -c conda-forge antlr-python-runtime==4.11

C 解析器依赖于 clang，而 Fortran 解析器依赖于 LFortran。你可以使用以下命令安装这些包:

$ conda install -c conda-forge lfortran clang