Python 如何遍历字母列表以指定浮点值来创建多项式？

我正试图通过梯形方法来积分多项式函数（稍后我可以换成更精确的方法）。我的代码并不完美，我想确切地理解为什么它不工作。我的一个问题是while循环没有结束。到目前为止，我的代码如下

    def Integrate_Trapezoidal(x_LoBound,x_HiBound,N):
        """
        INPUT   :
                    x_LoBound   --      lower bound of integral
                    x_HiBound   --      upper bound of integral
                    N           --      number of slices (N --> inf ==> integral)
        OUTPUT  :
                                --      approximate value of integral
        """
        ## CREATE ALPHABET
        alphabet = [chr(i) for i in range(ord('a'),ord('z')+1)]
        ## alphabet = ['a','b','c',...,'z'] ##
        ## WOULD LOVE TO TRY FLOATING INPUTS VIA ARRAY COMPREHENSION
        a = float(input("What is the coefficient of the lowest order term:  "))
        CoeffList = []
        CoeffNumList = []
        LengthCoeffList = [] ## [1,2,3,...,max] where max = coefficient of highest-order term
        for letter in alphabet:
            AddOne = int(1)
            AddOne += int(1)
            for i in range(int(1),int(AddOne)):
                letter = alphabet[int(i)]
                while letter in alphabet:
                    CoeffList.append(letter)
                    LengthCoeffList.append(len(CoeffList))
                    # alphabet[i]
                    # i = i + 1
                    letter = float(input("What is the coefficient of the next-order term:  ")) ## GO FROM a = ___ TO b = ___ TO c = ___ ...
                    CoeffNumList.append(letter)
                    if float(input("What is the coefficient of the next-order term:  ")) == '0':
                        print("Type 'Y for YES and 'N' for NO")
                        YESorNO = str(input("Is that the last term of the polynomial:  "))
                        endterm = YESorNO[-1] ## look at last character of string
                        if endterm == 'N' or endterm == 'n' or endterm == 'no' or endterm == 'NO' or endterm == 'No':
                            pass
                        elif endterm == 'Y' or endterm == 'y' or endterm == 'YES' or endterm == 'yes' or endterm == 'Yes':
                            break
                            def f(x):
                                """
                                INPUT   :
                                                   x    --  variable of function
                                                        EX: x = x_LoBound OR x = x_HiBound
                                OUTPUT  :
                                            function    --  f(x) = a x^0 + b x^1 + ...
                                                        EX: f(x_LoBound) OR f(x_HiBound)
                                """
                                for expval in LengthCoeffList and CoeffNum in CoeffNumList:
                                    # function = 0
                                    function += CoeffNum * x**expval
                                    return function
                    letter = alphabet[int(i+1)] ## GO FROM a TO b TO c ...
        ## TRAPEZOIDAL RULE
        # def f(x):
        #     return x**4 - 2*x + 1
        ht = (x_HiBound - x_LoBound) / N
        ss = 0.5 * f(x_LoBound) + 0.5 * f(x_HiBound)
        for num in range(1,N):
            ss += f(x_LoBound + num*ht)
        return ht*ss
    checkanswer = Integrate_Trapezoidal(0,2,10)
    print(checkanswer)

---

我仔细检查了你的代码，发现了一些我认为有效的东西，对照我下载的几份大学讲义。正如您在评论中所说的，有很多额外的列表是不必要的，所以我已经在那里大量地缩减了代码

特别是，如果假设每个系数是按从低到高的顺序相加的，并且没有的系数加上0，那么只需要列表中元素的编号就可以知道x的幂

我还移动了

f（）

的定义，以创建辅助函数

solve\u point（）

，我认为它的工作原理与此相同。特别是，内置了

sum

和

enumerate

，通过

enumerate

迭代

coeff_list

，并返回一个计数以给出幂（向上为0）

get\u coefficients（）

源于您以前的

Integrate\u梯形（）

，但它只关注一件事，这就是为什么它会返回

coeflist

以在最后进行处理

def solve_point(x, coeff_list):
    return sum(coeff * x**e for e, coeff in enumerate(coeff_list))


def get_coefficients():
    CoeffList = []
    while True:
        # GO FROM a = ___ TO b = ___ TO c = ___ ...
        coeff = float(input("What is the coefficient of the next-order term:  "))
        CoeffList.append(coeff)
        if coeff == 0:
            YESorNO = raw_input("Is that the last term of the polynomial: [Y/N]  ")
            if YESorNO.upper() == 'Y':
                return CoeffList[:-1]

lo, hi, n = 0, 2, 6
coeff_list = get_coefficients()

