[从头学数学] 第111节 整式的加减 小结与复习题

剧情提要：
[机器小伟]在[工程师阿伟]的陪同下进入了筑基初期的修炼，
这次要修炼的目标是[整式的加减 小结与复习题]。

正剧开始：

星历2016年02月27日 09:35:40, 银河系厄尔斯星球中华帝国江南行省。
[工程师阿伟]正在和[机器小伟]一起继续研究整式的加减。

现在，小伟已经对上一节修炼中制造的工具进行了改良，看看能不能轻松地

完成这一次功法的修炼吧。

<span style="font-size:18px;">#题2

>>> 
['-0.5a2b', '0.14m4n2', 'x2+y2-1', 'x', '3x2-y+3xy3+x4-1', '32t3', '2x-y']
单项式-0.5a2b 的系数是-0.5， 次数是3，详细是[['a', 2], ['b', 1]]。
单项式0.14m4n2 的系数是0.14， 次数是6，详细是[['m', 4], ['n', 2]]。
x2+y2-1 不是单项式。
多项式x2+y2-1 具有以下的项： ['x2', 'y2', '-1']
其中各单项分别是：
单项式x2 的系数是1， 次数是2，详细是[['x', 2]]。
单项式y2 的系数是1， 次数是2，详细是[['y', 2]]。
单项式-1 的系数是-1， 次数是0，
合并同类项后详细情况是： [[1, 2, [['x', 2]]], [1, 2, [['y', 2]]], [-1, 0, []]]
合并同类项后是:x2+y2-1


单项式x 的系数是1， 次数是1，详细是[['x', 1]]。
3x2-y+3xy3+x4-1 不是单项式。
多项式3x2-y+3xy3+x4-1 具有以下的项： ['3x2', '-y', '3xy3', 'x4', '-1']
其中各单项分别是：
单项式3x2 的系数是3， 次数是2，详细是[['x', 2]]。
单项式-y 的系数是-1， 次数是1，详细是[['y', 1]]。
单项式3xy3 的系数是3， 次数是4，详细是[['x', 1], ['y', 3]]。
单项式x4 的系数是1， 次数是4，详细是[['x', 4]]。
单项式-1 的系数是-1， 次数是0，
合并同类项后详细情况是： [[3, 2, [['x', 2]]], [-1, 1, [['y', 1]]], [3, 4, [['x', 1], ['y', 3]]], [1, 4, [['x', 4]]], [-1, 0, []]]
合并同类项后是:3x2-y+3xy3+x4-1


单项式32t3 的系数是32， 次数是3，详细是[['t', 3]]。
2x-y 不是单项式。
多项式2x-y 具有以下的项： ['2x', '-y']
其中各单项分别是：
单项式2x 的系数是2， 次数是1，详细是[['x', 1]]。
单项式-y 的系数是-1， 次数是1，详细是[['y', 1]]。
合并同类项后详细情况是： [[2, 1, [['x', 1]]], [-1, 1, [['y', 1]]]]
合并同类项后是:2x-y

def tmp():
    a = ['-1/2a2b', '1/7m4n2', 'x2+y2-1', 'x', '3x2-y+3xy3+x4-1', '32t3',\
         '2x-y'];

    size = len(a);

    for i in range(size):
        a[i] = algExpr(a[i]);
    print(a);

    for i in range(size):
        result = monomial(a[i]);

        if (len(result)==0):
            polynomial(a[i]);
    return;</span>

这个解答可真是多啊，小伟忍不住打了个哈欠。好在结论还是比较清楚的，倒也不用费太多事。

<span style="font-size:18px;">#题3

