使用带有逻辑条件的循环使用python生成字符串针对连接函数替代方案的问题？

为了生成拉格朗日插值表达式，我编写了一个函数

所以我得到：

def polinomioLagrange(Xs, Ys, t):

    for k in range(len(Xs)):

        if k >0: 
            expresion = expresion + '+' + str(Ys[k]) + '*'
        elif k==0:
            expresion = expresion + str(Ys[k]) + '*'

        expresion = expresion + '('

        for i in range(len(Xs)):
            if k==i:
                continue 

            expresion = expresion + '(' + '3' + '-' + str(Xs[i]) + ')'

            if k != len(Xs)-1 and i!= len(Xs)-1:
                expresion=expresion+'*'

        expresion = expresion + '/'

        for i in range(len(Xs)):
            if k==i:
                continue 
            expresion = expresion + '(' + str(Xs[k]) + '-' + str(Xs[i]) + ')'

            if i != len(Xs)-1 and k != len(Xs)-1:
                expresion=expresion+'*'             

    print expresion

例如，我通过：

polinomioLagrange（[0,1,2,4]，[7,0，-1,63]，3）来调用它，

得到的输出类似于：

7*((3-1)*(3-2)*(3-4)/(0-1)*(0-2)*(0-4))+0*((3-0)*(3-2)*(3-4)/(1-0)*(1-2)*(1-4))+-1*((3-0)*(3-1)*(3-4)/(2-0)*(2-1)*(2-4))+63*((3-0)(3-1)(3-2)/(4-0)(4-1)(4-2))

可以看出，上学期没有星号：

63*((3-0)(3-1)(3-2)/(4-0)(4-1)(4-2))

那是因为

if k != len(Xs)-1 and i!= len(Xs)-1:
    expresion=expresion+'*'

但我真的玩过索引，并没有得到我想要的结果：

7*((3-1)*(3-2)*(3-4)/(0-1)*(0-2)*(0-4))+0*((3-0)*(3-2)*(3-4)/(1-0)*(1-2)*(1-4))+-1*((3-0)*(3-1)*(3-4)/(2-0)*(2-1)*(2-4))+63*((3-0)*(3-1)*(3-2)/(4-0)*(4-1)*(4-2))

什么样的逻辑条件可以完成这项工作，更重要的是，最简单的方法是什么，使用更复杂的python函数，如

join

来完成这项工作

我得到的最接近的循环和改变逻辑条件是：

if i != len(Xs)-1:
    expresion=expresion+'*'

获取：

7*((3-1)*(3-2)*(3-4)/(0-1)*(0-2)*(0-4))+0*((3-0)*(3-2)*(3-4)/(1-0)*(1-2)*(1-4))+-1*((3-0)*(3-1)*(3-4)/(2-0)*(2-1)*(2-4))+63*((3-0)*(3-1)*(3-2)*/(4-0)*(4-1)*(4-2)*)

几乎正确，除了

..）*/（…

和

..4-2）*）

为了记录在案，这是我正在编写的代码：

---

我认为你让这件事变得更加困难了。与其构建字符串，不如简单地构建符号表达式。我们可以直接实现

l

和

l

：

from sympy import Symbol, prod

def lag_l(xx, j):
    x = Symbol("x")
    parts = ((x - x_i) / (xx[j] - x_i) for i, x_i in enumerate(xx) if i != j)
    return prod(parts)

def lag_L(xx, yy):
    return sum(y*lag_l(xx, j) for j, y in enumerate(yy))

def lag_fn(xx, yy, x):
    return lag_L(xx, yy).subs({'x': x})

然后我们可以得到基函数：

>>> lag_l([1,2,3], 0)
(-x + 2)*(-x/2 + 3/2)
>>> lag_l([1,2,3], 1)
(-x + 3)*(x - 1)
>>> lag_l([1,2,3], 2)
(x/2 - 1/2)*(x - 2)

全插值多项式：

>>> lag_L([1,2,3],[1,4,9])
(-x + 2)*(-x/2 + 3/2) + 4*(-x + 3)*(x - 1) + 9*(x/2 - 1/2)*(x - 2)

我们可以调用函数（这里包装为

lag\u fn

）：

。。当然，插值多项式可以简化很多：

