目前为止，我们程序中的数学问题和揭发都与数字运算有关。不过，数学的教学、学习和实践中还有另外一种方式，那就是用符号和符号之间的运算来表示。例如典型的代数问题中的x和y，我们将这类数字称为符号数学（symbolic math）。想想当时令人头疼的因式分解（例如，分解。别担心在本章，我们会学习如何编写解决这些问题的程序。我们将使用一个Sympy（一个Python库），他能够让你编写包含符号的代数表达式并对其执行操作。由于Sympy是第三方库，因此在使用他之前，需要先安装它。

第一节 定义符号和符号运算

符号是构成符号数学的基础。符号是方程式和代数表达式中x、y、a和b的通用名称。这里创建和使用符号的方式与以前不同。看如下语句：

 >>> x= 1
 >>> x + x + 1
 3

在这里，我们创建了一个标签x来指代数字1，然后使用语句x+x+1来执行计算，结果是3，可是我们希望输出的结果是包含x的，也就是2x+1。此时也不能直接把x=1去掉，这样的话Python就不知道x指代的是什么。

SymPy可以让我们编写类似的包含符号的代数表达式并执行计算。要在程序中使用符号，首先要创建一个Symbol对象，如下所示：

 >>> from sympy import Symbol
 >>> x = Symnbol('x')

首先从SymPy库导入Symbol类。然后创建一个Symbol对象，使用标签x来指代它，'x'作为参数传递。请注意：这个参数是以字符串形式传递的。现在我们就可以用这个符号来定义表达式和方程。例如，下面是前面的表达式：

 >>> from sympy import Symbol
 >>> x = Symnbol('x')
 >>> x + x + 1
 2*x + 1

可以看到，下的结果是包含x的输出。在语句x = Symbol('x')中，左侧的x和之前的标签一样，相当于是一个名字，只是起一个指代作用，用来指代右边的字符串为'x'的Symbol对象。此处需要注意：左边的x和右边的x含义要注意区分，用左边的x来指代x的Symbol对象，当然此处也可以使用a，b等标签来指代x的Symbol对象。

但是，通常是使用相匹配的标签，不然的话容易令人困惑。

为了再次便于理解，看如下程序，对于任何Symbol对象，它的name属性是他所代表的使肌肤好的一个字符串，也就是说，通过name属性我们可以知道它指代的是什么字符串。

 >>> x = Symbol('x')
 >>> x.name
 'x'
 >>> a = Symbol('x')
 >>> a.name
 'x'

再次强调，需要传入字符串参数，作为代数表达式的符号，即不能使用如下语句：x = Symbol(x)，必须使用x = Symbol('x')。

定义多个符号，可以像刚刚那样单独重复多次定义，也可以使用symbols()函数来更见简洁的定义它们。假如在一个程序中需要使用x、y和z三个符号，你可以像这样定义它：

 >>> x = Symbol('x')
 >>> y = Symbol('y')
 >>> z = Symbol('z')

这与之前的方法相同，或者进行如下定义：

 >>> from sympy import symbols
 >>> x, y, z = symbols('x, y, z')

可见这种方式更加简洁，首先从SymPy库导入symbols()函数。然后将想要创建的符号作为一个字符串传入，各符号之间使用逗号隔开。执行此语句后，x、y和z三个标签分别就指代三个符号对象'x'、'y'和'z'。

完成定义后，我们就可以对它进行基本的数学运算，例如第一章学到的加减乘除和幂运算等等。例如，以下演示：

 >>> from sympy import symbols
 >>> x, y = symbols('x, y')
 >>> s = x*y + x*y
 >>> s
 2*x*y

我们来看看是否能够得到x(x+x)的乘积

 >>> p = x*(x + x)
 >>> p 
 2*x**2

SymPy会自动对这些简单的加法和乘法进行计算，但是如果我们输入一个更加复杂一点的表达式，表达式将保持不变。让我们来看看当我们输入表达式(x + 2) * (x + 3)时会发生什么情况：

 >>> p = (x + 2) * (x + 3)
 >>> p
 (x + 2) * (x + 3)