>>> 
['x2y-3x2y', '10y2+0.5y2', '-0.5a2bc+0.5cba2', '0.25mn-0.33mn+7', '7ab-3a2b2+7+8ab2+3a2b2-3-7ab', '3x3-3x2-y2+5y+x2-5y+y2']
多项式x2y-3x2y 具有以下的项： ['x2y', '-3x2y']
其中各单项分别是：
单项式x2y 的系数是1， 次数是3，详细是[['x', 2], ['y', 1]]。
单项式-3x2y 的系数是-3， 次数是3，详细是[['x', 2], ['y', 1]]。
合并同类项后详细情况是： [[-2, 3, [['x', 2], ['y', 1]]]]
合并同类项后是:-2x2y


多项式10y2+0.5y2 具有以下的项： ['10y2', '0.5y2']
其中各单项分别是：
单项式10y2 的系数是10， 次数是2，详细是[['y', 2]]。
单项式0.5y2 的系数是0.5， 次数是2，详细是[['y', 2]]。
合并同类项后详细情况是： [[10.5, 2, [['y', 2]]]]
合并同类项后是:10.5y2


多项式-0.5a2bc+0.5cba2 具有以下的项： ['-0.5a2bc', '0.5cba2']
其中各单项分别是：
单项式-0.5a2bc 的系数是-0.5， 次数是4，详细是[['a', 2], ['b', 1], ['c', 1]]。
单项式0.5cba2 的系数是0.5， 次数是4，详细是[['a', 2], ['b', 1], ['c', 1]]。
合并同类项后详细情况是： []
合并同类项后是:0


多项式0.25mn-0.33mn+7 具有以下的项： ['0.25mn', '-0.33mn', '7']
其中各单项分别是：
单项式0.25mn 的系数是0.25， 次数是2，详细是[['m', 1], ['n', 1]]。
单项式-0.33mn 的系数是-0.33， 次数是2，详细是[['m', 1], ['n', 1]]。
单项式7 的系数是7， 次数是0，
合并同类项后详细情况是： [[-0.08, 2, [['m', 1], ['n', 1]]], [7, 0, []]]
合并同类项后是:-0.08mn+7


多项式7ab-3a2b2+7+8ab2+3a2b2-3-7ab 具有以下的项： ['7ab', '-3a2b2', '7', '8ab2', '3a2b2', '-3', '-7ab']
其中各单项分别是：
单项式7ab 的系数是7， 次数是2，详细是[['a', 1], ['b', 1]]。
单项式-3a2b2 的系数是-3， 次数是4，详细是[['a', 2], ['b', 2]]。
单项式7 的系数是7， 次数是0，
单项式8ab2 的系数是8， 次数是3，详细是[['a', 1], ['b', 2]]。
单项式3a2b2 的系数是3， 次数是4，详细是[['a', 2], ['b', 2]]。
单项式-3 的系数是-3， 次数是0，
单项式-7ab 的系数是-7， 次数是2，详细是[['a', 1], ['b', 1]]。
合并同类项后详细情况是： [[4, 0, []], [8, 3, [['a', 1], ['b', 2]]]]
合并同类项后是:4+8ab2


多项式3x3-3x2-y2+5y+x2-5y+y2 具有以下的项： ['3x3', '-3x2', '-y2', '5y', 'x2', '-5y', 'y2']
其中各单项分别是：
单项式3x3 的系数是3， 次数是3，详细是[['x', 3]]。
单项式-3x2 的系数是-3， 次数是2，详细是[['x', 2]]。
单项式-y2 的系数是-1， 次数是2，详细是[['y', 2]]。
单项式5y 的系数是5， 次数是1，详细是[['y', 1]]。
单项式x2 的系数是1， 次数是2，详细是[['x', 2]]。
单项式-5y 的系数是-5， 次数是1，详细是[['y', 1]]。
单项式y2 的系数是1， 次数是2，详细是[['y', 2]]。
合并同类项后详细情况是： [[3, 3, [['x', 3]]], [-2, 2, [['x', 2]]]]
合并同类项后是:3x3-2x2