>>> from sympy import simplify
>>> simplify(lag_L([1,2,3],[1,4,9]))
x**2

---

我认为你让这件事变得比实际需要困难得多。与其构建字符串，不如简单地构建符号表达式。我们可以直接实现

l

和

l

：

from sympy import Symbol, prod

def lag_l(xx, j):
    x = Symbol("x")
    parts = ((x - x_i) / (xx[j] - x_i) for i, x_i in enumerate(xx) if i != j)
    return prod(parts)

def lag_L(xx, yy):
    return sum(y*lag_l(xx, j) for j, y in enumerate(yy))

def lag_fn(xx, yy, x):
    return lag_L(xx, yy).subs({'x': x})

然后我们可以得到基函数：

>>> lag_l([1,2,3], 0)
(-x + 2)*(-x/2 + 3/2)
>>> lag_l([1,2,3], 1)
(-x + 3)*(x - 1)
>>> lag_l([1,2,3], 2)
(x/2 - 1/2)*(x - 2)

全插值多项式：

>>> lag_L([1,2,3],[1,4,9])
(-x + 2)*(-x/2 + 3/2) + 4*(-x + 3)*(x - 1) + 9*(x/2 - 1/2)*(x - 2)

我们可以调用函数（这里包装为

lag\u fn

）：

。。当然，插值多项式可以简化很多：

>>> from sympy import simplify
>>> simplify(lag_L([1,2,3],[1,4,9]))
x**2

---

我认为你让这件事变得比实际需要困难得多。与其构建字符串，不如简单地构建符号表达式。我们可以直接实现

l

和

l

：

from sympy import Symbol, prod

def lag_l(xx, j):
    x = Symbol("x")
    parts = ((x - x_i) / (xx[j] - x_i) for i, x_i in enumerate(xx) if i != j)
    return prod(parts)

def lag_L(xx, yy):
    return sum(y*lag_l(xx, j) for j, y in enumerate(yy))

def lag_fn(xx, yy, x):
    return lag_L(xx, yy).subs({'x': x})

然后我们可以得到基函数：

>>> lag_l([1,2,3], 0)
(-x + 2)*(-x/2 + 3/2)
>>> lag_l([1,2,3], 1)
(-x + 3)*(x - 1)
>>> lag_l([1,2,3], 2)
(x/2 - 1/2)*(x - 2)

全插值多项式：

>>> lag_L([1,2,3],[1,4,9])
(-x + 2)*(-x/2 + 3/2) + 4*(-x + 3)*(x - 1) + 9*(x/2 - 1/2)*(x - 2)

我们可以调用函数（这里包装为

lag\u fn

）：

。。当然，插值多项式可以简化很多：

>>> from sympy import simplify
>>> simplify(lag_L([1,2,3],[1,4,9]))
x**2

---

我认为你让这件事变得比实际需要困难得多。与其构建字符串，不如简单地构建符号表达式。我们可以直接实现

l

和

l

：

from sympy import Symbol, prod

def lag_l(xx, j):
    x = Symbol("x")
    parts = ((x - x_i) / (xx[j] - x_i) for i, x_i in enumerate(xx) if i != j)
    return prod(parts)

def lag_L(xx, yy):
    return sum(y*lag_l(xx, j) for j, y in enumerate(yy))

def lag_fn(xx, yy, x):
    return lag_L(xx, yy).subs({'x': x})

然后我们可以得到基函数：

>>> lag_l([1,2,3], 0)
(-x + 2)*(-x/2 + 3/2)
>>> lag_l([1,2,3], 1)
(-x + 3)*(x - 1)
>>> lag_l([1,2,3], 2)
(x/2 - 1/2)*(x - 2)

全插值多项式：

>>> lag_L([1,2,3],[1,4,9])
(-x + 2)*(-x/2 + 3/2) + 4*(-x + 3)*(x - 1) + 9*(x/2 - 1/2)*(x - 2)

我们可以调用函数（这里包装为

lag\u fn

）：

。。当然，插值多项式可以简化很多：

>>> from sympy import simplify
>>> simplify(lag_L([1,2,3],[1,4,9]))
x**2

---

如果我可以的话我会给你+50如果我可以的话我会给你+50如果我可以的话我会给你+50如果我可以的话我会给你+50