你可能很期待SymPy将所有内容相乘并输出x**2+5*x+6，然而，表达式这是输出了原有形式。SymPy只进行简单的表达式计算，对于更复杂的表达式，SymPy将简化操作留给了程序员。如果你希望得到展开式，必须使用expand()函数，稍后我们将看到该函数。

第二节 使用表达式

4.2.1 分解和展开表达式

factor()函数分解表达式，而expand()函数展开表达式，将表达式表示为单个项的总和。我们使用基本代数恒等式x^2-y^2 = (x+y)(x-y)来检验这些函数。当时的左边为展开版本右边为相应的分解式。因为等式中有两个符号，一次我们需要创建两个符号对象：

 >>> from sympy import symbols
 >>> x, y = symbols('x, y')

接下来，我们导入factor()函数，用它将展开式(等式左边)转换分解为分解式(等式右边)：

 >>> from sympy import factor
 >>> expr = x**2 - y**2
 >>> factor(expr)
 (x - y)*(x + y)

根预期一样，我们对展开式分解因式，得到了方解式，现在我们对其进行逆运算，将其展开：

 >>> from sympy import expand
 >>> factors = factor(expr)
 >>> expand(factors)
 x**2 - y**2

我们使用一个标签factors来指代方解式，将其作为参数传入expand()函数，进行展开，得到最初的表达式，尝试一下更复杂的等式:

 >>> expr = x**3 + 3*x**2*y + 3*x*y**2 + y**3
 >>> factors = factor(expr)
 (x + y)**3
 >>> expand(factors)
 x**3 + 3*x**2*y + 3*x*y**2 + y**3

对于无法分解的表达式，factor()函数会返回原表达式，例如：

 >>> expr = x + y + x*y
 >>> factor(expr)
 x + y + x*y

同样，如果表达式无法通过expand()展开，它将返回原表达式。

4.2.2 使表达式整齐输出

如果希望所处理的表达式在输出时看起来整齐一些，可以使用pprint()函数，这个函数将以更接近于我们通常看到的形式来输出表达式，例如：

 >>> expr = x*x + 2*x*y + y*y

如果我们使用之前的输出方法print()函数，输出结果为原表达式：

 >>> expr
 x*x + 2*x*y + y*y

现在我们使用pprint()函数来进行输出，并与之前的输出作比较，如下所示：

 >>> from sympy import pprint
 >>> pprint(expr)
  2            2
 x  + 2*x*y + y 

这种形式的输出可能有点傻，但是却更容易看清楚。比如我们再看看一个表达式：

 >>> expr = 1 + 2*x +2*x**2
 >>> pprint(expr)
    2          
 2*x  + 2*x + 1

这些项按照x的幂顺序排列，由高到低。如果你希望得到相反的顺序，即x的最高次幂在最后面，可以使用init_printing()函数，如下所示：

 >>> from sympy import init_printing
 >>> init_printing(order='rev-lex')
 >>> pprint(expr)
              2
 1 + 2*x + 2*x 

导入init_printing()函数，使用关键字order='rev-lex'调用。这表明，我们需要SymPy以相反顺序输出表达式。这种情况下，关键字告诉Python收i谢娜输出低阶幂项。