def tmp():
    a = ['x2y-3x2y', '10y2+0.5y2', '-1/2a2bc+1/2cba2',\
         '1/4mn-1/3mn+7', '7ab-3a2b2+7+8ab2+3a2b2-3-7ab',\
         '3x3-3x2-y2+5y+x2-5y+y2'];

    size = len(a);

    for i in range(size):
        a[i] = algExpr(a[i]);
    print(a);

    for i in range(size):
        polynomial(a[i]);
    return;</span>

这些解答太浮夸了，小伟一阵无语，好在经过检验，结果是对的。

<span style="font-size:18px;">#题4

>>> 
['4a3b-10b3-3a2b2+10b3', '4x2y-5xy2-3x2y+4xy2', '5a2-a2-5a2+2a+2a2-6a', '15+3-3a-1+a+a2+1-a+a2-a3', '4a2b-3ab-5a2b+2ab', '6m2-4m-3+2m2-4m+1', '5a2+2a-1-12+32a-8a2', '3x2-5x+0.5x-3-2x2']
<1>

多项式4a3b-10b3-3a2b2+10b3 具有以下的项： ['4a3b', '-10b3', '-3a2b2', '10b3']
其中各单项分别是：
单项式4a3b 的系数是4， 次数是4，详细是[['a', 3], ['b', 1]]。
单项式-10b3 的系数是-10， 次数是3，详细是[['b', 3]]。
单项式-3a2b2 的系数是-3， 次数是4，详细是[['a', 2], ['b', 2]]。
单项式10b3 的系数是10， 次数是3，详细是[['b', 3]]。
合并同类项后详细情况是： [[4, 4, [['a', 3], ['b', 1]]], [-3, 4, [['a', 2], ['b', 2]]]]
合并同类项后是:4a3b-3a2b2


<2>

多项式4x2y-5xy2-3x2y+4xy2 具有以下的项： ['4x2y', '-5xy2', '-3x2y', '4xy2']
其中各单项分别是：
单项式4x2y 的系数是4， 次数是3，详细是[['x', 2], ['y', 1]]。
单项式-5xy2 的系数是-5， 次数是3，详细是[['x', 1], ['y', 2]]。
单项式-3x2y 的系数是-3， 次数是3，详细是[['x', 2], ['y', 1]]。
单项式4xy2 的系数是4， 次数是3，详细是[['x', 1], ['y', 2]]。
合并同类项后详细情况是： [[1, 3, [['x', 2], ['y', 1]]], [-1, 3, [['x', 1], ['y', 2]]]]
合并同类项后是:x2y-xy2


<3>

多项式5a2-a2-5a2+2a+2a2-6a 具有以下的项： ['5a2', '-a2', '-5a2', '2a', '2a2', '-6a']
其中各单项分别是：
单项式5a2 的系数是5， 次数是2，详细是[['a', 2]]。
单项式-a2 的系数是-1， 次数是2，详细是[['a', 2]]。
单项式-5a2 的系数是-5， 次数是2，详细是[['a', 2]]。
单项式2a 的系数是2， 次数是1，详细是[['a', 1]]。
单项式2a2 的系数是2， 次数是2，详细是[['a', 2]]。
单项式-6a 的系数是-6， 次数是1，详细是[['a', 1]]。
合并同类项后详细情况是： [[1, 2, [['a', 2]]], [-4, 1, [['a', 1]]]]
合并同类项后是:a2-4a


<4>

多项式15+3-3a-1+a+a2+1-a+a2-a3 具有以下的项： ['15', '3', '-3a', '-1', 'a', 'a2', '1', '-a', 'a2', '-a3']
其中各单项分别是：
单项式15 的系数是15， 次数是0，
单项式3 的系数是3， 次数是0，
单项式-3a 的系数是-3， 次数是1，详细是[['a', 1]]。
单项式-1 的系数是-1， 次数是0，
单项式a 的系数是1， 次数是1，详细是[['a', 1]]。
单项式a2 的系数是1， 次数是2，详细是[['a', 2]]。
单项式1 的系数是1， 次数是0，
单项式-a 的系数是-1， 次数是1，详细是[['a', 1]]。
单项式a2 的系数是1， 次数是2，详细是[['a', 2]]。
单项式-a3 的系数是-1， 次数是3，详细是[['a', 3]]。
合并同类项后详细情况是： [[18, 0, []], [-3, 1, [['a', 1]]], [2, 2, [['a', 2]]], [-1, 3, [['a', 3]]]]
合并同类项后是:18-3a+2a2-a3