ht = (hi - lo) / float(n)
ss = 0.5 * solve_point(lo, coeff_list) + 0.5 * solve_point(hi, coeff_list)
for num in range(1,n):
    ss += solve_point(lo + num*ht, coeff_list)
checkanswer = ht*ss


print(checkanswer)

---

我认为这是对的——我做了几次检查。希望它能对你的重写有所帮助！如果您有任何不起作用的示例，最好知道，或者您能看到的任何错误…

我仔细查看了您的代码，发现了一些我认为有效的东西，并对照我下载的几份大学讲义进行了检查。正如您在评论中所说的，有很多额外的列表是不必要的，所以我已经在那里大量地缩减了代码

特别是，如果假设每个系数是按从低到高的顺序相加的，并且没有的系数加上0，那么只需要列表中元素的编号就可以知道x的幂

我还移动了

f（）

的定义，以创建辅助函数

solve\u point（）

，我认为它的工作原理与此相同。特别是，内置了

sum

和

enumerate

，通过

enumerate

迭代

coeff_list

，并返回一个计数以给出幂（向上为0）

get\u coefficients（）

源于您以前的

Integrate\u梯形（）

，但它只关注一件事，这就是为什么它会返回

coeflist

以在最后进行处理

def solve_point(x, coeff_list):
    return sum(coeff * x**e for e, coeff in enumerate(coeff_list))


def get_coefficients():
    CoeffList = []
    while True:
        # GO FROM a = ___ TO b = ___ TO c = ___ ...
        coeff = float(input("What is the coefficient of the next-order term:  "))
        CoeffList.append(coeff)
        if coeff == 0:
            YESorNO = raw_input("Is that the last term of the polynomial: [Y/N]  ")
            if YESorNO.upper() == 'Y':
                return CoeffList[:-1]

lo, hi, n = 0, 2, 6
coeff_list = get_coefficients()

ht = (hi - lo) / float(n)
ss = 0.5 * solve_point(lo, coeff_list) + 0.5 * solve_point(hi, coeff_list)
for num in range(1,n):
    ss += solve_point(lo + num*ht, coeff_list)
checkanswer = ht*ss


print(checkanswer)

---

我认为这是对的——我做了几次检查。希望它能对你的重写有所帮助！如果您有任何不起作用的示例，最好知道，或者您可以看到的任何错误…

您是否可以尝试将其减少到这段代码的最低版本，仍然重现您的问题（尽可能多地删除；您需要的是代码逻辑方面的帮助，而不是算法本身）。不要在循环中定义函数！我在发布之前减少了代码。如果我进一步减少它，那么运行发布的代码将不会重现我的问题。函数是在循环中定义的，因为它基于用户输入而不是预定义的。循环中的函数接受从循环中创建的值。但是如果你知道一个更好的方法，我很乐意接受。函数是在循环中定义的，因为它是基于用户输入的：那么用户输入应该是函数的一个参数。还有很多你可以脱掉的！事实上，你不太可能让别人看一下你的代码（例如：

Y

是否应该从你的

for

循环中触发一个

break

(“下一个顺序项的系数是什么：”）==“0”永远不会是

真的

：您将

str

与

float

进行比较。在for循环结束时，您选择下一个字母，字母=字母表[int（i+1）]###从a到b再到c…，但实际上不改变I的存储值，所以每次都是一样的。如果你加上I+=1会有帮助吗？你能试着把它减少到这个代码的最小版本，仍然重现你的问题吗（尽可能多地删除；你需要的是代码逻辑方面的帮助，而不是算法本身）。并且不要在循环中定义函数！我在发布之前减少了代码。如果我进一步减少代码，则运行发布的代码不会重新产生问题。函数在循环中定义，因为它基于用户输入，并且不是预定义的。循环中的函数使用从循环中创建的值。但是如果您知道更好的方法，我将我愿意接受这些想法。这个函数是在循环中定义的，因为它是基于用户输入的：那么用户输入应该是这个函数的一个参数。而且有很多东西你可以去掉！因为这样，你不太可能让别人看你的代码（例如：

Y

是否应该触发所有

for

循环的

中断

？如果是这样的问题：忘记

字母表

，在范围（3）循环中为i写一个

，看看你是否可以中断）。顺便说一下：
浮点（输入（“下一个顺序项的系数是什么：”））=='0'
将永远不会为
True
：您正在将
str
与
float
进行比较。在for循环结束时，使用字母=字母[int（i+1）]选择下一个字母###从a到b再到c…，但实际上不改变I的存储值，所以每次都是一样的。如果你把I+=1加起来会有帮助吗？把一个函数的输入看作是另一个函数的输出，对像我这样的初学者来说真的很有帮助