打印¶
请参阅教程中的 打印 部分，了解打印的介绍。
本指南记录了 SymPy 中的打印系统及其内部工作原理。
打印机类¶
打印子系统驱动
SymPy 的打印系统工作方式如下：任何表达式都可以传递给指定的打印机，然后由该打印机负责返回该表达式的适当表示。
基本概念如下：
如果对象知道如何打印自己，就让它自己打印。
采用打印机中定义的最佳拟合方法。
作为备用，使用打印机的 emptyPrinter 方法。
哪个方法负责打印？¶
整个打印过程是通过在你想要使用的打印机上调用 .doprint(expr) 来启动的。这个方法会寻找一个合适的方法，该方法能够在打印机定义的给定样式中打印给定的表达式。在寻找方法的过程中，它会遵循以下步骤：
如果对象知道如何打印自己，就让它自己打印。
打印机在每个对象中寻找一个特定方法。该方法的名称取决于具体的打印机，并在
Printer.printmethod下定义。例如，StrPrinter 调用_sympystr，而 LatexPrinter 调用_latex。查看您想要使用的打印机的文档。方法名称在那里指定。这是在 SymPy 中进行打印的原始方式。每个类都有自己的 latex、mathml、str 和 repr 方法，但事实证明，如果所有方法都分散得那么远，很难生成高质量的打印机。因此，所有打印代码都被合并到不同的打印机中，这对于内置的 SymPy 对象非常有效，但对于用户定义的类来说，修补打印机并不方便。
采用打印机中定义的最佳拟合方法。
打印机遍历表达式类（类及其基类），并尝试将工作分派给
_print_<EXPR_CLASS>例如，假设我们有以下类层次结构:
Basic | Atom | Number | Rational
然后，对于
expr=Rational(...)，打印机将按照下图所示的顺序尝试调用打印机方法:p._print(expr) | |-- p._print_Rational(expr) | |-- p._print_Number(expr) | |-- p._print_Atom(expr) | `-- p._print_Basic(expr)
如果在打印机中存在
._print_Rational方法，则调用该方法，并将结果返回。否则，打印机尝试调用._print_Number等。作为备用，使用打印机的 emptyPrinter 方法。
作为回退，
self.emptyPrinter将被调用并传入表达式。如果在 Printer 子类中未定义，这将等同于str(expr)。
自定义打印机的示例¶
在下面的例子中，我们有一个打印机，它以更简短的形式打印函数的导数。
from sympy.core.symbol import Symbol
from sympy.printing.latex import LatexPrinter, print_latex
from sympy.core.function import UndefinedFunction, Function
class MyLatexPrinter(LatexPrinter):
"""Print derivative of a function of symbols in a shorter form.
"""
def _print_Derivative(self, expr):
function, *vars = expr.args
if not isinstance(type(function), UndefinedFunction) or \
not all(isinstance(i, Symbol) for i in vars):
return super()._print_Derivative(expr)
# If you want the printer to work correctly for nested
# expressions then use self._print() instead of str() or latex().
# See the example of nested modulo below in the custom printing
# method section.
return "{}_{{{}}}".format(
self._print(Symbol(function.func.__name__)),
''.join(self._print(i) for i in vars))
def print_my_latex(expr):
""" Most of the printers define their own wrappers for print().
These wrappers usually take printer settings. Our printer does not have
any settings.
"""
print(MyLatexPrinter().doprint(expr))
y = Symbol("y")
x = Symbol("x")
f = Function("f")
expr = f(x, y).diff(x, y)
# Print the expression using the normal latex printer and our custom
# printer.
print_latex(expr)
print_my_latex(expr)
上述代码的输出是:
\frac{\partial^{2}}{\partial x\partial y} f{\left(x,y \right)}
f_{xy}
自定义打印方法的示例¶
在下面的示例中，模运算符的latex打印被修改。这是通过重写 Mod 的 _latex 方法实现的。
>>> from sympy import Symbol, Mod, Integer, print_latex
>>> # Always use printer._print()
>>> class ModOp(Mod):
... def _latex(self, printer):
... a, b = [printer._print(i) for i in self.args]
... return r"\operatorname{Mod}{\left(%s, %s\right)}" % (a, b)
比较我们自定义操作符的输出与内置操作符的输出：
>>> x = Symbol('x')
>>> m = Symbol('m')
>>> print_latex(Mod(x, m))
x \bmod m
>>> print_latex(ModOp(x, m))
\operatorname{Mod}{\left(x, m\right)}
常见错误¶
在自定义打印机时，始终使用 self._print(obj) 来打印表达式的子组件是非常重要的。错误包括：
使用
self.doprint(obj)代替：>>> # This example does not work properly, as only the outermost call may use >>> # doprint. >>> class ModOpModeWrong(Mod): ... def _latex(self, printer): ... a, b = [printer.doprint(i) for i in self.args] ... return r"\operatorname{Mod}{\left(%s, %s\right)}" % (a, b)
当向打印机传递
mode参数时，此操作失败：>>> print_latex(ModOp(x, m), mode='inline') # ok $\operatorname{Mod}{\left(x, m\right)}$ >>> print_latex(ModOpModeWrong(x, m), mode='inline') # bad $\operatorname{Mod}{\left($x$, $m$\right)}$
使用
str(obj)代替：>>> class ModOpNestedWrong(Mod): ... def _latex(self, printer): ... a, b = [str(i) for i in self.args] ... return r"\operatorname{Mod}{\left(%s, %s\right)}" % (a, b)
这在嵌套对象上失败：
>>> # Nested modulo. >>> print_latex(ModOp(ModOp(x, m), Integer(7))) # ok \operatorname{Mod}{\left(\operatorname{Mod}{\left(x, m\right)}, 7\right)} >>> print_latex(ModOpNestedWrong(ModOpNestedWrong(x, m), Integer(7))) # bad \operatorname{Mod}{\left(ModOpNestedWrong(x, m), 7\right)}
使用
LatexPrinter()._print(obj)代替。>>> from sympy.printing.latex import LatexPrinter >>> class ModOpSettingsWrong(Mod): ... def _latex(self, printer): ... a, b = [LatexPrinter()._print(i) for i in self.args] ... return r"\operatorname{Mod}{\left(%s, %s\right)}" % (a, b)
这会导致所有子对象中的设置被丢弃。例如，显示浮点数到完整精度的
full_prec设置将被忽略：>>> from sympy import Float >>> print_latex(ModOp(Float(1) * x, m), full_prec=True) # ok \operatorname{Mod}{\left(1.00000000000000 x, m\right)} >>> print_latex(ModOpSettingsWrong(Float(1) * x, m), full_prec=True) # bad \operatorname{Mod}{\left(1.0 x, m\right)}
负责打印的主要类是 ``Printer``（参见其 源代码）：
- class sympy.printing.printer.Printer(settings=None)[源代码][源代码]¶
通用打印机
它的任务是为实现新的打印机提供基础设施。
如果你想为你的自定义类定义自定义打印机或自定义打印方法，请参见上面的示例：printer_example。
- 属性:
- 顺序
方法
doprint(expr)返回表达式 expr 的打印机表示（作为字符串）
set_global_settings(**settings)设置系统范围的打印设置。
- printmethod: str = None¶
PrettyPrinter 类¶
漂亮的打印子系统在 sympy.printing.pretty.pretty 中由 PrettyPrinter 类实现，该类继承自 Printer。它依赖于模块 sympy.printing.pretty.stringPict 和 sympy.printing.pretty.pretty_symbology 来渲染美观的公式。
模块 stringPict 提供了一个基类 stringPict 和一个派生类 prettyForm，它们简化了跨多行公式的创建和操作。
模块 pretty_symbology 提供了构建二维形状（如 hline、vline 等）的基本元素，并结合了一种在可能的情况下自动使用 Unicode 的技术。
- class sympy.printing.pretty.pretty.PrettyPrinter(settings=None)[源代码][源代码]¶
Printer，它将一个表达式转换为2D ASCII艺术图形。
方法
doprint(expr)- printmethod: str = '_pretty'¶
- sympy.printing.pretty.pretty.pretty(
- expr,
- *,
- order=None,
- full_prec='auto',
- use_unicode=True,
- wrap_line=True,
- num_columns=None,
- use_unicode_sqrt_char=True,
- root_notation=True,
- mat_symbol_style='plain',
- imaginary_unit='i',
- perm_cyclic=True,
返回包含 expr 的格式化形式的字符串。
关于关键字参数的信息，请参阅 pretty_print 函数。
- sympy.printing.pretty.pretty.pretty_print(expr, **kwargs)[源代码][源代码]¶
以美观的形式打印表达式。
pprint 只是这个函数的快捷方式。
- 参数:
- 表达式表达式
要打印的表达式。
- wrap_linebool, 可选 (默认=True)
行包装启用/禁用。
- num_columnsint 或 None, 可选 (默认=None)
换行前的列数（默认为 None，读取终端宽度），在使用 SymPy 时非常有用，尤其是在不使用终端的情况下。
- use_unicodebool 或 None, 可选 (默认=None)
使用Unicode字符，例如希腊字母π而不是字符串pi。
- full_prec布尔值或字符串，可选（默认值为“auto”）
使用全精度。
- 顺序bool 或 string, 可选 (默认=None)
如果表达式较长且速度慢，请设置为 ‘none’；默认值为 None。
- use_unicode_sqrt_charbool, 可选 (默认=True)
使用紧凑的单字符平方根符号（在无歧义时）。
- 根符号bool, 可选 (默认=True)
设置为 ‘False’ 以分数形式打印形式为 1/n 的指数。默认情况下，指数以根形式打印。
- mat_symbol_style字符串，可选（默认值为“plain”）
设置为“bold”以使用粗体数学符号面打印 MatrixSymbols。默认情况下使用标准面。
- 虚数单位字符串，可选（默认值为“i”）
当 use_unicode 为 True 时，用于虚数单位的字母。可以是“i”（默认）或“j”。
C 代码打印机¶
此类实现C代码打印，即将Python表达式转换为C代码字符串（另见 C89CodePrinter）。
用法:
>>> from sympy.printing import print_ccode
>>> from sympy.functions import sin, cos, Abs, gamma
>>> from sympy.abc import x
>>> print_ccode(sin(x)**2 + cos(x)**2, standard='C89')
pow(sin(x), 2) + pow(cos(x), 2)
>>> print_ccode(2*x + cos(x), assign_to="result", standard='C89')
result = 2*x + cos(x);
>>> print_ccode(Abs(x**2), standard='C89')
fabs(pow(x, 2))
>>> print_ccode(gamma(x**2), standard='C99')
tgamma(pow(x, 2))
- sympy.printing.c.known_functions_C89 = {'Abs': [(<function <lambda>>, 'fabs'), (<function <lambda>>, 'abs')], 'acos': 'acos', 'asin': 'asin', 'atan': 'atan', 'atan2': 'atan2', 'ceiling': 'ceil', 'cos': 'cos', 'cosh': 'cosh', 'exp': 'exp', 'floor': 'floor', 'log': 'log', 'sin': 'sin', 'sinh': 'sinh', 'sqrt': 'sqrt', 'tan': 'tan', 'tanh': 'tanh'}¶
!! 由 numpydoc 处理 !!
- sympy.printing.c.known_functions_C99 = {'Abs': [(<function <lambda>>, 'fabs'), (<function <lambda>>, 'abs')], 'Cbrt': 'cbrt', 'Max': 'fmax', 'Min': 'fmin', 'acos': 'acos', 'acosh': 'acosh', 'asin': 'asin', 'asinh': 'asinh', 'atan': 'atan', 'atan2': 'atan2', 'atanh': 'atanh', 'ceiling': 'ceil', 'cos': 'cos', 'cosh': 'cosh', 'erf': 'erf', 'erfc': 'erfc', 'exp': 'exp', 'exp2': 'exp2', 'expm1': 'expm1', 'floor': 'floor', 'fma': 'fma', 'gamma': 'tgamma', 'hypot': 'hypot', 'log': 'log', 'log10': 'log10', 'log1p': 'log1p', 'log2': 'log2', 'loggamma': 'lgamma', 'sin': 'sin', 'sinh': 'sinh', 'sqrt': 'sqrt', 'tan': 'tan', 'tanh': 'tanh'}¶
!! 由 numpydoc 处理 !!
- class sympy.printing.c.C89CodePrinter(settings=None)[源代码][源代码]¶
一个将 Python 表达式转换为 C 代码字符串的打印机
- 属性:
- 数学宏
- 顺序
方法
doprint(expr[, assign_to])将表达式打印为代码。
indent_code(code)接受一行代码或一个代码行列表
set_global_settings(**settings)设置系统范围的打印设置。
emptyPrinter
加括号
字符串化
- printmethod: str = '_ccode'¶
- class sympy.printing.c.C99CodePrinter(settings=None)[源代码][源代码]¶
- 属性:
- 数学宏
- 顺序
方法
doprint(expr[, assign_to])将表达式打印为代码。
indent_code(code)接受一行代码或一个代码行列表
set_global_settings(**settings)设置系统范围的打印设置。
emptyPrinter
加括号
字符串化
- printmethod: str = '_ccode'¶
- sympy.printing.c.ccode(
- expr,
- assign_to=None,
- standard='c99',
- **settings,
将一个表达式转换为C代码字符串
- 参数:
- 表达式表达式
要转换的 SymPy 表达式。
- 分配给可选的
当提供时，参数被用作表达式所赋值的变量名称。可以是字符串、
Symbol、MatrixSymbol或Indexed类型。这在行包装或生成多行语句的表达式中很有帮助。- 标准str, 可选
指定标准的字符串。如果你的编译器支持更现代的标准，你可以将此设置为 ‘c99’，以允许打印机使用更多的数学函数。[默认=’c89’]。
- 精度整数，可选
如 pi 等数字的精度 [默认=17]。
- 用户功能dict, 可选
一个字典，其中键是
FunctionClass或UndefinedFunction实例的字符串表示，值是它们所需的 C 字符串表示。或者，字典值可以是元组列表，即 [(argument_test, cfunction_string)] 或 [(argument_test, cfunction_formater)]。请参见下面的示例。- 解引用可迭代对象, 可选
一个符号的可迭代对象，这些符号应在打印的代码表达式中被解引用。这些将是通过地址传递给函数的值。例如，如果
dereference=[a]，则生成的代码将打印(*a)而不是a。- 人类bool, 可选
如果为 True，结果是一个可能包含一些数字符号常量声明的单个字符串。如果为 False，则以元组 (symbols_to_declare, not_supported_functions, code_text) 的形式返回相同的信息。[默认=True]。
- contract: bool, 可选
如果为真，
Indexed实例被假定为遵循张量收缩规则，并且生成相应的嵌套循环遍历索引。设置 contract=False 将不会生成循环，而是由用户负责在代码中提供索引的值。[默认=True]。
示例
>>> from sympy import ccode, symbols, Rational, sin, ceiling, Abs, Function >>> x, tau = symbols("x, tau") >>> expr = (2*tau)**Rational(7, 2) >>> ccode(expr) '8*M_SQRT2*pow(tau, 7.0/2.0)' >>> ccode(expr, math_macros={}) '8*sqrt(2)*pow(tau, 7.0/2.0)' >>> ccode(sin(x), assign_to="s") 's = sin(x);' >>> from sympy.codegen.ast import real, float80 >>> ccode(expr, type_aliases={real: float80}) '8*M_SQRT2l*powl(tau, 7.0L/2.0L)'
可以通过将一个包含 {“类型” : “函数”} 的字典传递给
user_functions关键字参数来为某些类型定义简单的自定义打印。或者，字典的值可以是一个元组列表，即 [(参数测试, c函数字符串)]。>>> custom_functions = { ... "ceiling": "CEIL", ... "Abs": [(lambda x: not x.is_integer, "fabs"), ... (lambda x: x.is_integer, "ABS")], ... "func": "f" ... } >>> func = Function('func') >>> ccode(func(Abs(x) + ceiling(x)), standard='C89', user_functions=custom_functions) 'f(fabs(x) + CEIL(x))'
或者如果C函数只接受原始参数的一个子集：
>>> ccode(2**x + 3**x, standard='C99', user_functions={'Pow': [ ... (lambda b, e: b == 2, lambda b, e: 'exp2(%s)' % e), ... (lambda b, e: b != 2, 'pow')]}) 'exp2(x) + pow(3, x)'
Piecewise表达式被转换为条件语句。如果提供了assign_to变量，则会创建一个 if 语句，否则使用三元运算符。请注意，如果Piecewise缺少默认项，由(expr, True)表示，则会抛出一个错误。这是为了防止生成可能无法计算出任何结果的表达式。>>> from sympy import Piecewise >>> expr = Piecewise((x + 1, x > 0), (x, True)) >>> print(ccode(expr, tau, standard='C89')) if (x > 0) { tau = x + 1; } else { tau = x; }
循环的支持通过
Indexed类型提供。使用contract=True这些表达式将被转换为循环，而contract=False将仅打印应循环的赋值表达式：>>> from sympy import Eq, IndexedBase, Idx >>> len_y = 5 >>> y = IndexedBase('y', shape=(len_y,)) >>> t = IndexedBase('t', shape=(len_y,)) >>> Dy = IndexedBase('Dy', shape=(len_y-1,)) >>> i = Idx('i', len_y-1) >>> e=Eq(Dy[i], (y[i+1]-y[i])/(t[i+1]-t[i])) >>> ccode(e.rhs, assign_to=e.lhs, contract=False, standard='C89') 'Dy[i] = (y[i + 1] - y[i])/(t[i + 1] - t[i]);'
矩阵也被支持，但必须提供相同维度的
MatrixSymbol给assign_to。请注意，任何可以正常生成的表达式也可以存在于矩阵内部：>>> from sympy import Matrix, MatrixSymbol >>> mat = Matrix([x**2, Piecewise((x + 1, x > 0), (x, True)), sin(x)]) >>> A = MatrixSymbol('A', 3, 1) >>> print(ccode(mat, A, standard='C89')) A[0] = pow(x, 2); if (x > 0) { A[1] = x + 1; } else { A[1] = x; } A[2] = sin(x);
C++ 代码打印机¶
此模块包含用于 C++ 代码的打印机，即用于将 SymPy 表达式转换为 C++ 代码字符串的函数。
用法:
>>> from sympy.printing import cxxcode
>>> from sympy.functions import Min, gamma
>>> from sympy.abc import x
>>> print(cxxcode(Min(gamma(x) - 1, x), standard='C++11'))
std::min(x, std::tgamma(x) - 1)
- class sympy.printing.cxx.CXX98CodePrinter(settings=None)[源代码][源代码]¶
- 属性:
- 数学宏
- 顺序
方法
doprint(expr[, assign_to])将表达式打印为代码。
indent_code(code)接受一行代码或一个代码行列表
set_global_settings(**settings)设置系统范围的打印设置。
emptyPrinter
加括号
字符串化
- printmethod: str = '_cxxcode'¶
RCodePrinter¶
此类实现了 R 代码打印（即将 Python 表达式转换为 R 代码字符串）。
用法:
>>> from sympy.printing import print_rcode
>>> from sympy.functions import sin, cos, Abs
>>> from sympy.abc import x
>>> print_rcode(sin(x)**2 + cos(x)**2)
sin(x)^2 + cos(x)^2
>>> print_rcode(2*x + cos(x), assign_to="result")
result = 2*x + cos(x);
>>> print_rcode(Abs(x**2))
abs(x^2)
- sympy.printing.rcode.known_functions = {'Abs': 'abs', 'Max': 'max', 'Min': 'min', 'acos': 'acos', 'acosh': 'acosh', 'asin': 'asin', 'asinh': 'asinh', 'atan': 'atan', 'atan2': 'atan2', 'atanh': 'atanh', 'beta': 'beta', 'ceiling': 'ceiling', 'cos': 'cos', 'cosh': 'cosh', 'digamma': 'digamma', 'erf': 'erf', 'exp': 'exp', 'factorial': 'factorial', 'floor': 'floor', 'gamma': 'gamma', 'log': 'log', 'sign': 'sign', 'sin': 'sin', 'sinh': 'sinh', 'sqrt': 'sqrt', 'tan': 'tan', 'tanh': 'tanh', 'trigamma': 'trigamma'}¶
!! 由 numpydoc 处理 !!
- class sympy.printing.rcode.RCodePrinter(settings={})[源代码][源代码]¶
一个将 SymPy 表达式转换为 R 代码字符串的打印机
- 属性:
- 顺序
方法
doprint(expr[, assign_to])将表达式打印为代码。
indent_code(code)接受一行代码或一个代码行列表
set_global_settings(**settings)设置系统范围的打印设置。
emptyPrinter
加括号
字符串化
- printmethod: str = '_rcode'¶
- sympy.printing.rcode.rcode(expr, assign_to=None, **settings)[源代码][源代码]¶
将一个表达式转换为R代码的字符串
- 参数:
- 表达式表达式
要转换的 SymPy 表达式。
- 分配给可选的
当提供时，参数被用作表达式所赋值的变量名称。可以是字符串、
Symbol、MatrixSymbol或Indexed类型。这在行包装或生成多行语句的表达式中很有帮助。- 精度整数，可选
如 pi 等数字的精度 [默认=15]。
- 用户功能dict, 可选
一个字典，其中键是
FunctionClass或UndefinedFunction实例的字符串表示，值是它们所需的 R 字符串表示。或者，字典值可以是元组列表，即 [(argument_test, rfunction_string)] 或 [(argument_test, rfunction_formater)]。请参见下面的示例。- 人类bool, 可选
如果为 True，结果是一个可能包含一些数字符号常量声明的单个字符串。如果为 False，则以元组 (symbols_to_declare, not_supported_functions, code_text) 的形式返回相同的信息。[默认=True]。
- contract: bool, 可选
如果为真，
Indexed实例被假定为遵循张量收缩规则，并且生成相应的嵌套循环遍历索引。设置 contract=False 将不会生成循环，而是由用户负责在代码中提供索引的值。[默认=True]。
示例
>>> from sympy import rcode, symbols, Rational, sin, ceiling, Abs, Function >>> x, tau = symbols("x, tau") >>> rcode((2*tau)**Rational(7, 2)) '8*sqrt(2)*tau^(7.0/2.0)' >>> rcode(sin(x), assign_to="s") 's = sin(x);'
可以通过将一个包含 {“类型” : “函数”} 的字典传递给
user_functions关键字参数来为某些类型定义简单的自定义打印。或者，字典的值可以是一个元组列表，即 [(参数测试, c函数字符串)]。>>> custom_functions = { ... "ceiling": "CEIL", ... "Abs": [(lambda x: not x.is_integer, "fabs"), ... (lambda x: x.is_integer, "ABS")], ... "func": "f" ... } >>> func = Function('func') >>> rcode(func(Abs(x) + ceiling(x)), user_functions=custom_functions) 'f(fabs(x) + CEIL(x))'
或者如果 R-函数 只接受原始参数的一个子集：
>>> rcode(2**x + 3**x, user_functions={'Pow': [ ... (lambda b, e: b == 2, lambda b, e: 'exp2(%s)' % e), ... (lambda b, e: b != 2, 'pow')]}) 'exp2(x) + pow(3, x)'
Piecewise表达式被转换为条件语句。如果提供了assign_to变量，则会创建一个 if 语句，否则使用三元运算符。请注意，如果Piecewise缺少默认项，由(expr, True)表示，则会抛出一个错误。这是为了防止生成可能无法计算出任何结果的表达式。>>> from sympy import Piecewise >>> expr = Piecewise((x + 1, x > 0), (x, True)) >>> print(rcode(expr, assign_to=tau)) tau = ifelse(x > 0,x + 1,x);
循环的支持通过
Indexed类型提供。使用contract=True这些表达式将被转换为循环，而contract=False将仅打印应循环的赋值表达式：>>> from sympy import Eq, IndexedBase, Idx >>> len_y = 5 >>> y = IndexedBase('y', shape=(len_y,)) >>> t = IndexedBase('t', shape=(len_y,)) >>> Dy = IndexedBase('Dy', shape=(len_y-1,)) >>> i = Idx('i', len_y-1) >>> e=Eq(Dy[i], (y[i+1]-y[i])/(t[i+1]-t[i])) >>> rcode(e.rhs, assign_to=e.lhs, contract=False) 'Dy[i] = (y[i + 1] - y[i])/(t[i + 1] - t[i]);'
矩阵也被支持，但必须提供相同维度的
MatrixSymbol给assign_to。请注意，任何可以正常生成的表达式也可以存在于矩阵内部：>>> from sympy import Matrix, MatrixSymbol >>> mat = Matrix([x**2, Piecewise((x + 1, x > 0), (x, True)), sin(x)]) >>> A = MatrixSymbol('A', 3, 1) >>> print(rcode(mat, A)) A[0] = x^2; A[1] = ifelse(x > 0,x + 1,x); A[2] = sin(x);
Fortran 打印¶
fcode 函数将 sympy 表达式转换为 Fortran 代码。其主要目的是减轻手动翻译长数学表达式的负担。因此，生成的表达式也应不需要（或很少需要）手动调整即可编译。fcode 的可选参数可以用来微调 fcode 的行为，使得结果不再需要手动修改。
- sympy.printing.fortran.fcode(expr, assign_to=None, **settings)[源代码][源代码]¶
将一个表达式转换为Fortran代码的字符串
- 参数:
- 表达式表达式
要转换的 SymPy 表达式。
- 分配给可选的
当提供时，参数被用作表达式所赋值的变量名称。可以是字符串、
Symbol、MatrixSymbol或Indexed类型。这在行包装或生成多行语句的表达式中很有帮助。- 精度整数，可选
已弃用。请改用 type_mappings。数字如 pi 的精度 [默认=17]。
- 用户功能dict, 可选
一个字典，其中键是
FunctionClass实例，值是它们的字符串表示。或者，字典值可以是元组列表，即 [(argument_test, cfunction_string)]。请参见下面的示例。- 人类bool, 可选
如果为 True，结果是一个可能包含一些数字符号常量声明的单个字符串。如果为 False，则以元组 (symbols_to_declare, not_supported_functions, code_text) 的形式返回相同的信息。[默认=True]。
- contract: bool, 可选
如果为真，
Indexed实例被假定为遵循张量收缩规则，并且生成相应的嵌套循环遍历索引。设置 contract=False 将不会生成循环，而是由用户负责在代码中提供索引的值。[默认=True]。- 源格式可选的
源格式可以是 ‘fixed’ 或 ‘free’。[默认=’fixed’]
- 标准整数，可选
要遵循的 Fortran 标准。这被指定为一个整数。可接受的标准是 66、77、90、95、2003 和 2008。默认是 77。请注意，目前内部唯一的区别是 95 之前和 95 之后的标准。随着更多功能的添加，这可能会在以后发生变化。
- 名称修饰bool, 可选
如果为 True，那么在 Fortran 中不区分大小写的情况下会变得相同的变量，将在末尾附加不同数量的
_以进行混淆。如果为 False，SymPy 将不会干涉变量的命名。[默认=True]
示例
>>> from sympy import fcode, symbols, Rational, sin, ceiling, floor >>> x, tau = symbols("x, tau") >>> fcode((2*tau)**Rational(7, 2)) ' 8*sqrt(2.0d0)*tau**(7.0d0/2.0d0)' >>> fcode(sin(x), assign_to="s") ' s = sin(x)'
可以通过向
user_functionskwarg 传递一个 “type” : “function” 的字典来为某些类型定义自定义打印。或者，字典值可以是一个元组列表，即 [(argument_test, cfunction_string)]。>>> custom_functions = { ... "ceiling": "CEIL", ... "floor": [(lambda x: not x.is_integer, "FLOOR1"), ... (lambda x: x.is_integer, "FLOOR2")] ... } >>> fcode(floor(x) + ceiling(x), user_functions=custom_functions) ' CEIL(x) + FLOOR1(x)'
Piecewise表达式被转换为条件语句。如果提供了assign_to变量，则会创建一个 if 语句，否则使用三元运算符。请注意，如果Piecewise缺少默认项，由(expr, True)表示，则会抛出一个错误。这是为了防止生成可能无法计算出任何结果的表达式。>>> from sympy import Piecewise >>> expr = Piecewise((x + 1, x > 0), (x, True)) >>> print(fcode(expr, tau)) if (x > 0) then tau = x + 1 else tau = x end if
循环的支持通过
Indexed类型提供。使用contract=True这些表达式将被转换为循环，而contract=False将仅打印应循环的赋值表达式：>>> from sympy import Eq, IndexedBase, Idx >>> len_y = 5 >>> y = IndexedBase('y', shape=(len_y,)) >>> t = IndexedBase('t', shape=(len_y,)) >>> Dy = IndexedBase('Dy', shape=(len_y-1,)) >>> i = Idx('i', len_y-1) >>> e=Eq(Dy[i], (y[i+1]-y[i])/(t[i+1]-t[i])) >>> fcode(e.rhs, assign_to=e.lhs, contract=False) ' Dy(i) = (y(i + 1) - y(i))/(t(i + 1) - t(i))'
矩阵也被支持，但必须提供相同维度的
MatrixSymbol给assign_to。请注意，任何可以正常生成的表达式也可以存在于矩阵内部：>>> from sympy import Matrix, MatrixSymbol >>> mat = Matrix([x**2, Piecewise((x + 1, x > 0), (x, True)), sin(x)]) >>> A = MatrixSymbol('A', 3, 1) >>> print(fcode(mat, A)) A(1, 1) = x**2 if (x > 0) then A(2, 1) = x + 1 else A(2, 1) = x end if A(3, 1) = sin(x)
- sympy.printing.fortran.print_fcode(expr, **settings)[源代码][源代码]¶
打印给定表达式的 Fortran 表示形式。
参见 fcode 以了解可选参数的含义。
- class sympy.printing.fortran.FCodePrinter(settings=None)[源代码][源代码]¶
一个将 SymPy 表达式转换为 Fortran 代码字符串的打印机
- 属性:
- 顺序
方法
doprint(expr[, assign_to])将表达式打印为代码。
indent_code(code)接受一行代码或一个代码行列表
set_global_settings(**settings)设置系统范围的打印设置。
emptyPrinter
加括号
字符串化
- printmethod: str = '_fcode'¶
两个基本示例：
>>> from sympy import *
>>> x = symbols("x")
>>> fcode(sqrt(1-x**2))
' sqrt(1 - x**2)'
>>> fcode((3 + 4*I)/(1 - conjugate(x)))
' (cmplx(3,4))/(1 - conjg(x))'
需要换行的示例：
>>> expr = sqrt(1-x**2).series(x,n=20).removeO()
>>> print(fcode(expr))
-715.0d0/65536.0d0*x**18 - 429.0d0/32768.0d0*x**16 - 33.0d0/
@ 2048.0d0*x**14 - 21.0d0/1024.0d0*x**12 - 7.0d0/256.0d0*x**10 -
@ 5.0d0/128.0d0*x**8 - 1.0d0/16.0d0*x**6 - 1.0d0/8.0d0*x**4 - 1.0d0
@ /2.0d0*x**2 + 1
在换行的情况下，包含赋值部分是很方便的，这样在添加赋值部分时，行可以正确地换行。
>>> print(fcode(expr, assign_to="var"))
var = -715.0d0/65536.0d0*x**18 - 429.0d0/32768.0d0*x**16 - 33.0d0/
@ 2048.0d0*x**14 - 21.0d0/1024.0d0*x**12 - 7.0d0/256.0d0*x**10 -
@ 5.0d0/128.0d0*x**8 - 1.0d0/16.0d0*x**6 - 1.0d0/8.0d0*x**4 - 1.0d0
@ /2.0d0*x**2 + 1
对于分段函数，assign_to 选项是必需的：
>>> print(fcode(Piecewise((x,x<1),(x**2,True)), assign_to="var"))
if (x < 1) then
var = x
else
var = x**2
end if
请注意，由于Fortran 77缺乏条件运算符，默认情况下仅支持顶层分段函数。通过设置关键字参数 standard=95 ，可以使用Fortran 95中引入的 merge 函数来支持内联条件。
>>> print(fcode(Piecewise((x,x<1),(x**2,True)), standard=95))
merge(x, x**2, x < 1)
如果在表达式中存在索引对象，则会生成循环。这也需要使用 assign_to 选项。
>>> A, B = map(IndexedBase, ['A', 'B'])
>>> m = Symbol('m', integer=True)
>>> i = Idx('i', m)
>>> print(fcode(2*B[i], assign_to=A[i]))
do i = 1, m
A(i) = 2*B(i)
end do
在包含Indexed对象的表达式中，重复的索引被解释为求和。例如，可以使用代码生成矩阵的迹。
>>> print(fcode(A[i, i], assign_to=x))
x = 0
do i = 1, m
x = x + A(i, i)
end do
默认情况下，诸如 pi 和 E 之类的数字符号会被检测并定义为 Fortran 参数。常数的精度可以通过精度参数进行调整。使用 N 函数可以轻松避免参数定义。
>>> print(fcode(x - pi**2 - E))
parameter (E = 2.7182818284590452d0)
parameter (pi = 3.1415926535897932d0)
x - pi**2 - E
>>> print(fcode(x - pi**2 - E, precision=25))
parameter (E = 2.718281828459045235360287d0)
parameter (pi = 3.141592653589793238462643d0)
x - pi**2 - E
>>> print(fcode(N(x - pi**2, 25)))
x - 9.869604401089358618834491d0
当某些函数不属于 Fortran 标准时，可能需要在 Fortran 表达式中引入用户定义的函数名称。
>>> print(fcode(1 - gamma(x)**2, user_functions={'gamma': 'mygamma'}))
1 - mygamma(x)**2
然而，当未提供 user_functions 参数时，fcode 默认会引发一个异常，但如果用户打算提供一个同名函数，仍可以通过传递 strict=False 选项来生成代码。此时，代码中会包含一条注释，告知用户该问题：
>>> print(fcode(1 - gamma(x)**2, strict=False))
C Not supported in Fortran:
C gamma
1 - gamma(x)**2
打印机可以配置为省略这些注释：
>>> print(fcode(1 - gamma(x)**2, allow_unknown_functions=True))
1 - gamma(x)**2
默认情况下，输出是人类可读的代码，准备好复制和粘贴。使用选项 human=False，返回值适合用源代码生成器进行后处理，这些生成器编写包含多条指令的例程。返回值是一个三元组，包含：(i) 一组必须定义为 ‘Fortran 参数’ 的数字符号，(ii) 一个无法在纯 Fortran 中翻译的函数列表，以及 (iii) 一个 Fortran 代码字符串。一些例子：
>>> fcode(1 - gamma(x)**2, human=False)
(set(), {gamma(x)}, ' 1 - gamma(x)**2')
>>> fcode(1 - sin(x)**2, human=False)
(set(), set(), ' 1 - sin(x)**2')
>>> fcode(x - pi**2, human=False)
({(pi, '3.1415926535897932d0')}, set(), ' x - pi**2')
SMT-Lib 打印¶
- class sympy.printing.smtlib.SMTLibPrinter(
- settings: dict | None = None,
- symbol_table=None,
- 属性:
- 顺序
方法
doprint(expr)返回表达式 expr 的打印机表示（作为字符串）
set_global_settings(**settings)设置系统范围的打印设置。
emptyPrinter
- printmethod: str = '_smtlib'¶
- _default_settings: dict = {'known_constants': {}, 'known_functions': {<class 'sympy.core.add.Add'>: '+', <class 'sympy.core.mul.Mul'>: '*', <class 'sympy.core.power.Pow'>: 'pow', <class 'sympy.core.relational.Equality'>: '=', <class 'sympy.core.relational.GreaterThan'>: '>=', <class 'sympy.core.relational.LessThan'>: '<=', <class 'sympy.core.relational.StrictGreaterThan'>: '>', <class 'sympy.core.relational.StrictLessThan'>: '<', Abs: 'abs', And: 'and', ITE: 'ite', Implies: '=>', Max: 'max', Min: 'min', Not: 'not', Or: 'or', Q.eq: '=', Q.ge: '>=', Q.gt: '>', Q.le: '<=', Q.lt: '<', Xor: 'xor', acos: 'arccos', asin: 'arcsin', atan: 'arctan', atan2: 'arctan2', cos: 'cos', cosh: 'cosh', exp: 'exp', log: 'log', sin: 'sin', sinh: 'sinh', tan: 'tan', tanh: 'tanh'}, 'known_types': {<class 'bool'>: 'Bool', <class 'float'>: 'Real', <class 'int'>: 'Int'}, 'precision': None}¶
- sympy.printing.smtlib.smtlib_code(
- expr,
- auto_assert=True,
- auto_declare=True,
- precision=None,
- symbol_table=None,
- known_types=None,
- known_constants=None,
- known_functions=None,
- prefix_expressions=None,
- suffix_expressions=None,
- log_warn=None,
将
expr转换为 smtlib 代码的字符串。- 参数:
- 表达式Expr | List[Expr]
要转换的 SymPy 表达式或系统。
- auto_assertbool, 可选
如果为假，不修改 expr 并仅生成 expr 的 S-表达式等价物。如果为真，假设 expr 是一个系统并断言每个布尔元素。
- 自动声明bool, 可选
如果为假，则不为 expr 中使用的符号生成声明。如果为真，则根据 symbol_table 为 expr 中使用的所有变量预先添加必要的声明。
- 精度整数，可选
evalf(..)对于诸如 pi 这样的数字的精度。- 符号表dict, 可选
一个字典，其中键是
Symbol或Function实例，值是它们的 Python 类型，即bool、int、float或Callable[...]。如果信息不完整，将尝试从expr推断类型。- known_types: dict, 可选
一个字典，其中键为
bool、int、float等，值为它们对应的 SMT 类型名称。如果没有给出，将使用与多个求解器兼容的部分列表。- 已知函数dict, 可选
一个字典，其中键是
Function、Relational、BooleanFunction或Expr实例，值是它们的 SMT 字符串表示。如果未提供，将使用针对 dReal 求解器优化的部分列表（但与其他求解器兼容）。- known_constants: dict, 可选
一个字典，其中键是
NumberSymbol实例，值是它们的 SMT 变量名。使用此功能时，必须格外小心，以避免用户符号与列出的常量之间的命名冲突。如果未提供，常量将内联展开，例如3.14159而不是MY_SMT_VARIABLE_FOR_PI。- prefix_expressions: list, 可选
一个包含
str和/或表达式的列表，将其转换为 SMTLib 并添加到输出前缀。- suffix_expressions: list, 可选
一个由
str和/或表达式组成的列表，将转换为 SMTLib 并附加到输出中。- log_warn: lambda 函数, 可选
一个用于记录在潜在风险操作期间所有警告的函数。健全性是 SMT 求解中的核心价值，因此记录所有假设是很好的做法。
示例
>>> from sympy import smtlib_code, symbols, sin, Eq >>> x = symbols('x') >>> smtlib_code(sin(x).series(x).removeO(), log_warn=print) Could not infer type of `x`. Defaulting to float. Non-Boolean expression `x**5/120 - x**3/6 + x` will not be asserted. Converting to SMTLib verbatim. '(declare-const x Real)\n(+ x (* (/ -1 6) (pow x 3)) (* (/ 1 120) (pow x 5)))'
>>> from sympy import Rational >>> x, y, tau = symbols("x, y, tau") >>> smtlib_code((2*tau)**Rational(7, 2), log_warn=print) Could not infer type of `tau`. Defaulting to float. Non-Boolean expression `8*sqrt(2)*tau**(7/2)` will not be asserted. Converting to SMTLib verbatim. '(declare-const tau Real)\n(* 8 (pow 2 (/ 1 2)) (pow tau (/ 7 2)))'
Piecewise表达式默认通过ite表达式实现。请注意，如果Piecewise缺少一个默认项，由(expr, True)表示，那么将会抛出一个错误。这是为了防止生成一个可能无法计算出结果的表达式。>>> from sympy import Piecewise >>> pw = Piecewise((x + 1, x > 0), (x, True)) >>> smtlib_code(Eq(pw, 3), symbol_table={x: float}, log_warn=print) '(declare-const x Real)\n(assert (= (ite (> x 0) (+ 1 x) x) 3))'
可以通过将 PythonType : “SMT 名称” 的字典传递给
known_types、known_constants和known_functions关键字参数，为某些类型定义自定义打印。>>> from typing import Callable >>> from sympy import Function, Add >>> f = Function('f') >>> g = Function('g') >>> smt_builtin_funcs = { # functions our SMT solver will understand ... f: "existing_smtlib_fcn", ... Add: "sum", ... } >>> user_def_funcs = { # functions defined by the user must have their types specified explicitly ... g: Callable[[int], float], ... } >>> smtlib_code(f(x) + g(x), symbol_table=user_def_funcs, known_functions=smt_builtin_funcs, log_warn=print) Non-Boolean expression `f(x) + g(x)` will not be asserted. Converting to SMTLib verbatim. '(declare-const x Int)\n(declare-fun g (Int) Real)\n(sum (existing_smtlib_fcn x) (g x))'
Mathematica 代码打印¶
- sympy.printing.mathematica.known_functions = {'Chi': [(<function <lambda>>, 'CoshIntegral')], 'Ci': [(<function <lambda>>, 'CosIntegral')], 'DiracDelta': [(<function <lambda>>, 'DiracDelta')], 'Ei': [(<function <lambda>>, 'ExpIntegralEi')], 'FallingFactorial': [(<function <lambda>>, 'FactorialPower')], 'Heaviside': [(<function <lambda>>, 'HeavisideTheta')], 'KroneckerDelta': [(<function <lambda>>, 'KroneckerDelta')], 'Max': [(<function <lambda>>, 'Max')], 'Min': [(<function <lambda>>, 'Min')], 'RisingFactorial': [(<function <lambda>>, 'Pochhammer')], 'Shi': [(<function <lambda>>, 'SinhIntegral')], 'Si': [(<function <lambda>>, 'SinIntegral')], 'acos': [(<function <lambda>>, 'ArcCos')], 'acosh': [(<function <lambda>>, 'ArcCosh')], 'acot': [(<function <lambda>>, 'ArcCot')], 'acoth': [(<function <lambda>>, 'ArcCoth')], 'acsc': [(<function <lambda>>, 'ArcCsc')], 'acsch': [(<function <lambda>>, 'ArcCsch')], 'airyai': [(<function <lambda>>, 'AiryAi')], 'airyaiprime': [(<function <lambda>>, 'AiryAiPrime')], 'airybi': [(<function <lambda>>, 'AiryBi')], 'airybiprime': [(<function <lambda>>, 'AiryBiPrime')], 'appellf1': [(<function <lambda>>, 'AppellF1')], 'asec': [(<function <lambda>>, 'ArcSec')], 'asech': [(<function <lambda>>, 'ArcSech')], 'asin': [(<function <lambda>>, 'ArcSin')], 'asinh': [(<function <lambda>>, 'ArcSinh')], 'assoc_laguerre': [(<function <lambda>>, 'LaguerreL')], 'assoc_legendre': [(<function <lambda>>, 'LegendreP')], 'atan': [(<function <lambda>>, 'ArcTan')], 'atan2': [(<function <lambda>>, 'ArcTan')], 'atanh': [(<function <lambda>>, 'ArcTanh')], 'besseli': [(<function <lambda>>, 'BesselI')], 'besselj': [(<function <lambda>>, 'BesselJ')], 'besselk': [(<function <lambda>>, 'BesselK')], 'bessely': [(<function <lambda>>, 'BesselY')], 'beta': [(<function <lambda>>, 'Beta')], 'catalan': [(<function <lambda>>, 'CatalanNumber')], 'chebyshevt': [(<function <lambda>>, 'ChebyshevT')], 'chebyshevu': [(<function <lambda>>, 'ChebyshevU')], 'conjugate': [(<function <lambda>>, 'Conjugate')], 'cos': [(<function <lambda>>, 'Cos')], 'cosh': [(<function <lambda>>, 'Cosh')], 'cot': [(<function <lambda>>, 'Cot')], 'coth': [(<function <lambda>>, 'Coth')], 'csc': [(<function <lambda>>, 'Csc')], 'csch': [(<function <lambda>>, 'Csch')], 'dirichlet_eta': [(<function <lambda>>, 'DirichletEta')], 'elliptic_e': [(<function <lambda>>, 'EllipticE')], 'elliptic_f': [(<function <lambda>>, 'EllipticE')], 'elliptic_k': [(<function <lambda>>, 'EllipticK')], 'elliptic_pi': [(<function <lambda>>, 'EllipticPi')], 'erf': [(<function <lambda>>, 'Erf')], 'erf2': [(<function <lambda>>, 'Erf')], 'erf2inv': [(<function <lambda>>, 'InverseErf')], 'erfc': [(<function <lambda>>, 'Erfc')], 'erfcinv': [(<function <lambda>>, 'InverseErfc')], 'erfi': [(<function <lambda>>, 'Erfi')], 'erfinv': [(<function <lambda>>, 'InverseErf')], 'exp': [(<function <lambda>>, 'Exp')], 'expint': [(<function <lambda>>, 'ExpIntegralE')], 'factorial': [(<function <lambda>>, 'Factorial')], 'factorial2': [(<function <lambda>>, 'Factorial2')], 'fresnelc': [(<function <lambda>>, 'FresnelC')], 'fresnels': [(<function <lambda>>, 'FresnelS')], 'gamma': [(<function <lambda>>, 'Gamma')], 'gcd': [(<function <lambda>>, 'GCD')], 'gegenbauer': [(<function <lambda>>, 'GegenbauerC')], 'hankel1': [(<function <lambda>>, 'HankelH1')], 'hankel2': [(<function <lambda>>, 'HankelH2')], 'harmonic': [(<function <lambda>>, 'HarmonicNumber')], 'hermite': [(<function <lambda>>, 'HermiteH')], 'hyper': [(<function <lambda>>, 'HypergeometricPFQ')], 'jacobi': [(<function <lambda>>, 'JacobiP')], 'jn': [(<function <lambda>>, 'SphericalBesselJ')], 'laguerre': [(<function <lambda>>, 'LaguerreL')], 'lcm': [(<function <lambda>>, 'LCM')], 'legendre': [(<function <lambda>>, 'LegendreP')], 'lerchphi': [(<function <lambda>>, 'LerchPhi')], 'li': [(<function <lambda>>, 'LogIntegral')], 'log': [(<function <lambda>>, 'Log')], 'loggamma': [(<function <lambda>>, 'LogGamma')], 'lucas': [(<function <lambda>>, 'LucasL')], 'mathieuc': [(<function <lambda>>, 'MathieuC')], 'mathieucprime': [(<function <lambda>>, 'MathieuCPrime')], 'mathieus': [(<function <lambda>>, 'MathieuS')], 'mathieusprime': [(<function <lambda>>, 'MathieuSPrime')], 'meijerg': [(<function <lambda>>, 'MeijerG')], 'polygamma': [(<function <lambda>>, 'PolyGamma')], 'polylog': [(<function <lambda>>, 'PolyLog')], 'riemann_xi': [(<function <lambda>>, 'RiemannXi')], 'sec': [(<function <lambda>>, 'Sec')], 'sech': [(<function <lambda>>, 'Sech')], 'sin': [(<function <lambda>>, 'Sin')], 'sinc': [(<function <lambda>>, 'Sinc')], 'sinh': [(<function <lambda>>, 'Sinh')], 'sqrt': [(<function <lambda>>, 'Sqrt')], 'stieltjes': [(<function <lambda>>, 'StieltjesGamma')], 'subfactorial': [(<function <lambda>>, 'Subfactorial')], 'tan': [(<function <lambda>>, 'Tan')], 'tanh': [(<function <lambda>>, 'Tanh')], 'uppergamma': [(<function <lambda>>, 'Gamma')], 'yn': [(<function <lambda>>, 'SphericalBesselY')], 'zeta': [(<function <lambda>>, 'Zeta')]}¶
!! 由 numpydoc 处理 !!
Maple 代码打印¶
- class sympy.printing.maple.MapleCodePrinter(settings=None)[源代码][源代码]¶
将 SymPy 表达式转换为 maple 代码的打印机。
- 属性:
- 顺序
方法
doprint(expr[, assign_to])将表达式打印为代码。
set_global_settings(**settings)设置系统范围的打印设置。
emptyPrinter
加括号
字符串化
- printmethod: str = '_maple'¶
- sympy.printing.maple.maple_code(expr, assign_to=None, **settings)[源代码][源代码]¶
将
expr转换为 Maple 代码的字符串。- 参数:
- 表达式表达式
要转换的 SymPy 表达式。
- 分配给可选的
当提供时，参数被用作表达式所赋值的变量名称。可以是字符串、
Symbol、MatrixSymbol或Indexed类型。这对于生成多行语句的表达式非常有帮助。- 精度整数，可选
如 pi 等数字的精度 [默认=16]。
- 用户功能dict, 可选
一个字典，其中键是
FunctionClass实例，值是它们的字符串表示。或者，字典值可以是元组列表，即 [(参数测试, c函数字符串)]。请参见下面的示例。- 人类bool, 可选
如果为 True，结果是一个可能包含一些数字符号常量声明的单个字符串。如果为 False，则以元组 (symbols_to_declare, not_supported_functions, code_text) 的形式返回相同的信息。[默认=True]。
- contract: bool, 可选
如果为真，
Indexed实例被假定为遵循张量收缩规则，并且生成相应的嵌套循环遍历索引。设置 contract=False 将不会生成循环，而是由用户负责在代码中提供索引的值。[默认=True]。- inline: bool, 可选
如果为真，我们尝试创建单语句代码而不是多语句代码。[默认=True]。
- sympy.printing.maple.print_maple_code(expr, **settings)[源代码][源代码]¶
打印给定表达式的 Maple 表示。
参见
maple_code()以了解可选参数的含义。示例
>>> from sympy import print_maple_code, symbols >>> x, y = symbols('x y') >>> print_maple_code(x, assign_to=y) y := x
Javascript 代码打印¶
- sympy.printing.jscode.known_functions = {'Abs': 'Math.abs', 'Max': 'Math.max', 'Min': 'Math.min', 'acos': 'Math.acos', 'acosh': 'Math.acosh', 'asin': 'Math.asin', 'asinh': 'Math.asinh', 'atan': 'Math.atan', 'atan2': 'Math.atan2', 'atanh': 'Math.atanh', 'ceiling': 'Math.ceil', 'cos': 'Math.cos', 'cosh': 'Math.cosh', 'exp': 'Math.exp', 'floor': 'Math.floor', 'log': 'Math.log', 'sign': 'Math.sign', 'sin': 'Math.sin', 'sinh': 'Math.sinh', 'tan': 'Math.tan', 'tanh': 'Math.tanh'}¶
!! 由 numpydoc 处理 !!
- class sympy.printing.jscode.JavascriptCodePrinter(settings={})[源代码][源代码]¶
一个将 Python 表达式转换为 JavaScript 代码字符串的打印机
- 属性:
- 顺序
方法
doprint(expr[, assign_to])将表达式打印为代码。
indent_code(code)接受一行代码或一个代码行列表
set_global_settings(**settings)设置系统范围的打印设置。
emptyPrinter
加括号
字符串化
- printmethod: str = '_javascript'¶
- sympy.printing.jscode.jscode(expr, assign_to=None, **settings)[源代码][源代码]¶
将一个表达式转换为一段 JavaScript 代码字符串
- 参数:
- 表达式表达式
要转换的 SymPy 表达式。
- 分配给可选的
当提供时，参数被用作表达式所赋值的变量名称。可以是字符串、
Symbol、MatrixSymbol或Indexed类型。这在行包装或生成多行语句的表达式中很有帮助。- 精度整数，可选
如 pi 等数字的精度 [默认=15]。
- 用户功能dict, 可选
一个字典，其中键是
FunctionClass实例，值是它们的字符串表示。或者，字典值可以是一个元组列表，即 [(参数测试, js_函数字符串)]。请参见下面的示例。- 人类bool, 可选
如果为 True，结果是一个可能包含一些数字符号常量声明的单个字符串。如果为 False，则以元组 (symbols_to_declare, not_supported_functions, code_text) 的形式返回相同的信息。[默认=True]。
- contract: bool, 可选
如果为真，
Indexed实例被假定为遵循张量收缩规则，并且生成相应的嵌套循环遍历索引。设置 contract=False 将不会生成循环，而是由用户负责在代码中提供索引的值。[默认=True]。
示例
>>> from sympy import jscode, symbols, Rational, sin, ceiling, Abs >>> x, tau = symbols("x, tau") >>> jscode((2*tau)**Rational(7, 2)) '8*Math.sqrt(2)*Math.pow(tau, 7/2)' >>> jscode(sin(x), assign_to="s") 's = Math.sin(x);'
可以通过向
user_functionskwarg 传递一个 “类型” : “函数” 的字典来为某些类型定义自定义打印。或者，字典值可以是一个元组列表，即 [(参数测试, js函数字符串)]。>>> custom_functions = { ... "ceiling": "CEIL", ... "Abs": [(lambda x: not x.is_integer, "fabs"), ... (lambda x: x.is_integer, "ABS")] ... } >>> jscode(Abs(x) + ceiling(x), user_functions=custom_functions) 'fabs(x) + CEIL(x)'
Piecewise表达式被转换为条件语句。如果提供了assign_to变量，则会创建一个 if 语句，否则使用三元运算符。请注意，如果Piecewise缺少默认项，由(expr, True)表示，则会抛出一个错误。这是为了防止生成可能无法计算出任何结果的表达式。>>> from sympy import Piecewise >>> expr = Piecewise((x + 1, x > 0), (x, True)) >>> print(jscode(expr, tau)) if (x > 0) { tau = x + 1; } else { tau = x; }
循环的支持通过
Indexed类型提供。使用contract=True这些表达式将被转换为循环，而contract=False将仅打印应循环的赋值表达式：>>> from sympy import Eq, IndexedBase, Idx >>> len_y = 5 >>> y = IndexedBase('y', shape=(len_y,)) >>> t = IndexedBase('t', shape=(len_y,)) >>> Dy = IndexedBase('Dy', shape=(len_y-1,)) >>> i = Idx('i', len_y-1) >>> e=Eq(Dy[i], (y[i+1]-y[i])/(t[i+1]-t[i])) >>> jscode(e.rhs, assign_to=e.lhs, contract=False) 'Dy[i] = (y[i + 1] - y[i])/(t[i + 1] - t[i]);'
矩阵也被支持，但必须提供相同维度的
MatrixSymbol给assign_to。请注意，任何可以正常生成的表达式也可以存在于矩阵内部：>>> from sympy import Matrix, MatrixSymbol >>> mat = Matrix([x**2, Piecewise((x + 1, x > 0), (x, True)), sin(x)]) >>> A = MatrixSymbol('A', 3, 1) >>> print(jscode(mat, A)) A[0] = Math.pow(x, 2); if (x > 0) { A[1] = x + 1; } else { A[1] = x; } A[2] = Math.sin(x);
Julia 代码打印¶
- sympy.printing.julia.known_fcns_src1 = ['sin', 'cos', 'tan', 'cot', 'sec', 'csc', 'asin', 'acos', 'atan', 'acot', 'asec', 'acsc', 'sinh', 'cosh', 'tanh', 'coth', 'sech', 'csch', 'asinh', 'acosh', 'atanh', 'acoth', 'asech', 'acsch', 'sinc', 'atan2', 'sign', 'floor', 'log', 'exp', 'cbrt', 'sqrt', 'erf', 'erfc', 'erfi', 'factorial', 'gamma', 'digamma', 'trigamma', 'polygamma', 'beta', 'airyai', 'airyaiprime', 'airybi', 'airybiprime', 'besselj', 'bessely', 'besseli', 'besselk', 'erfinv', 'erfcinv']¶
内置的可变序列。
如果没有给出参数，构造函数会创建一个新的空列表。如果指定了参数，它必须是一个可迭代对象。
- sympy.printing.julia.known_fcns_src2 = {'Abs': 'abs', 'ceiling': 'ceil', 'conjugate': 'conj', 'hankel1': 'hankelh1', 'hankel2': 'hankelh2', 'im': 'imag', 're': 'real'}¶
!! 由 numpydoc 处理 !!
- class sympy.printing.julia.JuliaCodePrinter(settings={})[源代码][源代码]¶
一个将表达式转换为 Julia 代码字符串的打印机。
- 属性:
- 顺序
方法
doprint(expr[, assign_to])将表达式打印为代码。
indent_code(code)接受一行代码或一个代码行列表
set_global_settings(**settings)设置系统范围的打印设置。
emptyPrinter
加括号
字符串化
- printmethod: str = '_julia'¶
- sympy.printing.julia.julia_code(expr, assign_to=None, **settings)[源代码][源代码]¶
将 \(expr\) 转换为 Julia 代码的字符串。
- 参数:
- 表达式表达式
要转换的 SymPy 表达式。
- 分配给可选的
当提供时，参数被用作表达式所赋值的变量名称。可以是字符串、
Symbol、MatrixSymbol或Indexed类型。这对于生成多行语句的表达式非常有帮助。- 精度整数，可选
如 pi 等数字的精度 [默认=16]。
- 用户功能dict, 可选
一个字典，其中键是
FunctionClass实例，值是它们的字符串表示。或者，字典值可以是元组列表，即 [(参数测试, c函数字符串)]。请参见下面的示例。- 人类bool, 可选
如果为 True，结果是一个可能包含一些数字符号常量声明的单个字符串。如果为 False，则以元组 (symbols_to_declare, not_supported_functions, code_text) 的形式返回相同的信息。[默认=True]。
- contract: bool, 可选
如果为真，
Indexed实例被假定为遵循张量收缩规则，并且生成相应的嵌套循环遍历索引。设置 contract=False 将不会生成循环，而是由用户负责在代码中提供索引的值。[默认=True]。- inline: bool, 可选
如果为真，我们尝试创建单语句代码而不是多语句代码。[默认=True]。
示例
>>> from sympy import julia_code, symbols, sin, pi >>> x = symbols('x') >>> julia_code(sin(x).series(x).removeO()) 'x .^ 5 / 120 - x .^ 3 / 6 + x'
>>> from sympy import Rational, ceiling >>> x, y, tau = symbols("x, y, tau") >>> julia_code((2*tau)**Rational(7, 2)) '8 * sqrt(2) * tau .^ (7 // 2)'
注意，默认情况下在符号之间使用逐元素（Hadamard）操作。这是因为Julia中可以编写“矢量化”代码。如果值是标量，则这是无害的。
>>> julia_code(sin(pi*x*y), assign_to="s") 's = sin(pi * x .* y)'
如果你需要矩阵乘积“*”或矩阵幂“^”，你可以将符号指定为
MatrixSymbol。>>> from sympy import Symbol, MatrixSymbol >>> n = Symbol('n', integer=True, positive=True) >>> A = MatrixSymbol('A', n, n) >>> julia_code(3*pi*A**3) '(3 * pi) * A ^ 3'
此类使用几条规则来决定使用哪个符号进行乘法。纯数字使用“*”，符号使用“.*”，MatrixSymbols使用“*”。可以使用HadamardProduct来指定两个MatrixSymbols的逐元素乘法“.*”。目前没有简单的方法来指定标量符号，因此有时代码可能会有一些小的外观问题。例如，假设x和y是标量，A是矩阵，那么虽然人类程序员可能会写“(x^2*y)*A^3”，但我们生成的是：
>>> julia_code(x**2*y*A**3) '(x .^ 2 .* y) * A ^ 3'
矩阵支持使用 Julia 内联表示法。在使用
assign_to处理矩阵时，名称可以指定为字符串或MatrixSymbol。在后一种情况下，维度必须对齐。>>> from sympy import Matrix, MatrixSymbol >>> mat = Matrix([[x**2, sin(x), ceiling(x)]]) >>> julia_code(mat, assign_to='A') 'A = [x .^ 2 sin(x) ceil(x)]'
Piecewise表达式默认通过逻辑掩码实现。或者，你可以传递 “inline=False” 来使用 if-else 条件。注意，如果Piecewise缺少默认项，由(expr, True)表示，则会抛出错误。这是为了防止生成可能无法评估的表达式。>>> from sympy import Piecewise >>> pw = Piecewise((x + 1, x > 0), (x, True)) >>> julia_code(pw, assign_to=tau) 'tau = ((x > 0) ? (x + 1) : (x))'
请注意，任何可以正常生成的表达式也可以存在于矩阵中：
>>> mat = Matrix([[x**2, pw, sin(x)]]) >>> julia_code(mat, assign_to='A') 'A = [x .^ 2 ((x > 0) ? (x + 1) : (x)) sin(x)]'
可以通过向
user_functionskwarg 传递一个 “类型” : “函数” 的字典来为某些类型定义自定义打印。 或者，字典值可以是一个元组列表，即 [(参数测试, c函数字符串)]。 这可以用于调用自定义的 Julia 函数。>>> from sympy import Function >>> f = Function('f') >>> g = Function('g') >>> custom_functions = { ... "f": "existing_julia_fcn", ... "g": [(lambda x: x.is_Matrix, "my_mat_fcn"), ... (lambda x: not x.is_Matrix, "my_fcn")] ... } >>> mat = Matrix([[1, x]]) >>> julia_code(f(x) + g(x) + g(mat), user_functions=custom_functions) 'existing_julia_fcn(x) + my_fcn(x) + my_mat_fcn([1 x])'
循环的支持通过
Indexed类型提供。使用contract=True这些表达式将被转换为循环，而contract=False将仅打印应循环的赋值表达式：>>> from sympy import Eq, IndexedBase, Idx >>> len_y = 5 >>> y = IndexedBase('y', shape=(len_y,)) >>> t = IndexedBase('t', shape=(len_y,)) >>> Dy = IndexedBase('Dy', shape=(len_y-1,)) >>> i = Idx('i', len_y-1) >>> e = Eq(Dy[i], (y[i+1]-y[i])/(t[i+1]-t[i])) >>> julia_code(e.rhs, assign_to=e.lhs, contract=False) 'Dy[i] = (y[i + 1] - y[i]) ./ (t[i + 1] - t[i])'
Octave (和 Matlab) 代码打印¶
- sympy.printing.octave.known_fcns_src1 = ['sin', 'cos', 'tan', 'cot', 'sec', 'csc', 'asin', 'acos', 'acot', 'atan', 'atan2', 'asec', 'acsc', 'sinh', 'cosh', 'tanh', 'coth', 'csch', 'sech', 'asinh', 'acosh', 'atanh', 'acoth', 'asech', 'acsch', 'erfc', 'erfi', 'erf', 'erfinv', 'erfcinv', 'besseli', 'besselj', 'besselk', 'bessely', 'bernoulli', 'beta', 'euler', 'exp', 'factorial', 'floor', 'fresnelc', 'fresnels', 'gamma', 'harmonic', 'log', 'polylog', 'sign', 'zeta', 'legendre']¶
内置的可变序列。
如果没有给出参数，构造函数会创建一个新的空列表。如果指定了参数，它必须是一个可迭代对象。
- sympy.printing.octave.known_fcns_src2 = {'Abs': 'abs', 'Chi': 'coshint', 'Ci': 'cosint', 'DiracDelta': 'dirac', 'Heaviside': 'heaviside', 'LambertW': 'lambertw', 'Max': 'max', 'Min': 'min', 'Mod': 'mod', 'RisingFactorial': 'pochhammer', 'Shi': 'sinhint', 'Si': 'sinint', 'arg': 'angle', 'binomial': 'bincoeff', 'ceiling': 'ceil', 'chebyshevt': 'chebyshevT', 'chebyshevu': 'chebyshevU', 'conjugate': 'conj', 'im': 'imag', 'laguerre': 'laguerreL', 'li': 'logint', 'loggamma': 'gammaln', 'polygamma': 'psi', 're': 'real'}¶
!! 由 numpydoc 处理 !!
- class sympy.printing.octave.OctaveCodePrinter(settings={})[源代码][源代码]¶
一个将表达式转换为 Octave/Matlab 代码字符串的打印机。
- 属性:
- 顺序
方法
doprint(expr[, assign_to])将表达式打印为代码。
indent_code(code)接受一行代码或一个代码行列表
set_global_settings(**settings)设置系统范围的打印设置。
emptyPrinter
加括号
字符串化
- printmethod: str = '_octave'¶
- sympy.printing.octave.octave_code(expr, assign_to=None, **settings)[源代码][源代码]¶
将 \(expr\) 转换为 Octave（或 Matlab）代码的字符串。
该字符串使用了Octave语言的一个子集，以实现与Matlab的兼容性。
- 参数:
- 表达式表达式
要转换的 SymPy 表达式。
- 分配给可选的
当提供时，参数被用作表达式所赋值的变量名称。可以是字符串、
Symbol、MatrixSymbol或Indexed类型。这对于生成多行语句的表达式非常有帮助。- 精度整数，可选
如 pi 等数字的精度 [默认=16]。
- 用户功能dict, 可选
一个字典，其中键是
FunctionClass实例，值是它们的字符串表示。或者，字典值可以是元组列表，即 [(参数测试, c函数字符串)]。请参见下面的示例。- 人类bool, 可选
如果为 True，结果是一个可能包含一些数字符号常量声明的单个字符串。如果为 False，则以元组 (symbols_to_declare, not_supported_functions, code_text) 的形式返回相同的信息。[默认=True]。
- contract: bool, 可选
如果为真，
Indexed实例被假定为遵循张量收缩规则，并且生成相应的嵌套循环遍历索引。设置 contract=False 将不会生成循环，而是由用户负责在代码中提供索引的值。[默认=True]。- inline: bool, 可选
如果为真，我们尝试创建单语句代码而不是多语句代码。[默认=True]。
示例
>>> from sympy import octave_code, symbols, sin, pi >>> x = symbols('x') >>> octave_code(sin(x).series(x).removeO()) 'x.^5/120 - x.^3/6 + x'
>>> from sympy import Rational, ceiling >>> x, y, tau = symbols("x, y, tau") >>> octave_code((2*tau)**Rational(7, 2)) '8*sqrt(2)*tau.^(7/2)'
注意，默认情况下在符号之间使用逐元素（Hadamard）操作。这是因为Octave中非常常见编写“向量化”代码。如果值是标量，这是无害的。
>>> octave_code(sin(pi*x*y), assign_to="s") 's = sin(pi*x.*y);'
如果你需要矩阵乘积“*”或矩阵幂“^”，你可以将符号指定为
MatrixSymbol。>>> from sympy import Symbol, MatrixSymbol >>> n = Symbol('n', integer=True, positive=True) >>> A = MatrixSymbol('A', n, n) >>> octave_code(3*pi*A**3) '(3*pi)*A^3'
此类使用几条规则来决定使用哪个符号进行乘法。纯数字使用“*”，符号使用“.*”，MatrixSymbols使用“*”。可以使用HadamardProduct来指定两个MatrixSymbols的逐元素乘法“.*”。目前没有简单的方法来指定标量符号，因此有时代码可能会有一些小的外观问题。例如，假设x和y是标量，A是矩阵，那么虽然人类程序员可能会写“(x^2*y)*A^3”，但我们生成的是：
>>> octave_code(x**2*y*A**3) '(x.^2.*y)*A^3'
矩阵支持使用 Octave 内联表示法。在使用
assign_to处理矩阵时，名称可以指定为字符串或MatrixSymbol。在后一种情况下，维度必须对齐。>>> from sympy import Matrix, MatrixSymbol >>> mat = Matrix([[x**2, sin(x), ceiling(x)]]) >>> octave_code(mat, assign_to='A') 'A = [x.^2 sin(x) ceil(x)];'
Piecewise表达式默认通过逻辑掩码实现。或者，你可以传递 “inline=False” 来使用 if-else 条件。注意，如果Piecewise缺少默认项，由(expr, True)表示，则会抛出错误。这是为了防止生成可能无法评估的表达式。>>> from sympy import Piecewise >>> pw = Piecewise((x + 1, x > 0), (x, True)) >>> octave_code(pw, assign_to=tau) 'tau = ((x > 0).*(x + 1) + (~(x > 0)).*(x));'
请注意，任何可以正常生成的表达式也可以存在于矩阵中：
>>> mat = Matrix([[x**2, pw, sin(x)]]) >>> octave_code(mat, assign_to='A') 'A = [x.^2 ((x > 0).*(x + 1) + (~(x > 0)).*(x)) sin(x)];'
可以通过将 “type” : “function” 的字典传递给
user_functionskwarg 来为某些类型定义自定义打印。或者，字典值可以是元组列表，即 [(argument_test, cfunction_string)]。这可以用于调用自定义的 Octave 函数。>>> from sympy import Function >>> f = Function('f') >>> g = Function('g') >>> custom_functions = { ... "f": "existing_octave_fcn", ... "g": [(lambda x: x.is_Matrix, "my_mat_fcn"), ... (lambda x: not x.is_Matrix, "my_fcn")] ... } >>> mat = Matrix([[1, x]]) >>> octave_code(f(x) + g(x) + g(mat), user_functions=custom_functions) 'existing_octave_fcn(x) + my_fcn(x) + my_mat_fcn([1 x])'
循环的支持通过
Indexed类型提供。使用contract=True这些表达式将被转换为循环，而contract=False将仅打印应循环的赋值表达式：>>> from sympy import Eq, IndexedBase, Idx >>> len_y = 5 >>> y = IndexedBase('y', shape=(len_y,)) >>> t = IndexedBase('t', shape=(len_y,)) >>> Dy = IndexedBase('Dy', shape=(len_y-1,)) >>> i = Idx('i', len_y-1) >>> e = Eq(Dy[i], (y[i+1]-y[i])/(t[i+1]-t[i])) >>> octave_code(e.rhs, assign_to=e.lhs, contract=False) 'Dy(i) = (y(i + 1) - y(i))./(t(i + 1) - t(i));'
Rust 代码打印¶
- sympy.printing.rust.known_functions = {'Abs': 'abs', 'Max': 'max', 'Min': 'min', 'Pow': [(<function <lambda>>, 'recip', 2), (<function <lambda>>, 'sqrt', 2), (<function <lambda>>, 'sqrt().recip', 2), (<function <lambda>>, 'cbrt', 2), (<function <lambda>>, 'exp2', 3), (<function <lambda>>, 'powi', 1), (<function <lambda>>, 'powf', 1)], 'acos': 'acos', 'acosh': 'acosh', 'asin': 'asin', 'asinh': 'asinh', 'atan': 'atan', 'atan2': 'atan2', 'atanh': 'atanh', 'cos': 'cos', 'cosh': 'cosh', 'exp': [(<function <lambda>>, 'exp', 2)], 'float_ceiling': 'ceil', 'float_floor': 'floor', 'log': 'ln', 'sign': 'signum', 'sin': 'sin', 'sinh': 'sinh', 'sqrt': 'sqrt', 'tan': 'tan', 'tanh': 'tanh'}¶
!! 由 numpydoc 处理 !!
- class sympy.printing.rust.RustCodePrinter(settings={})[源代码][源代码]¶
一个将 SymPy 表达式转换为 Rust 代码字符串的打印机
- 属性:
- 顺序
方法
doprint(expr[, assign_to])将表达式打印为代码。
indent_code(code)接受一行代码或一个代码行列表
set_global_settings(**settings)设置系统范围的打印设置。
emptyPrinter
加括号
字符串化
- printmethod: str = '_rust_code'¶
- sympy.printing.codeprinter.rust_code(expr, assign_to=None, **settings)[源代码][源代码]¶
将一个表达式转换为Rust代码的字符串
- 参数:
- 表达式表达式
要转换的 SymPy 表达式。
- 分配给可选的
当提供时，参数被用作表达式所赋值的变量名称。可以是字符串、
Symbol、MatrixSymbol或Indexed类型。这在行包装或生成多行语句的表达式中很有帮助。- 精度整数，可选
如 pi 等数字的精度 [默认=15]。
- 用户功能dict, 可选
一个字典，其中键是
FunctionClass或UndefinedFunction实例的字符串表示，值是它们所需的 C 字符串表示。或者，字典值可以是元组列表，即 [(argument_test, cfunction_string)]。请参见下面的示例。- 解引用可迭代对象, 可选
一个符号的可迭代对象，这些符号应在打印的代码表达式中被解引用。这些将是通过地址传递给函数的值。例如，如果
dereference=[a]，则生成的代码将打印(*a)而不是a。- 人类bool, 可选
如果为 True，结果是一个可能包含一些数字符号常量声明的单个字符串。如果为 False，则以元组 (symbols_to_declare, not_supported_functions, code_text) 的形式返回相同的信息。[默认=True]。
- contract: bool, 可选
如果为真，
Indexed实例被假定为遵循张量收缩规则，并且生成相应的嵌套循环遍历索引。设置 contract=False 将不会生成循环，而是由用户负责在代码中提供索引的值。[默认=True]。
示例
>>> from sympy import rust_code, symbols, Rational, sin, ceiling, Abs, Function >>> x, tau = symbols("x, tau") >>> rust_code((2*tau)**Rational(7, 2)) '8.0*1.4142135623731*tau.powf(7_f64/2.0)' >>> rust_code(sin(x), assign_to="s") 's = x.sin();'
可以通过将一个包含 {“类型” : “函数”} 的字典传递给
user_functions关键字参数来为某些类型定义简单的自定义打印。或者，字典的值可以是一个元组列表，即 [(参数测试, c函数字符串)]。>>> custom_functions = { ... "ceiling": "CEIL", ... "Abs": [(lambda x: not x.is_integer, "fabs", 4), ... (lambda x: x.is_integer, "ABS", 4)], ... "func": "f" ... } >>> func = Function('func') >>> rust_code(func(Abs(x) + ceiling(x)), user_functions=custom_functions) '(fabs(x) + x.ceil()).f()'
Piecewise表达式被转换为条件语句。如果提供了assign_to变量，则会创建一个 if 语句，否则使用三元运算符。请注意，如果Piecewise缺少默认项，由(expr, True)表示，则会抛出一个错误。这是为了防止生成可能无法计算出任何结果的表达式。>>> from sympy import Piecewise >>> expr = Piecewise((x + 1, x > 0), (x, True)) >>> print(rust_code(expr, tau)) tau = if (x > 0.0) { x + 1 } else { x };
循环的支持通过
Indexed类型提供。使用contract=True这些表达式将被转换为循环，而contract=False将仅打印应循环的赋值表达式：>>> from sympy import Eq, IndexedBase, Idx >>> len_y = 5 >>> y = IndexedBase('y', shape=(len_y,)) >>> t = IndexedBase('t', shape=(len_y,)) >>> Dy = IndexedBase('Dy', shape=(len_y-1,)) >>> i = Idx('i', len_y-1) >>> e=Eq(Dy[i], (y[i+1]-y[i])/(t[i+1]-t[i])) >>> rust_code(e.rhs, assign_to=e.lhs, contract=False) 'Dy[i] = (y[i + 1] - y[i])/(t[i + 1] - t[i]);'
矩阵也被支持，但必须提供相同维度的
MatrixSymbol给assign_to。请注意，任何可以正常生成的表达式也可以存在于矩阵内部：>>> from sympy import Matrix, MatrixSymbol >>> mat = Matrix([x**2, Piecewise((x + 1, x > 0), (x, True)), sin(x)]) >>> A = MatrixSymbol('A', 3, 1) >>> print(rust_code(mat, A)) A = [x.powi(2), if (x > 0.0) { x + 1 } else { x }, x.sin()];
Aesara 代码打印¶
- class sympy.printing.aesaracode.AesaraPrinter(*args, **kwargs)[源代码][源代码]¶
创建 Aesara 符号表达式图的代码打印机。
- 参数:
- 缓存dict
要使用的缓存字典。如果为 None（默认），将使用全局缓存。要创建一个不依赖或不改变全局状态的打印机，请传递一个空字典。注意：字典在打印机初始化时不会被复制，并且会在原地更新，因此在创建多个打印机或多次调用
aesara_code()或aesara_function()时使用相同的字典对象意味着缓存在所有这些应用之间共享。
- 属性:
- 缓存dict
一个为 SymPy 符号类对象（例如
sympy.core.symbol.Symbol或sympy.matrices.expressions.MatrixSymbol）创建的 Aesara 变量的缓存。这用于确保在表达式（或多个表达式）中对给定符号的所有引用都打印为相同的 Aesara 变量，该变量仅创建一次。符号仅通过名称和类型进行区分。缓存内容的形式应被用户视为不透明。
方法
doprint(expr[, dtypes, broadcastables])将 SymPy 表达式转换为 Aesara 图变量。
set_global_settings(**settings)设置系统范围的打印设置。
emptyPrinter
- printmethod: str = '_aesara'¶
- doprint(
- expr,
- dtypes=None,
- broadcastables=None,
将 SymPy 表达式转换为 Aesara 图变量。
dtypes和broadcastables参数用于指定与expr中的自由符号对应的 Aesara 变量的数据类型、维度和广播行为。每个参数都是一个从 SymPy 符号到aesara.tensor.var.TensorVariable相应参数值的映射。有关Aesara中广播的更多信息，请参阅相应的 文档页面。
- 参数:
- 表达式sympy.core.expr.Expr
SymPy 表达式以打印。
- dtypesdict
从 SymPy 符号到 Aesara 数据类型的映射，用于为这些符号创建新的 Aesara 变量时使用。对应于
aesara.tensor.var.TensorVariable的dtype参数。对于未包含在映射中的符号，默认为'floatX'。- 可广播的dict
从 SymPy 符号到
aesara.tensor.var.TensorVariable的broadcastable参数值的映射，用于在为这些符号创建 Aesara 变量时使用。默认情况下，未包含在映射中的符号使用空元组（结果为标量）。
- 返回:
- aesara.graph.basic.Variable
在 Aesara 符号表达式图中，对应于表达式值的变量。
- sympy.printing.aesaracode.aesara_code(expr, cache=None, **kwargs)[源代码][源代码]¶
将 SymPy 表达式转换为 Aesara 图变量。
- 参数:
- 表达式sympy.core.expr.Expr
要转换的 SymPy 表达式对象。
- 缓存dict
缓存的 Aesara 变量（参见
AesaraPrinter.cache）。默认为模块级的全局缓存。- dtypesdict
- 可广播的dict
- 返回:
- aesara.graph.basic.Variable
在 Aesara 符号表达式图中，对应于表达式值的变量。
- sympy.printing.aesaracode.aesara_function(
- inputs,
- outputs,
- scalar=False,
- *,
- dim=None,
- dims=None,
- broadcastables=None,
- **kwargs,
从 SymPy 表达式创建一个 Aesara 函数。
输入和输出通过
aesara_code()转换为 Aesara 变量，然后传递给aesara.function。- 参数:
- 输入
构成函数输入的符号序列。
- 输出
构成函数输出(s)的表达式序列。每个表达式的自由符号必须是
inputs的子集。- 标量布尔
将输出中的0维数组转换为标量。这将返回一个围绕Aesara函数对象的Python包装函数。
- 缓存dict
缓存的 Aesara 变量（参见
AesaraPrinter.cache）。默认为模块级的全局缓存。- dtypesdict
- 可广播的dict
- 维度dict
broadcastables参数的替代方案。从inputs的元素映射到表示其关联数组/张量维度的整数。如果给出，将覆盖broadcastables参数。- 暗淡整数
broadcastables参数的另一个替代方案。所有数组/张量使用的公共维度数量。aesara_function([x, y], [...], dim=2)等同于使用broadcastables={x: (False, False), y: (False, False)}。
- 返回:
- 可调用
一个可调用对象，它以
inputs的值作为位置参数，并为outputs中的每个表达式返回一个输出数组。如果outputs是单个表达式，函数将返回一个 Numpy 数组；如果是多个表达式的列表，函数将返回一个数组列表。有关在列表中传递单个输出时的行为，请参见上面的squeeze参数描述。返回的对象将是aesara.compile.function.types.Function的实例或围绕其的 Python 包装函数。在两种情况下，返回的值都将具有指向aesara.function返回值的aesara_function属性。
参见
示例
>>> from sympy.abc import x, y, z >>> from sympy.printing.aesaracode import aesara_function
一个带有一个输入和一个输出的简单函数：
>>> f1 = aesara_function([x], [x**2 - 1], scalar=True) >>> f1(3) 8.0
一个具有多个输入和一个输出的函数：
>>> f2 = aesara_function([x, y, z], [(x**z + y**z)**(1/z)], scalar=True) >>> f2(3, 4, 2) 5.0
一个具有多个输入和多个输出的函数：
>>> f3 = aesara_function([x, y], [x**2 + y**2, x**2 - y**2], scalar=True) >>> f3(2, 3) [13.0, -5.0]
- sympy.printing.aesaracode.dim_handling(
- inputs,
- dim=None,
- dims=None,
- broadcastables=None,
从
aesara_function()的关键字参数中获取aesara_code()的broadcastables参数的值。为向后兼容而包含。
- 参数:
- 输入
输入符号的序列。
- 暗淡整数
所有输入的常见维度数量。如果给出，将覆盖其他参数。
- 维度dict
从输入符号到维数的映射。如果给出，将覆盖
broadcastables参数。- 可广播的dict
broadcastables参数的显式值传递给AesaraPrinter.doprint()。如果该值不为 None，函数将返回此值不变。
- 返回:
- dict
字典映射
inputs的元素到它们的“可广播”值（bool的元组）。
Gtk¶
你可以使用位于 sympy.printing.gtk 中的函数 print_gtk 将内容打印到一个 gtkmathview 小部件（在某些系统中，这需要安装 gtkmathview 和 libgtkmathview-bin）。
GtkMathView 接受 MathML，因此这种渲染依赖于表达式的 MathML 表示。
用法:
from sympy import *
print_gtk(x**2 + 2*exp(x**3))
LambdaPrinter¶
这些类实现了打印字符串的功能，这些字符串可以被 sympy.utilities.lambdify.lambdify() 函数使用。
LatexPrinter¶
此类实现 LaTeX 打印。参见 sympy.printing.latex。
- sympy.printing.latex.accepted_latex_functions = ['arcsin', 'arccos', 'arctan', 'sin', 'cos', 'tan', 'sinh', 'cosh', 'tanh', 'sqrt', 'ln', 'log', 'sec', 'csc', 'cot', 'coth', 're', 'im', 'frac', 'root', 'arg']¶
内置的可变序列。
如果没有给出参数，构造函数会创建一个新的空列表。如果指定了参数，它必须是一个可迭代对象。
- class sympy.printing.latex.LatexPrinter(settings=None)[源代码][源代码]¶
- 属性:
- 顺序
方法
doprint(expr)保护上标
set_global_settings(**settings)设置系统范围的打印设置。
emptyPrinter
加括号
- printmethod: str = '_latex'¶
- sympy.printing.latex.latex(
- expr,
- *,
- full_prec=False,
- fold_frac_powers=False,
- fold_func_brackets=False,
- fold_short_frac=None,
- inv_trig_style='abbreviated',
- itex=False,
- ln_notation=False,
- long_frac_ratio=None,
- mat_delim='[',
- mat_str=None,
- mode='plain',
- mul_symbol=None,
- order=None,
- symbol_names={},
- root_notation=True,
- mat_symbol_style='plain',
- imaginary_unit='i',
- gothic_re_im=False,
- decimal_separator='period',
- perm_cyclic=True,
- parenthesize_super=True,
- min=None,
- max=None,
- diff_operator='d',
- adjoint_style='dagger',
将给定的表达式转换为 LaTeX 字符串表示。
- 参数:
- full_prec: boolean, 可选
如果设置为 True，浮点数将以完整精度打印。
- fold_frac_powers布尔值，可选
对于分数幂，发出
^{p/q}而不是^{\frac{p}{q}}。- fold_func_brackets布尔值，可选
在适用的地方折叠函数括号。
- fold_short_frac布尔值，可选
当分母足够简单时（最多两个项且没有幂），发出
p / q而不是\frac{p}{q}。默认值在行内模式下为True，否则为False。- inv_trig_style字符串，可选
反三角函数应如何显示。可以是
'abbreviated'、'full'或'power'之一。默认为'abbreviated'。- itex布尔值，可选
指定是否使用 itex 特定的语法，包括发出
$$...$$。- ln_notation布尔值，可选
如果设置为
True，则使用\ln代替默认的\log。- long_frac_ratio浮点数或无，可选
在打印机断开长分数之前，分子宽度与分母宽度之间的允许比例。如果为
None（默认值），则不会断开长分数。- mat_delim字符串，可选
用于环绕矩阵的分隔符。可以是
'['、'('或空字符串''。默认为'['。- mat_str字符串，可选
要发出的矩阵环境字符串。
'smallmatrix'、'matrix'、'array'等。默认情况下，行内模式为'smallmatrix'，不超过 10 列的矩阵为'matrix'，其他情况为'array'。- 模式: 字符串, 可选
指定生成的代码将如何分隔。
mode可以是'plain'、'inline'、'equation'或'equation*'之一。如果mode设置为'plain'，那么结果代码将不会被分隔（这是默认设置）。如果mode设置为'inline'，那么将使用行内 LaTeX$...$。如果mode设置为'equation'或'equation*'，结果代码将被包含在equation或equation*环境中（记得为equation*导入amsmath），除非设置了itex选项。在后一种情况下，将使用$$...$$语法。- mul_symbol字符串或无，可选
用于乘法的符号。可以是以下之一：
None、'ldot'、'dot'或'times'。- order: string, 可选
任何支持的单项式排序（目前为
'lex'、'grlex'或'grevlex'）、'old'和'none'。此参数对 \(~.Mul\) 对象无效。将排序设置为'old'使用 Printer 中定义的~.Add的兼容排序。如果对速度有要求，对于非常大的表达式，请将order关键字设置为'none'。- 符号名称字符串映射到符号的字典，可选
符号及其应输出的自定义字符串的字典。
- 根符号布尔值，可选
如果设置为
False，形式为 1/n 的指数将以分数形式打印。默认值为True，以根形式打印指数。- mat_symbol_style字符串，可选
可以是
'plain'``（默认）或 ``'bold'。如果设置为'bold'，一个 \(~.MatrixSymbol\) A 将被打印为\mathbf{A}，否则为A。- 虚数单位字符串，可选
用于虚数单位的字符串。定义的选项有
'i'``（默认）和 ``'j'。在前面添加r或t会生成\mathrm或\text，因此'ri'会生成\mathrm{i}，即 \(\mathrm{i}\)。- gothic_re_im布尔值，可选
如果设置为
True，则分别使用 \(\Re\) 和 \(\Im\) 表示re和im。默认值为False，这将导致使用 \(\operatorname{re}\) 和 \(\operatorname{im}\)。- decimal_separator字符串，可选
指定用于分隔浮点数整数部分和小数部分的符号，例如默认情况下为 \(2.5\)，当指定
comma时为 \(2{,}5\)。当选择comma时，列表、集合和元组以分号分隔元素打印。例如，选择comma时为 [1; 2; 3]，选择period时为 [1,2,3]。- parenthesize_super布尔值，可选
如果设置为
False，当表达式被上标时，不会加上括号。默认是True，这会在表达式被上标时加上括号。- min: 整数或 None, 可选
设置以定点格式打印浮点数时指数的下限。
- max: 整数或None，可选
设置以定点格式打印浮点数的指数上限。
- diff_operator: 字符串, 可选
用于微分运算符的字符串。默认是
'd'，以斜体形式打印。'rd'，'td'是\mathrm{d}和\text{d}的快捷方式。- adjoint_style: 字符串, 可选
用于共轭符号的字符串。定义的选项有
'dagger'``（默认）、’star’`` 和'hermitian'。
注释
不使用打印语句进行打印，会导致 LaTeX 命令出现双反斜杠，因为这是 Python 在字符串中转义反斜杠的方式。
>>> from sympy import latex, Rational >>> from sympy.abc import tau >>> latex((2*tau)**Rational(7,2)) '8 \\sqrt{2} \\tau^{\\frac{7}{2}}' >>> print(latex((2*tau)**Rational(7,2))) 8 \sqrt{2} \tau^{\frac{7}{2}}
示例
>>> from sympy import latex, pi, sin, asin, Integral, Matrix, Rational, log >>> from sympy.abc import x, y, mu, r, tau
基本用法：
>>> print(latex((2*tau)**Rational(7,2))) 8 \sqrt{2} \tau^{\frac{7}{2}}
mode和itex选项：>>> print(latex((2*mu)**Rational(7,2), mode='plain')) 8 \sqrt{2} \mu^{\frac{7}{2}} >>> print(latex((2*tau)**Rational(7,2), mode='inline')) $8 \sqrt{2} \tau^{7 / 2}$ >>> print(latex((2*mu)**Rational(7,2), mode='equation*')) \begin{equation*}8 \sqrt{2} \mu^{\frac{7}{2}}\end{equation*} >>> print(latex((2*mu)**Rational(7,2), mode='equation')) \begin{equation}8 \sqrt{2} \mu^{\frac{7}{2}}\end{equation} >>> print(latex((2*mu)**Rational(7,2), mode='equation', itex=True)) $$8 \sqrt{2} \mu^{\frac{7}{2}}$$ >>> print(latex((2*mu)**Rational(7,2), mode='plain')) 8 \sqrt{2} \mu^{\frac{7}{2}} >>> print(latex((2*tau)**Rational(7,2), mode='inline')) $8 \sqrt{2} \tau^{7 / 2}$ >>> print(latex((2*mu)**Rational(7,2), mode='equation*')) \begin{equation*}8 \sqrt{2} \mu^{\frac{7}{2}}\end{equation*} >>> print(latex((2*mu)**Rational(7,2), mode='equation')) \begin{equation}8 \sqrt{2} \mu^{\frac{7}{2}}\end{equation} >>> print(latex((2*mu)**Rational(7,2), mode='equation', itex=True)) $$8 \sqrt{2} \mu^{\frac{7}{2}}$$
分数选项：
>>> print(latex((2*tau)**Rational(7,2), fold_frac_powers=True)) 8 \sqrt{2} \tau^{7/2} >>> print(latex((2*tau)**sin(Rational(7,2)))) \left(2 \tau\right)^{\sin{\left(\frac{7}{2} \right)}} >>> print(latex((2*tau)**sin(Rational(7,2)), fold_func_brackets=True)) \left(2 \tau\right)^{\sin {\frac{7}{2}}} >>> print(latex(3*x**2/y)) \frac{3 x^{2}}{y} >>> print(latex(3*x**2/y, fold_short_frac=True)) 3 x^{2} / y >>> print(latex(Integral(r, r)/2/pi, long_frac_ratio=2)) \frac{\int r\, dr}{2 \pi} >>> print(latex(Integral(r, r)/2/pi, long_frac_ratio=0)) \frac{1}{2 \pi} \int r\, dr
乘法选项：
>>> print(latex((2*tau)**sin(Rational(7,2)), mul_symbol="times")) \left(2 \times \tau\right)^{\sin{\left(\frac{7}{2} \right)}}
Trig 选项：
>>> print(latex(asin(Rational(7,2)))) \operatorname{asin}{\left(\frac{7}{2} \right)} >>> print(latex(asin(Rational(7,2)), inv_trig_style="full")) \arcsin{\left(\frac{7}{2} \right)} >>> print(latex(asin(Rational(7,2)), inv_trig_style="power")) \sin^{-1}{\left(\frac{7}{2} \right)}
矩阵选项：
>>> print(latex(Matrix(2, 1, [x, y]))) \left[\begin{matrix}x\\y\end{matrix}\right] >>> print(latex(Matrix(2, 1, [x, y]), mat_str = "array")) \left[\begin{array}{c}x\\y\end{array}\right] >>> print(latex(Matrix(2, 1, [x, y]), mat_delim="(")) \left(\begin{matrix}x\\y\end{matrix}\right)
自定义符号打印：
>>> print(latex(x**2, symbol_names={x: 'x_i'})) x_i^{2}
对数：
>>> print(latex(log(10))) \log{\left(10 \right)} >>> print(latex(log(10), ln_notation=True)) \ln{\left(10 \right)}
latex()也支持内置的容器类型列表、元组和字典：>>> print(latex([2/x, y], mode='inline')) $\left[ 2 / x, \ y\right]$
不支持的类型会以等宽纯文本形式呈现：
>>> print(latex(int)) \mathtt{\text{<class 'int'>}} >>> print(latex("plain % text")) \mathtt{\text{plain \% text}}
请参阅 自定义打印方法的示例 以了解如何通过实现
_latex来为您的自定义类型覆盖此行为的示例。在 1.7.0 版本发生变更: 不再将不支持类型的
str表示视为有效的 latex。
MathMLPrinter¶
此类负责 MathML 打印。参见 sympy.printing.mathml。
更多关于 MathML 的信息：https://www.w3.org/TR/MathML2
- class sympy.printing.mathml.MathMLPrinterBase(settings=None)[源代码][源代码]¶
包含 MathMLContentPrinter 和 MathMLPresentationPrinter 所需的通用代码。
- 属性:
- 顺序
- printmethod
方法
doprint(expr)以 MathML 格式打印表达式。
set_global_settings(**settings)设置系统范围的打印设置。
emptyPrinter
- class sympy.printing.mathml.MathMLContentPrinter(settings=None)[源代码][源代码]¶
将表达式打印为 Content MathML 标记语言。
参考资料: https://www.w3.org/TR/MathML2/chapter4.html
- 属性:
- 顺序
方法
doprint(expr)以 MathML 格式打印表达式。
mathml_tag(e)返回表达式的 MathML 标签。
set_global_settings(**settings)设置系统范围的打印设置。
emptyPrinter
- printmethod: str = '_mathml_content'¶
- class sympy.printing.mathml.MathMLPresentationPrinter(settings=None)[源代码][源代码]¶
将表达式打印为 Presentation MathML 标记语言。
参考资料: https://www.w3.org/TR/MathML2/chapter3.html
- 属性:
- 顺序
方法
doprint(expr)以 MathML 格式打印表达式。
mathml_tag(e)返回表达式的 MathML 标签。
set_global_settings(**settings)设置系统范围的打印设置。
emptyPrinter
加括号
- printmethod: str = '_mathml_presentation'¶
- sympy.printing.mathml.mathml(
- expr,
- printer='content',
- *,
- order=None,
- encoding='utf-8',
- fold_frac_powers=False,
- fold_func_brackets=False,
- fold_short_frac=None,
- inv_trig_style='abbreviated',
- ln_notation=False,
- long_frac_ratio=None,
- mat_delim='[',
- mat_symbol_style='plain',
- mul_symbol=None,
- root_notation=True,
- symbol_names={},
- mul_symbol_mathml_numbers='·',
返回 expr 的 MathML 表示。如果 printer 是 presentation，则打印 Presentation MathML，否则打印 content MathML。
- sympy.printing.mathml.print_mathml(expr, printer='content', **settings)[源代码][源代码]¶
打印表达式 expr 的 MathML 代码的漂亮表示。如果打印机是 presentation，则打印 Presentation MathML，否则打印 content MathML。
示例
>>> ## >>> from sympy import print_mathml >>> from sympy.abc import x >>> print_mathml(x+1) <apply> <plus/> <ci>x</ci> <cn>1</cn> </apply> >>> print_mathml(x+1, printer='presentation') <mrow> <mi>x</mi> <mo>+</mo> <mn>1</mn> </mrow>
Python代码打印机¶
Python 代码打印机
此模块包含适用于纯Python以及启用了NumPy和SciPy的Python代码的代码打印机。
- class sympy.printing.pycode.MpmathPrinter(settings=None)[源代码][源代码]¶
用于 mpmath 的 Lambda 打印机，保持浮点数的精度
- 属性:
- 模块
- 顺序
方法
doprint(expr[, assign_to])将表达式打印为代码。
set_global_settings(**settings)设置系统范围的打印设置。
emptyPrinter
加括号
字符串化
- sympy.printing.pycode.pycode(expr, **settings)[源代码][源代码]¶
将一个表达式转换为Python代码的字符串
- 参数:
- 表达式表达式
一个 SymPy 表达式。
- fully_qualified_modules布尔
是否写出函数的完整模块名称（例如
math.sin对比sin）。默认值：True。- 标准str 或 None, 可选
仅支持 ‘python3’（默认）。此参数未来可能会被移除。
示例
>>> from sympy import pycode, tan, Symbol >>> pycode(tan(Symbol('x')) + 1) 'math.tan(x) + 1'
PythonPrinter¶
此类实现 Python 打印功能。使用方法:
>>> from sympy import print_python, sin
>>> from sympy.abc import x
>>> print_python(5*x**3 + sin(x))
x = Symbol('x')
e = 5*x**3 + sin(x)
srepr¶
此打印机生成可执行代码。该代码满足恒等式 eval(srepr(expr)) == expr。
srepr() 比 repr() 提供更低层次的文本输出。
示例:
>>> repr(5*x**3 + sin(x))
'5*x**3 + sin(x)'
>>> srepr(5*x**3 + sin(x))
"Add(Mul(Integer(5), Pow(Symbol('x'), Integer(3))), sin(Symbol('x')))"
srepr() 给出 repr 形式，这是 repr() 通常会给出的内容，但对于 SymPy，我们实际上不使用 srepr() 作为 __repr__，因为它非常冗长，不太可能有人希望它默认被调用。另一个原因是列表会调用其元素的 repr，例如 print([a, b, c]) 会调用 repr(a)、repr(b)、repr(c)。因此，如果我们为 __repr__ 使用 srepr，任何包含 SymPy 对象的列表都将包含 srepr 形式，即使我们使用 str() 或 print()。
StrPrinter¶
此模块生成 SymPy 表达式的可读表示。
- class sympy.printing.str.StrPrinter(settings=None)[源代码][源代码]¶
方法
emptyPrinter
加括号
字符串化
- printmethod: str = '_sympystr'¶
- sympy.printing.str.sstr(
- expr,
- *,
- order=None,
- full_prec='auto',
- sympy_integers=False,
- abbrev=False,
- perm_cyclic=True,
- min=None,
- max=None,
- dps=None,
返回表达式作为字符串。
对于速度是关键的大表达式，使用设置 order=’none’。如果使用了 abbrev=True 设置，那么单位将以缩写形式打印。
示例
>>> from sympy import symbols, Eq, sstr >>> a, b = symbols('a b') >>> sstr(Eq(a + b, 0)) 'Eq(a + b, 0)'
树打印¶
此模块中的函数将表达式创建为树的表示形式。
- sympy.printing.tree.pprint_nodes(subtrees)[源代码][源代码]¶
美化节点系统的打印。
示例
>>> from sympy.printing.tree import pprint_nodes >>> print(pprint_nodes(["a", "b1\nb2", "c"])) +-a +-b1 | b2 +-c
- sympy.printing.tree.print_node(node, assumptions=True)[源代码][源代码]¶
返回有关“节点”的信息。
这包括类名、字符串表示形式和假设。
- 参数:
- 假设bool, 可选
请参阅
tree中的assumptions关键字
- sympy.printing.tree.tree(node, assumptions=True)[源代码][源代码]¶
返回“节点”的字符串树表示形式。
它使用 print_node() 和 pprint_nodes() 递归地处理 node.args。
- 参数:
- 假设bool, 可选
决定是否打印出与表达式相关的所有假设数据（如
is_integer`, ``is_real）的标志。启用该标志会使结果变得详细，并且由于在回溯假设时使用了随机性，打印的结果可能不是确定性的。
参见
- sympy.printing.tree.print_tree(node, assumptions=True)[源代码][源代码]¶
打印“节点”的树形表示。
- 参数:
- 假设bool, 可选
决定是否打印出与表达式相关的所有假设数据（如
is_integer`, ``is_real）的标志。启用该标志会使结果变得详细，并且由于在回溯假设时使用了随机性，打印的结果可能不是确定性的。
参见
示例
>>> from sympy.printing import print_tree >>> from sympy import Symbol >>> x = Symbol('x', odd=True) >>> y = Symbol('y', even=True)
打印包含完整假设信息：
>>> print_tree(y**x) Pow: y**x +-Symbol: y | algebraic: True | commutative: True | complex: True | even: True | extended_real: True | finite: True | hermitian: True | imaginary: False | infinite: False | integer: True | irrational: False | noninteger: False | odd: False | rational: True | real: True | transcendental: False +-Symbol: x algebraic: True commutative: True complex: True even: False extended_nonzero: True extended_real: True finite: True hermitian: True imaginary: False infinite: False integer: True irrational: False noninteger: False nonzero: True odd: True rational: True real: True transcendental: False zero: False
隐藏假设：
>>> print_tree(y**x, assumptions=False) Pow: y**x +-Symbol: y +-Symbol: x
预览¶
一个有用的功能是 preview:
- sympy.printing.preview.preview(
- expr,
- output='png',
- viewer=None,
- euler=True,
- packages=(),
- filename=None,
- outputbuffer=None,
- preamble=None,
- dvioptions=None,
- outputTexFile=None,
- extra_preamble=None,
- fontsize=None,
- **latex_settings,
以PNG、DVI、PostScript或PDF格式查看表达式或LaTeX标记。
如果 expr 参数是一个表达式，它将被导出到 LaTeX 并使用可用的 TeX 发行版进行编译。第一个参数 ‘expr’ 也可以是一个 LaTeX 字符串。然后，该函数将运行适用于给定输出格式的适当查看器，或者使用用户定义的查看器。默认生成 png 输出。
默认情况下，排版使用漂亮的 Euler 字体（这些字体曾用于排版著名的《具体数学》书籍）。为此，您需要 ‘eulervm.sty’ LaTeX 样式（在 Debian/Ubuntu 中，安装 texlive-fonts-extra 包）。如果您更喜欢默认的 AMS 字体或您的系统缺少 ‘eulervm’ LaTeX 包，则取消设置 ‘euler’ 关键字参数。
要使用查看器自动检测，例如对于 ‘png’ 输出，请执行
>>> from sympy import symbols, preview, Symbol >>> x, y = symbols("x,y")
>>> preview(x + y, output='png')
默认情况下，这将选择 ‘pyglet’。要选择不同的一个，请执行
>>> preview(x + y, output='png', viewer='gimp')
‘png’ 格式被视为特殊。对于所有其他格式，规则略有不同。作为一个例子，我们将采用‘dvi’输出格式。如果你运行
>>> preview(x + y, output='dvi')
然后，’view’ 将在您的系统上查找可用的 ‘dvi’ 查看器（在函数中预定义，因此它将首先尝试 evince，然后是 kdvi 和 xdvi）。如果没有找到任何查看器，它将回退到使用系统文件关联（通过
open和xdg-open）。要始终使用您的系统文件关联而不搜索上述阅读器，请使用>>> from sympy.printing.preview import system_default_viewer >>> preview(x + y, output='dvi', viewer=system_default_viewer)
如果这仍然找不到你想要的查看器，可以明确地设置它。
>>> preview(x + y, output='dvi', viewer='superior-dvi-viewer')
这将跳过自动检测，并运行用户指定的 ‘superior-dvi-viewer’。如果
view在您的系统中找不到它，它将优雅地引发异常。您也可以为 viewer 参数输入
'file'。这样做会导致此函数在filename未设置时返回一个只读模式的文件对象。然而，如果设置了filename，那么 ‘preview’ 会将生成的文件写入此文件名。还支持写入类似于
io.BytesIO的对象，这需要传递给outputbuffer参数。>>> from io import BytesIO >>> obj = BytesIO() >>> preview(x + y, output='png', viewer='BytesIO', ... outputbuffer=obj)
可以通过设置 ‘preamble’ 关键字参数来自定义 LaTeX 前言。例如，这可以用于设置不同的字体大小、使用自定义的文档类或导入特定的 LaTeX 包。
>>> preamble = "\\documentclass[10pt]{article}\n" \ ... "\\usepackage{amsmath,amsfonts}\\begin{document}" >>> preview(x + y, output='png', preamble=preamble)
也可以使用标准的序言，并通过
extra_preamble关键字参数向序言提供额外信息。>>> from sympy import sin >>> extra_preamble = "\\renewcommand{\\sin}{\\cos}" >>> preview(sin(x), output='png', extra_preamble=extra_preamble)
如果 ‘output’ 的值不同于 ‘dvi’，则可以为 ‘dvi’+输出转换工具的执行设置命令行选项（’dvioptions’ 参数）。这些选项必须是以字符串列表的形式（参见
subprocess.Popen）。额外的关键字参数将被传递给
latex()调用，例如symbol_names标志。>>> phidd = Symbol('phidd') >>> preview(phidd, symbol_names={phidd: r'\ddot{\varphi}'})
对于生成的 TeX 文件，可以通过将所需文件名传递给 ‘outputTexFile’ 关键字参数来写入文件。要将 TeX 代码写入名为
"sample.tex"的文件并运行默认的 png 查看器以显示生成的位图，请执行>>> preview(x + y, outputTexFile="sample.tex")
实现 - 辅助类/函数¶
- sympy.printing.conventions.split_super_sub(text)[源代码][源代码]¶
将符号名称拆分为名称、上标和下标
符号名称的第一部分被认为是其真正的’名称’，后面跟着上标和下标。每个上标前面都有一个“^”字符或“__”。每个下标前面都有一个“_”字符。这三个返回值是实际名称、一个包含上标的列表和一个包含下标的列表。
示例
>>> from sympy.printing.conventions import split_super_sub >>> split_super_sub('a_x^1') ('a', ['1'], ['x']) >>> split_super_sub('var_sub1__sup_sub2') ('var', ['sup'], ['sub1', 'sub2'])
代码打印机¶
此类是实现代码打印功能的其他类的基类，并且还列出了一些难以翻译为 C 或 Fortran 的函数。
优先级¶
- sympy.printing.precedence.PRECEDENCE = {'Add': 40, 'And': 30, 'Atom': 1000, 'BitwiseAnd': 38, 'BitwiseOr': 36, 'BitwiseXor': 37, 'Func': 70, 'Lambda': 1, 'Mul': 50, 'Not': 100, 'Or': 20, 'Pow': 60, 'Relational': 35, 'Xor': 10}¶
!! 由 numpydoc 处理 !!
一些基本类型的默认优先级值。
- sympy.printing.precedence.PRECEDENCE_VALUES = {'Add': 40, 'And': 30, 'Equality': 50, 'Equivalent': 10, 'Function': 70, 'HadamardPower': 60, 'HadamardProduct': 50, 'Implies': 10, 'KroneckerProduct': 50, 'MatAdd': 40, 'MatPow': 60, 'MatrixSolve': 50, 'Mod': 50, 'NegativeInfinity': 40, 'Not': 100, 'Or': 20, 'Pow': 60, 'Relational': 35, 'Sub': 40, 'TensAdd': 40, 'TensMul': 50, 'Unequality': 50, 'Xor': 10}¶
!! 由 numpydoc 处理 !!
一个将优先级值分配给某些类的字典。这些值被视为继承的，因此不必在此处命名每个单独的类。
- sympy.printing.precedence.PRECEDENCE_FUNCTIONS = {'Float': <function precedence_Float>, 'FracElement': <function precedence_FracElement>, 'Integer': <function precedence_Integer>, 'Mul': <function precedence_Mul>, 'PolyElement': <function precedence_PolyElement>, 'Rational': <function precedence_Rational>, 'UnevaluatedExpr': <function precedence_UnevaluatedExpr>}¶
!! 由 numpydoc 处理 !!
有时，为类分配一个固定的优先级值是不够的。这时，可以在这个字典中插入一个函数，该函数以该类的一个实例为参数，并返回适当的优先级值。
美化打印实现辅助工具¶
- sympy.printing.pretty.pretty_symbology.U(name)[源代码][源代码]¶
通过名称获取一个Unicode字符，如果未找到则返回None。
这存在是因为旧版本的 Python 使用旧的 Unicode 数据库。
- sympy.printing.pretty.pretty_symbology.pretty_use_unicode(flag=None)[源代码][源代码]¶
设置是否默认使用Unicode进行美化打印
- sympy.printing.pretty.pretty_symbology.pretty_try_use_unicode()[源代码][源代码]¶
检查是否支持unicode输出，并在可能的情况下利用它
以下两个函数返回输入的希腊字母的Unicode版本。
- sympy.printing.pretty.pretty_symbology.greek_letters = ['alpha', 'beta', 'gamma', 'delta', 'epsilon', 'zeta', 'eta', 'theta', 'iota', 'kappa', 'lamda', 'mu', 'nu', 'xi', 'omicron', 'pi', 'rho', 'sigma', 'tau', 'upsilon', 'phi', 'chi', 'psi', 'omega']¶
内置的可变序列。
如果没有给出参数，构造函数会创建一个新的空列表。如果指定了参数，它必须是一个可迭代对象。
- sympy.printing.pretty.pretty_symbology.digit_2txt = {'0': 'ZERO', '1': 'ONE', '2': 'TWO', '3': 'THREE', '4': 'FOUR', '5': 'FIVE', '6': 'SIX', '7': 'SEVEN', '8': 'EIGHT', '9': 'NINE'}¶
!! 由 numpydoc 处理 !!
- sympy.printing.pretty.pretty_symbology.symb_2txt = {'(': 'LEFT PARENTHESIS', ')': 'RIGHT PARENTHESIS', '+': 'PLUS SIGN', '-': 'MINUS', '=': 'EQUALS SIGN', '[': 'LEFT SQUARE BRACKET', ']': 'RIGHT SQUARE BRACKET', 'int': 'INTEGRAL', 'sum': 'SUMMATION', '{': 'LEFT CURLY BRACKET', '{}': 'CURLY BRACKET', '}': 'RIGHT CURLY BRACKET'}¶
!! 由 numpydoc 处理 !!
以下函数返回字符的Unicode下标/上标版本。
- sympy.printing.pretty.pretty_symbology.sub = {'(': '₍', ')': '₎', '+': '₊', '-': '₋', '0': '₀', '1': '₁', '2': '₂', '3': '₃', '4': '₄', '5': '₅', '6': '₆', '7': '₇', '8': '₈', '9': '₉', '=': '₌', 'a': 'ₐ', 'beta': 'ᵦ', 'chi': 'ᵪ', 'e': 'ₑ', 'gamma': 'ᵧ', 'h': 'ₕ', 'i': 'ᵢ', 'k': 'ₖ', 'l': 'ₗ', 'm': 'ₘ', 'n': 'ₙ', 'o': 'ₒ', 'p': 'ₚ', 'phi': 'ᵩ', 'r': 'ᵣ', 'rho': 'ᵨ', 's': 'ₛ', 't': 'ₜ', 'u': 'ᵤ', 'v': 'ᵥ', 'x': 'ₓ'}¶
!! 由 numpydoc 处理 !!
- sympy.printing.pretty.pretty_symbology.sup = {'(': '⁽', ')': '⁾', '+': '⁺', '-': '⁻', '0': '⁰', '1': '¹', '2': '²', '3': '³', '4': '⁴', '5': '⁵', '6': '⁶', '7': '⁷', '8': '⁸', '9': '⁹', '=': '⁼', 'i': 'ⁱ', 'n': 'ⁿ'}¶
!! 由 numpydoc 处理 !!
以下函数返回 Unicode 垂直对象。
以下常量用于渲染根号和分数。
- sympy.printing.pretty.pretty_symbology.root = {2: '√', 3: '∛', 4: '∜'}¶
!! 由 numpydoc 处理 !!
- sympy.printing.pretty.pretty_symbology.frac = {(1, 2): '½', (1, 3): '⅓', (1, 4): '¼', (1, 5): '⅕', (1, 6): '⅙', (1, 8): '⅛', (2, 3): '⅔', (2, 5): '⅖', (3, 4): '¾', (3, 5): '⅗', (3, 8): '⅜', (4, 5): '⅘', (5, 6): '⅚', (5, 8): '⅝', (7, 8): '⅞'}¶
!! 由 numpydoc 处理 !!
以下常量/函数用于渲染原子和符号。
- sympy.printing.pretty.pretty_symbology.atoms_table = {'And': '∧', 'Arrow': '→', 'ArrowFromBar': '↦', 'Complexes': 'ℂ', 'Contradiction': '┬', 'Dagger': '†', 'Degree': '°', 'Differential': 'ⅆ', 'Dots': '…', 'ElementOf': '∈', 'EmptySequence': 'EmptySequence', 'EmptySet': '∅', 'Equiv': '⇔', 'Exp1': 'ℯ', 'IdentityMatrix': '𝕀', 'ImaginaryUnit': 'ⅈ', 'Implies': '⇔', 'Infinity': '∞', 'Integers': 'ℤ', 'Intersection': '∩', 'Modifier Letter Low Ring': '˳', 'Multiplication': '×', 'Nand': '⊼', 'Naturals': 'ℕ', 'Naturals0': 'ℕ₀', 'NegativeInfinity': '-∞', 'Nor': '⊽', 'Not': '¬', 'NotArrow': '↛', 'NotEquiv': '⇎', 'NotImplies': '⇎', 'OneMatrix': '𝟙', 'Or': '∨', 'Pi': 'π', 'Rationals': 'ℚ', 'Reals': 'ℝ', 'Ring': '∘', 'SmallElementOf': '∊', 'SuperscriptMinus': '⁻', 'SuperscriptPlus': '⁺', 'SymmetricDifference': '∆', 'Tautology': '┴', 'TensorProduct': '⨂', 'Union': '∪', 'Universe': '𝕌', 'Xor': '⊻', 'ZeroMatrix': '𝟘'}¶
!! 由 numpydoc 处理 !!
- sympy.printing.pretty.pretty_symbology.pretty_atom(atom_name, default=None, printer=None)[源代码][源代码]¶
返回原子的漂亮表示形式
- sympy.printing.pretty.pretty_symbology.pretty_symbol(symb_name, bold_name=False)[源代码][源代码]¶
返回符号的漂亮表示形式
- sympy.printing.pretty.pretty_symbology.annotated(letter)[源代码][源代码]¶
返回字母
letter的样式化绘图，并附带如何在其上添加注释（左侧和右侧的上标和下标）的信息。参见 pretty.py 函数 _print_meijerg, _print_hyper 以了解如何使用此信息。
由Jurjen Bos编写的Prettyprinter。（我讨厌垃圾邮件发送者：请将邮件发送到pietjepuk314，地址为ku.oc.oohay的反向）。所有对象都有一个创建“stringPict”的方法，该方法可用于str方法中进行美观打印。
- 更新由 Jason Gedge 提供 (邮箱 <姓> at cs mun ca)
terminal_string() 方法
小修小补和更改（主要针对prettyForm）
- class sympy.printing.pretty.stringpict.stringPict(s, baseline=0)[源代码][源代码]¶
一个ASCII图片。图片以等长字符串列表的形式表示。
方法
above(*args)将图片放在此图片上方。
below(*args)将图片放在此图片下方。
height()图片的高度，以字符为单位。
left(*args)将图片（从左到右）放在左侧。
在对象前加上适当大小的斜杠。
next(*args)将一串 stringPicts 并排放置。
parens([left, right, ifascii_nougly])在 self 周围加上括号。
render(*args, **kwargs)返回 self 的字符串形式。
right(*args)将图片放在这张旁边。
root([n])生成一个漂亮的根符号。
stack(*args)将图片从上到下叠加。
如果可能，返回终端宽度，否则返回0。
width()图片的宽度，以字符为单位。
equalLengths
- below(*args)[源代码][源代码]¶
将图片放在此图片下方。返回字符串，字符串Pict的基本线参数。基线是顶部图片的基线。
示例
>>> from sympy.printing.pretty.stringpict import stringPict >>> print(stringPict("x+3").below( ... stringPict.LINE, '3')[0]) x+3 --- 3
- parens(
- left='(',
- right=')',
- ifascii_nougly=False,
在 self 周围加上括号。返回字符串，字符串Pict的基本参数。
left 或 right 可以是 None 或空字符串，这意味着 ‘那一侧没有括号’
- render(*args, **kwargs)[源代码][源代码]¶
返回 self 的字符串形式。
除非参数 line_break 设置为 False，否则它将以一种可以在终端上打印而不被打断的形式打断表达式。
- right(*args)[源代码][源代码]¶
将图片放在此图片旁边。返回字符串，字符串Pict的基本参数。（多行）字符串是允许的，并且它们的基线为0。
示例
>>> from sympy.printing.pretty.stringpict import stringPict >>> print(stringPict("10").right(" + ",stringPict("1\r-\r2",1))[0]) 1 10 + - 2
- class sympy.printing.pretty.stringpict.prettyForm(s, baseline=0, binding=0, unicode=None)[源代码][源代码]¶
扩展了 stringPict 类，该类了解基本的数学应用，优化了双减号。
“绑定” 解释如下:
ATOM this is an atom: never needs to be parenthesized FUNC this is a function application: parenthesize if added (?) DIV this is a division: make wider division if divided POW this is a power: only parenthesize if exponent MUL this is a multiplication: parenthesize if powered ADD this is an addition: parenthesize if multiplied or powered NEG this is a negative number: optimize if added, parenthesize if multiplied or powered OPEN this is an open object: parenthesize if added, multiplied, or powered (example: Piecewise)- 属性:
- unicode
方法
above(*args)将图片放在此图片上方。
apply(function, *args)一个或多个变量的函数。
below(*args)将图片放在此图片下方。
height()图片的高度，以字符为单位。
left(*args)将图片（从左到右）放在左侧。
leftslash()在对象前加上适当大小的斜杠。
next(*args)将一串 stringPicts 并排放置。
parens([left, right, ifascii_nougly])在 self 周围加上括号。
render(*args, **kwargs)返回 self 的字符串形式。
right(*args)将图片放在这张旁边。
root([n])生成一个漂亮的根符号。
stack(*args)将图片从上到下叠加。
terminal_width()如果可能，返回终端宽度，否则返回0。
width()图片的宽度，以字符为单位。
equalLengths
dotprint¶
- sympy.printing.dot.dotprint(
- expr,
- styles=((<class 'sympy.core.basic.Basic'>,
- {'color': 'blue',
- 'shape': 'ellipse'}),
- (<class 'sympy.core.expr.Expr'>,
- {'color': 'black'})),
- atom=<function <lambda>>,
- maxdepth=None,
- repeat=True,
- labelfunc=<class 'str'>,
- **kwargs,
DOT 描述 SymPy 表达式树
- 参数:
- 样式由 (类, 映射) 组成的列表列表，可选
不同类别的样式。
默认是
( (Basic, {'color': 'blue', 'shape': 'ellipse'}), (Expr, {'color': 'black'}) )
- 原子函数, 可选
用于确定参数是否为原子的函数。
一个好的选择是
lambda x: not x.args。默认是
lambda x: not isinstance(x, Basic)。- maxdepth整数，可选
最大深度。
默认值是
None，表示没有限制。- 重复布尔值，可选
是否为常见子表达式使用不同的节点。
默认值为
True。例如，对于
x + x*y且repeat=True时，它将有两个x节点；当repeat=False时，它将只有一个节点。警告
即使一个节点在同一个对象中出现两次，例如
Pow(x, x)中的x，它仍然只会出现一次。因此，使用repeat=False，一个对象的出箭头数量可能不等于它的参数数量。- labelfunc函数, 可选
一个为给定叶节点创建标签的函数。
默认值是
str。另一个好的选项是
srepr。例如，对于
str，x + 1的叶节点被标记为x和1。 使用srepr，它们被标记为Symbol('x')和Integer(1)。- **kwargs可选的
额外的关键字参数作为图形的样式包含在内。
示例
>>> from sympy import dotprint >>> from sympy.abc import x >>> print(dotprint(x+2)) digraph{ # Graph style "ordering"="out" "rankdir"="TD" ######### # Nodes # ######### "Add(Integer(2), Symbol('x'))_()" ["color"="black", "label"="Add", "shape"="ellipse"]; "Integer(2)_(0,)" ["color"="black", "label"="2", "shape"="ellipse"]; "Symbol('x')_(1,)" ["color"="black", "label"="x", "shape"="ellipse"]; ######### # Edges # ######### "Add(Integer(2), Symbol('x'))_()" -> "Integer(2)_(0,)"; "Add(Integer(2), Symbol('x'))_()" -> "Symbol('x')_(1,)"; }