<5>

多项式4a2b-3ab-5a2b+2ab 具有以下的项： ['4a2b', '-3ab', '-5a2b', '2ab']
其中各单项分别是：
单项式4a2b 的系数是4， 次数是3，详细是[['a', 2], ['b', 1]]。
单项式-3ab 的系数是-3， 次数是2，详细是[['a', 1], ['b', 1]]。
单项式-5a2b 的系数是-5， 次数是3，详细是[['a', 2], ['b', 1]]。
单项式2ab 的系数是2， 次数是2，详细是[['a', 1], ['b', 1]]。
合并同类项后详细情况是： [[-1, 3, [['a', 2], ['b', 1]]], [-1, 2, [['a', 1], ['b', 1]]]]
合并同类项后是:-a2b-ab


<6>

多项式6m2-4m-3+2m2-4m+1 具有以下的项： ['6m2', '-4m', '-3', '2m2', '-4m', '1']
其中各单项分别是：
单项式6m2 的系数是6， 次数是2，详细是[['m', 2]]。
单项式-4m 的系数是-4， 次数是1，详细是[['m', 1]]。
单项式-3 的系数是-3， 次数是0，
单项式2m2 的系数是2， 次数是2，详细是[['m', 2]]。
单项式-4m 的系数是-4， 次数是1，详细是[['m', 1]]。
单项式1 的系数是1， 次数是0，
合并同类项后详细情况是： [[8, 2, [['m', 2]]], [-8, 1, [['m', 1]]], [-2, 0, []]]
合并同类项后是:8m2-8m-2


<7>

多项式5a2+2a-1-12+32a-8a2 具有以下的项： ['5a2', '2a', '-1', '-12', '32a', '-8a2']
其中各单项分别是：
单项式5a2 的系数是5， 次数是2，详细是[['a', 2]]。
单项式2a 的系数是2， 次数是1，详细是[['a', 1]]。
单项式-1 的系数是-1， 次数是0，
单项式-12 的系数是-12， 次数是0，
单项式32a 的系数是32， 次数是1，详细是[['a', 1]]。
单项式-8a2 的系数是-8， 次数是2，详细是[['a', 2]]。
合并同类项后详细情况是： [[-3, 2, [['a', 2]]], [34, 1, [['a', 1]]], [-13, 0, []]]
合并同类项后是:-3a2+34a-13


<8>

多项式3x2-5x+0.5x-3-2x2 具有以下的项： ['3x2', '-5x', '0.5x', '-3', '-2x2']
其中各单项分别是：
单项式3x2 的系数是3， 次数是2，详细是[['x', 2]]。
单项式-5x 的系数是-5， 次数是1，详细是[['x', 1]]。
单项式0.5x 的系数是0.5， 次数是1，详细是[['x', 1]]。
单项式-3 的系数是-3， 次数是0，
单项式-2x2 的系数是-2， 次数是2，详细是[['x', 2]]。
合并同类项后详细情况是： [[1, 2, [['x', 2]]], [-4.5, 1, [['x', 1]]], [-3, 0, []]]
合并同类项后是:x2-4.5x-3


>>> 

def tmp():
    a = ['4a3b-10b3-3a2b2+10b3', \
         '4x2y-5xy2-3x2y+4xy2',\
         '5a2-a2-5a2+2a+2a2-2*3a',\
         '15+3-3a-1+a+a2+1-a+a2-a3',\
         '4a2b-3ab-5a2b+2ab',\
         '6m2-4m-3+2m2-4m+1',\
         '5a2+2a-1-4*3+32a-8a2',\
         '3x2-5x+1/2x-3-2x2'];

    size = len(a);

    for i in range(size):
        a[i] = algExpr(a[i]);
    print(a);

    for i in range(size):
        print('<{0}>\n'.format(i+1));
        polynomial(a[i]);
    return;

