Parsing input¶
Parsing Functions Reference¶
-
sympy.parsing.sympy_parser.
parse_expr
(s, local_dict=None, transformations=(<function lambda_notation>, <function auto_symbol>, <function repeated_decimals>, <function auto_number>, <function factorial_notation>), global_dict=None, evaluate=True)[source]¶ Converts the string
s
to a SymPy expression, inlocal_dict
- Parameters
s : str
The string to parse.
local_dict : dict, optional
A dictionary of local variables to use when parsing.
global_dict : dict, optional
A dictionary of global variables. By default, this is initialized with
from sympy import *
; provide this parameter to override this behavior (for instance, to parse"Q & S"
).transformations : tuple, optional
A tuple of transformation functions used to modify the tokens of the parsed expression before evaluation. The default transformations convert numeric literals into their SymPy equivalents, convert undefined variables into SymPy symbols, and allow the use of standard mathematical factorial notation (e.g.
x!
).evaluate : bool, optional
When False, the order of the arguments will remain as they were in the string and automatic simplification that would normally occur is suppressed. (see examples)
Examples
>>> 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
When evaluate=False, some automatic simplifications will not occur:
>>> parse_expr("2**3"), parse_expr("2**3", evaluate=False) (8, 2**3)
In addition the order of the arguments will not be made canonical. This feature allows one to tell exactly how the expression was entered:
>>> a = parse_expr('1 + x', evaluate=False) >>> b = parse_expr('x + 1', evaluate=0) >>> a == b False >>> a.args (1, x) >>> b.args (x, 1)
-
sympy.parsing.sympy_parser.
stringify_expr
(s, local_dict, global_dict, transformations)[source]¶ Converts the string
s
to Python code, inlocal_dict
Generally,
parse_expr
should be used.
-
sympy.parsing.sympy_parser.
eval_expr
(code, local_dict, global_dict)[source]¶ Evaluate Python code generated by
stringify_expr
.Generally,
parse_expr
should be used.
-
sympy.parsing.mathematica.
mathematica
(s, additional_translations=None)[source]¶ Users can add their own translation dictionary # Example In [1]: mathematica(‘Log3[9]’, {‘Log3[x]’:’log(x,3)’}) Out[1]: 2 In [2]: mathematica(‘F[7,5,3]’, {‘F[x]’:’Max(*x)*Min(*x)’}) Out[2]: 21 variable-length argument needs ‘’ character
Parsing Transformations Reference¶
A transformation is a function that accepts the arguments tokens,
local_dict, global_dict
and returns a list of transformed tokens. They can
be used by passing a list of functions to parse_expr()
and are
applied in the order given.
-
sympy.parsing.sympy_parser.
standard_transformations
= (<function lambda_notation>, <function auto_symbol>, <function repeated_decimals>, <function auto_number>, <function factorial_notation>)¶ Standard transformations for
parse_expr()
. Inserts calls toSymbol
,Integer
, and other SymPy datatypes and allows the use of standard factorial notation (e.g.x!
).
-
sympy.parsing.sympy_parser.
split_symbols
(tokens, local_dict, global_dict)¶ Splits symbol names for implicit multiplication.
Intended to let expressions like
xyz
be parsed asx*y*z
. Does not split Greek character names, sotheta
will not becomet*h*e*t*a
. Generally this should be used withimplicit_multiplication
.
-
sympy.parsing.sympy_parser.
split_symbols_custom
(predicate)[source]¶ Creates a transformation that splits symbol names.
predicate
should return True if the symbol name is to be split.For instance, to retain the default behavior but avoid splitting certain symbol names, a predicate like this would work:
>>> 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
(result, local_dict, global_dict)[source]¶ Makes the multiplication operator optional in most cases.
Use this before
implicit_application()
, otherwise expressions likesin 2x
will be parsed asx * sin(2)
rather thansin(2*x)
.Examples
>>> 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
(result, local_dict, global_dict)[source]¶ Makes parentheses optional in some cases for function calls.
Use this after
implicit_multiplication()
, otherwise expressions likesin 2x
will be parsed asx * sin(2)
rather thansin(2*x)
.Examples
>>> 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, local_dict, global_dict)[source]¶ Allows functions to be exponentiated, e.g.
cos**2(x)
.Examples
>>> 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, local_dict, global_dict)[source]¶ Allows a slightly relaxed syntax.
Parentheses for single-argument method calls are optional.
Multiplication is implicit.
Symbol names can be split (i.e. spaces are not needed between symbols).
Functions can be exponentiated.
Examples
>>> 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, local_dict, global_dict)[source]¶ Converts floats into
Rational
. Run AFTERauto_number
.
-
sympy.parsing.sympy_parser.
convert_xor
(tokens, local_dict, global_dict)[source]¶ Treats XOR,
^
, as exponentiation,**
.
These are included in
:data:sympy.parsing.sympy_parser.standard_transformations
and generally
don’t need to be manually added by the user.
-
sympy.parsing.sympy_parser.
lambda_notation
(tokens, local_dict, global_dict)[source]¶ Substitutes “lambda” with its Sympy equivalent Lambda(). However, the conversion doesn’t take place if only “lambda” is passed because that is a syntax error.
-
sympy.parsing.sympy_parser.
auto_symbol
(tokens, local_dict, global_dict)[source]¶ Inserts calls to
Symbol
/Function
for undefined variables.
-
sympy.parsing.sympy_parser.
repeated_decimals
(tokens, local_dict, global_dict)[source]¶ Allows 0.2[1] notation to represent the repeated decimal 0.2111… (19/90)
Run this before auto_number.
Experimental \(\LaTeX\) Parsing¶
\(\LaTeX\) parsing was ported from latex2sympy. While functional and its API should remain stable, the parsing behavior or backend may change in future releases.
\(\LaTeX\) Parsing Caveats¶
The current implementation is experimental. The behavior, parser backend and API might change in the future. Unlike some of the other parsers, \(\LaTeX\) is designed as a type-setting language, not a computer algebra system and so can contain typographical conventions that might be interpreted multiple ways.
In its current definition, the parser will at times will fail to fully parse the expression, but not throw a warning:
parse_latex(r'x -')
Will simply find x
. What is covered by this behavior will almost certainly
change between releases, and become stricter, more relaxed, or some mix.
\(\LaTeX\) Parsing Functions Reference¶
-
sympy.parsing.latex.
parse_latex
(s)[source]¶ Converts the string
s
to a SymPyExpr
- Parameters
s : str
The LaTeX string to parse. In Python source containing LaTeX, raw strings (denoted with
r"
, like this one) are preferred, as LaTeX makes liberal use of the\
character, which would trigger escaping in normal Python strings.
Examples
>>> from sympy.parsing.latex import parse_latex # doctest: +SKIP >>> expr = parse_latex(r"\frac {1 + \sqrt {\a}} {\b}") # doctest: +SKIP >>> expr # doctest: +SKIP (sqrt(a) + 1)/b >>> expr.evalf(4, subs=dict(a=5, b=2)) # doctest: +SKIP 1.618
Runtime Installation¶
The currently-packaged parser backend is partially generated with
ANTLR4,
but to use the parser, you only need the antlr4
Python package available.
Depending on your package manager, you can install the right package with, for
example, pip3
(Python 3 only):
$ pip3 install antlr4-python3-runtime
or pip
(Python 2 only):
$ pip install antlr4-python2-runtime
or conda
(Python 2 or Python 3):
$ conda install --channel=conda-forge antlr-python-runtime