注：我们这里使用init_printing()函数来配置表达式的输出顺序，但是此函数还有更多的方法来配置表达式的输出形式。关于SymPy中输出的更多选项和使用方式，请参阅Printing — SymPy 1.10.1 documentation[
https://docs.sympy.org/latest/tutorial/printing.html]上的文档。

4.2.3 输出级数

考虑以下级数：

编写一个程序，让用户输入一个数字n（项数），然后输出这个项数的级数。在级数中，x是一个符号，n是用户输入的众数。该级数的第n项由下式给出：

我们可以使用下面的程序输出这个级数：

 '''
 Print the series:
 '''
 from sympy import Symbol, pprint, init_printing, symbols
 from fractions import Fraction
 def print_series(n):
     init_printing(order='rev-lex')
     x = Symbol('x')
     expr = x
     for i in range(2, n+1):
         expr += x**i/i
     pprint(expr)
 
 if __name__ == '__main__':
     n = int(input('Enter the umber of terms you want in the series: '))
     print_series(n)

print_series()函数接受一个指定的级数n作为参数，并且注意需要将传入的n转为整数传入。然后调用init_printing()函数以阶数从小到大输出。

创建expr指代我们的级数，从2开始至n+1结束（此处也可从1开始，但是expr=0）进行迭代，然后对expr累加赋值，具体结果如下：

 i = 2, series = x + x**2 / 2
 i = 3, series = x + x**2 / 2 + x**3 / 3

级数的值由x开始，但在每一次的迭代中，x**i/i会被累加到expr中，直到传入的n为止。最后执行程序：

 Enter the umber of terms you want in the series: 5
      2    3    4    5
     x    x    x    x 
 x + ── + ── + ── + ──
     2    3    4    5 

尝试指定不同的n来运行程序。接下来，我们将学习如何计算当x为某个值时这个级数的和。

4.2.4 用值替代符号

下面我们学习使用Sympy把具体的值带入到表达式中，这样就可以用变量的特定值来计算表达式的值。考虑表达式，定义如下：

 >>> from sympy import symbols
 >>> x, y = symbols('x, y')
 >>> x*x + x*y + x*y + y*y
 x**2 + 2*x*y + y**2

如果要计算这一表达式，可以使用subs()函数将值代入：

 >>> expr = x*x + x*y + x*y + y*y
 >>> res = expr.subs({x:1, y:2}) 

首先创建了一个标签expr来指代我们的表达式，然后调用subs()函数，该函数的参数是一个字典（dictionary）,其中包含两个符号标签以及要填换的具体数值。结果如下：

 >>> res
 9

你也可以使用一个符号来表示了一个符号，并使用subs()函数进行相应的替换。例如，如果已知x = 1 - y，计算上述表达式：

 >>> res = expr.subs({x:1-y})
 >>> res
        2                  2
 (1 - y)  + 2*y*(1 - y) + y 

我们发现这个结果并不是最简结果，还可以继续简化，我们使用SymPy的simplify()函数，如下：

 >>> expr_subs = expr.subs({x:1-y})
 >>> from sympy import simplify
 >>> simplify(expr_subs)
 1

其中，某些项相互抵消了，计算结果为1。

虽然在前面例子中有过表达式的简化形式，但你必须要求SymPy 使用simplify() 函数来简化这个表达式。再次强调，在没有明确指定时，SymPy 不会对表达式进行 简化。 simplify()函数可以简化复杂的表达式，如那些包括对数和三角函数的函数，但是我们不会在这里讨论这些内容。 计算级数的值 让我们回忆一下级数输出的程序。除了输出级数以外，我们希望对于一个特定的值x，程序能够计算出级数的值。因此，程序将从用户那里得到两个参数：级数的项数和计算序列值的x的值。然后，程序将输出级数和级数总和。下面的程序扩展了级数输出程序，以包括上述增加的功能:

 '''
 Print the series:
 '''
 from sympy import Symbol, pprint, init_printing, symbols
 from fractions import Fraction
 
 
 def print_series(n, x_value):
     init_printing(order='rev-lex')
     x = Symbol('x')
     expr = x
     for i in range(2, n + 1):
         expr += x ** i / i
     pprint(expr)
     res = expr.subs({x:x_value})
     print('res = {0}'.format(res))
 
 
 if __name__ == '__main__':
     n = int(input('Enter the umber of terms you want in the series: '))
     x_value = float(input('Enter the value of x at which you want to evaluate the series: '))
     print_series(n, x_value)

现在，就需要额外传入一个参数x来计算级数的和，将其保存在标签x_value中调用print_series()函数。

执行程序：

 Enter the umber of terms you want in the series: 5
 Enter the value of x at which you want to evaluate the series: 1.2
      2    3    4    5
     x    x    x    x 
 x + ── + ── + ── + ──
     2    3    4    5 
 res = 3.51206400000000

4.2.5 将字符串转为数学表达式

到目前为止，我们每次都出于具体目的写出表达式。但是，如果希望编写一个更通用的程序，要求这个程序可以处理用户提供的任何表达式该怎么办呢？为此，我们需要一种方法， 将用户的输入(字符串)转换为可以执行数学运算的内容。SymPy的sympify0函数能帮助我们做到这一点， 该函数可以将字符串转换为SymPy对象，以方便应用SymPy的函数。让我们看一个例子:

 >>> from sympy import sympify
 >>> expr = input('Enter a mathmatical experssion: ')
 Enter a mathmatical experssion: x**2 + 3*x + x**3 + 2*x
 >>> expr = sympify(expr)

首先导入simpify()函数，然后使用input()函数得到一个数学表达式，并将表达式作为输入，使用exper来指代它。下一步，我们以expr作为参数调用simpify()函数，并使用相同的标签来指代转换后的表达式。

可以对转换后的表达式做各种运算，尝试将表达式乘以2：

 >>> 2*expr
           2      3
 10*x + 2*x  + 2*x 

那么用户提供无效表达式时会发生什么？看下面的例子：

 >>> expr = input('Enter a mathmatical experssion: ')
 Enter a mathmatical experssion: x**2 + 3*x + x**3 + 2x
 >>> expr = sympify(expr)
 During handling of the above exception, another exception occurred:
 Traceback (most recent call last):
   File "", line 1, in 
     expr = sympify(expr)
   File "C:\Users\32645\AppData\Roaming\Python\Python36\site-packages\sympy\core\sympify.py", line 474, in sympify
     raise SympifyError('could not parse %r' % a, exc)
 sympy.core.sympify.SympifyError: Sympify of expression 'could not parse 'x**2 + 3*x + x**3 + 2x''

由错误内容可知，sympify()不能转换输入的表达式。因为用户没有在x与2之间输入运算符，所以SymPy不明白这是什么意思。程序应该预计到此类无效输入，并再出现错误信息时输出错误提示，下面就要用到第一章提到的异常捕获了：

 >>> from sympy import sympify
 >>> from sympy.core.sympify import SympifyError
 >>> expr = input('Enter a mathmatical experssion: ')
 >>> try:
     expr = sympify(expr)
 except SympifyError:
     print('Invalid input')
 
 Invalid input

就是简单的导入SympifyError异常类并且在try...except模块中调用simpify()函数。如果出现SympifyError异常就会输出一条错误信息。

4.2.6 表达式乘法

让我们运用刚刚学到的sumpify()函数编写一个程序来计算两个表达式的乘积：

 '''
 Product of two expressions
 '''
 
 from sympy import expand, factor, sympify
 from sympy.core.sympify import  SympifyError
 def product(expr1, expr2):
     prod = expand(expr1 * expr2)
     print(prod)
 if __name__ == '__main__':
     expr1 = input('Enter the first expression : ')
     expr2 = input('Enter the second expression : ')
     try:
         expr1 = sympify(expr1)
         expr2 = sympify(expr2)
     except SympifyError:
         print('Invalid input')
     else:
         product(expr1, expr2)

询问用户输入两个表达式，然后再try...except模块中调用sympify()函数将字符串表达式转为表达式对象。如果转换成功（else）调用product()函数计算两表达式乘积并输出结果。注意：使用expand()函数输出乘积结果，该结果用其所有项的和来表示。

运行程序：

 Enter the first expression : x**2 + x*2 +x
 Enter the second expression : x**3 + x*3 +x
 x**5 + 3*x**4 + 4*x**3 + 12*x**2

当然，我们也可以输入包含多个符号的表达式作为参数：

 Enter the first expression : x*y+x
 Enter the second expression : x*x+y
 x**3*y + x**3 + x*y**2 + x*y