</span>

这去括号的事只能[工程师阿伟]亲自动手了，这让小伟做的事越多，出错的可能性可就越大。

为了结果的正确性着想，还是将就点好了。

这道题如果不看结果，小伟也觉得很平常，还是看下结果吧。

<span style="font-size:18px;">#题5

>>> 
['5x2+4-3x2-5x-2x2-5+6x']
<1>

多项式5x2+4-3x2-5x-2x2-5+6x 具有以下的项： ['5x2', '4', '-3x2', '-5x', '-2x2', '-5', '6x']
其中各单项分别是：
单项式5x2 的系数是5， 次数是2，详细是[['x', 2]]。
单项式4 的系数是4， 次数是0，
单项式-3x2 的系数是-3， 次数是2，详细是[['x', 2]]。
单项式-5x 的系数是-5， 次数是1，详细是[['x', 1]]。
单项式-2x2 的系数是-2， 次数是2，详细是[['x', 2]]。
单项式-5 的系数是-5， 次数是0，
单项式6x 的系数是6， 次数是1，详细是[['x', 1]]。
合并同类项后详细情况是： [[-1, 0, []], [1, 1, [['x', 1]]]]
合并同类项后是:-1+x</span>

[人叫板老师]真会开玩笑，是吧。

口算得到答案是-4。

<span style="font-size:18px;">#题9

>>> 
['12.56r', '6.28r+2.09r+1.05r']
多项式12.56r 具有以下的项： ['12.56r']
其中各单项分别是：
单项式12.56r 的系数是12.56， 次数是1，详细是[['r', 1]]。
合并同类项后详细情况是： [[12.56, 1, [['r', 1]]]]
合并同类项后是:12.56r


多项式6.28r+2.09r+1.05r 具有以下的项： ['6.28r', '2.09r', '1.05r']
其中各单项分别是：
单项式6.28r 的系数是6.28， 次数是1，详细是[['r', 1]]。
单项式2.09r 的系数是2.09， 次数是1，详细是[['r', 1]]。
单项式1.05r 的系数是1.05， 次数是1，详细是[['r', 1]]。
合并同类项后详细情况是： [[9.42, 1, [['r', 1]]]]
合并同类项后是:9.42r

def tmp():
    a = ['2*2*3.14r',\
         '2*3.14r+2*1/3*3.14r+2*1/6*3.14r'];

    size = len(a);

    for i in range(size):
        a[i] = algExpr(a[i]);
    print(a);

    for i in range(size):
        #print('<{0}>\n'.format(i+1));
        polynomial(a[i]);
    return;</span>

看来[人叫板老师]的问题，小伟都解答完毕了。

这里小伟整理了一下用到的工具：

<span style="font-size:18px;">###
# @usage   单项式相关概念
# @author  mw
# @date    2016年02月26日  星期五  10:00:14 
# @param
# @return
#
###
#单项式
#可以有**， ^号，暂时只能处理代号为一个字母的式子，像x_1, x_n, ...这种还不能处理。
def monomial(s):
    #原始复本
    s0 = s;
    
    s = s.replace('**', '^');
    s = s.replace('*', '');

    if (s.find('+') != -1 or (s.find('-') != -1 and s.find('-')!=0)):
        print(s0, '不是单项式。');
        return [];
        
    try:
        #系数
        sign = 1;
        if s[0] == '-':
            #负号
            sign = -1;
            s = s[1:];
        coefficient = 1;

        #字符串长度
        length = len(s);
        index = 0;
        while (not s[index].isalpha()):
            index+=1;
            if index >= length:
                index = length;
                break;

        if (index > 0):
            coefficient = float(s[:index]);
            if abs(int(coefficient)-coefficient) < 0.001:
                coefficient = int(coefficient);        
            s = s[index:];
            
        coefficient = sign * coefficient;
        #系数为0的项，其实就是0
        if (coefficient == 0):
            return [];
        #print(coefficient, s);

        length = len(s);
        array = [];
        if (length > 0):
            index = 0;
            index2 = 0;
            name = '';
            degree = 0;
            while index < length:        
                if s[index].isalpha():
                    if (name != ''):
                        array.append([name, degree]);
                        name = '';
                        degree = 0;
                    name = s[index];
                    degree = 1;
                    index += 1;
                else:
                    index2 = index;
                    tmp = '';
                    while (not s[index2].isalpha()):
                        index2+=1;
                        if (index2 >= length):
                            index2 = length;
                            break;
                    tmp = s[index:index2];
                    tmp = tmp.replace('^', '');
                    degree = float(tmp);
                    if abs(int(degree)-degree) < 0.001:
                        degree = int(degree);

                    index = index2;
            if (name != ''):
                array.append([name, degree]);
                name = '';
                degree = 0;
                
            #print(array);

            #所有字母，去除重复的
            setA = set();
            size = len(array);
            #单项式的次数
            totalDegree = 0;
            for i in range(size):
                setA.add(array[i][0]);
                totalDegree += array[i][1];

            listA = list(setA);
            listA.sort();
            size2 = len(listA);
            result = [];
            for i in range(size2):
                #计算每个字母的次数(degree)
                tmp = 0;
                for j in range(size):
                    if listA[i] == array[j][0]:
                        tmp += array[j][1];

                result.append([listA[i], tmp]);

            print('单项式{0} 的系数是{1}， 次数是{2}，详细是{3}。'.format(\
                s0, coefficient, totalDegree, result));
        else:
            totalDegree = 0;
            if (coefficient != 0):
                print('单项式{0} 的系数是{1}， 次数是{2}，'.format(\
                    s0, coefficient, 0));
            else:
                print('这个数是0, 暂无规定。');
        #返回单项式的次数
        return [coefficient, totalDegree, array];
    except:
        print(s0, '有误，无法正确计算。');

###
# @usage   多项式相关概念
# @author  mw
# @date    2016年02月26日  星期五  10:30:37 
# @param   如果有括号，需要先自行去除，
# @return
#
###
def polynomial(s):
    if (s == ''):
        return;
    
    #预留复本
    s0 = s;

    #只能有+或-号连接各项，不能有括号，分数要先化成小数
    s = s.replace('-', '+-');
    if (s[0] == '+'):
        s = s[1:];
    #各项
    terms = s.split('+');
    

    print('多项式{0} 具有以下的项： {1}\n其中各单项分别是：'.format(s0, terms));

    try:
        size = len(terms);
        array = [];
        for i in range(size):
            #此处也可扩展单项的合法性检查。
            if (terms[i] == ''):
                pass;
            else:
                tmp = monomial(terms[i]);
                #对于返回[]的项，剔除掉
                if len(tmp)>0:
                    array.append(tmp);
        #print(array);

        size2 = len(array);

        for i in range(size2):
            #判断系数是否是0
            if array[i][0] == 0:
                continue;
            for j in range(i+1, size2):
                if array[j][0] == 0:
                    continue;
                else:
                    if (sameTerm(array[i], array[j])):
                        #合并同类项
                        array[i][0]+=array[j][0];
                        array[j][0] = 0;

        result = [];
        for i in range(size2):
            #判断系数是否是0
            if array[i][0] == 0:
                continue;
            else:
                #保留三位小数
                array[i][0] = round(array[i][0], 3);
                result.append(array[i]);

        print('合并同类项后详细情况是：', result);
        sResult = '';
        size3 = len(result);
        if (size3)>0:
            for i in range(size3):
                tmp1 = result[i][0];
                if (tmp1 >= 0):
                    if (tmp1 != 1):
                        sResult += '+'+str(tmp1);
                    else:
                        sResult += '+';
                if (tmp1 < 0):
                    if (tmp1!=-1):
                        sResult += str(tmp1);
                    else:
                        sResult += '-';

                tmp2 = result[i][2];
                length = len(tmp2);
                if (length == 0 and abs(tmp1)==1):
                    sResult += '1';
                else:
                    for j in range(length):
                        if tmp2[j][1] != 1:
                            sResult += tmp2[j][0]+str(tmp2[j][1]);
                        else:
                            sResult += tmp2[j][0];
            if sResult[0] == '+':
                sResult = sResult[1:];
        else:
            #所有项的系数刚好抵消，导致结果为0
            sResult = '0';
        print('合并同类项后是:{0}\n\n'.format(sResult));
    except:
        print(s0, '有误，无法进行多项式操作。');
    return;

                

#同类项判断
def sameTerm(a, b):
    #由于a, b具有以下格式[1, 1, [['v', 1]]] [系数, 次数, 详细元素]
    if (a[1] == 0 and b[1] == 0):
        return True;
    
    if (a[1] != b[1]):
        #次数不同
        return False;
    if (len(a[2]) != len(b[2])):
        #元素个数不同
        return False;

    a1 = list(a[2]);
    b1 = list(b[2]);
    a1 = sorted(a1, key=lambda num:num[0]);
    b1 = sorted(b1, key=lambda num:num[0]);
    size = len(a1);
    for i in range(size):
        if a1[i][0] != b1[i][0] or a1[i][1] != b1[i][1]:
            return False;

    return True;

###
# @usage   代数式，可以对系数中含计算式的情况进行计算，得出简化后的多项式字符串
# @author  mw
# @date    2016年02月27日  星期六  09:23:44 
# @param
# @return
#
###
#代数式
def algExpr(s):
    s0 = s;

    #判断字符串中左右括号是否匹配
    if s.count('(') - s.count(')') != 0:
        print(s, '左右括号数目不匹配，表达式有误。');
        return '';
    #去除空格
    s = s.replace(' ', '');
    #存放需要计算的表达式子串
    sub = '';
    length = len(s);
    #新字符串
    sNew = '';
    #括号层次
    bracket = 0;

    result = [];

    #需要计算的部分，是从每一个单项的开始处，一般只需要计算系数
    need = 1;
    
    #遍历字符串s
    i = 0;
    while i < length:
        if (s[i] == '('):
            bracket+=1;
            sub += s[i];
        elif (s[i] == ')'):
            bracket -=1;
            sub += s[i];                
        elif (s[i].isalpha()):
            if sub != '':
                sNew += str(round(eval(sub), 2))+ s[i];
                sub = '';
            else:
                sNew += s[i];
            #由于字母后面是次数，不需要计算
            need = 0;            
        elif (s[i] == '+' or s[i] == '-'):
            if (bracket == 0):
                if sub != '':
                    sNew += str(round(eval(sub), 2))+ s[i];
                    sub = '';
                else:
                    sNew += s[i];
                need = 1;
            else:
                sub += s[i];
        else:
            if (need == 1):
                sub += s[i];
            else:
                sNew += s[i];

        i += 1;

    if sub != '':
        sNew += str(round(eval(sub), 2));
        sub = '';

    #print(sNew);
    return sNew;      
        
def tmp():
    a = ['2*2*3.14r',\
         '2*3.14r+2*1/3*3.14r+2*1/6*3.14r'];

    size = len(a);

    for i in range(size):
        a[i] = algExpr(a[i]);
    print(a);

    for i in range(size):
        #print('<{0}>\n'.format(i+1));
        polynomial(a[i]);
    return;
</span>

涉及到手算的，就是麻烦，不知不觉就有这么多了。

本节到此结束，欲知后事如何，请看下回分解。