替代大型“ if-else”树算法？

Question

在这里是全新的，并且对于编程来说是相当新的。 我用Python编写了一个程序，该程序可以汇总或“压缩”化学和物理学中常见的大型UV-Vis吸光度数据集。 我试图通过使各节更加“ Pythonic”来为程序添加最后的修饰。 以下代码段就是这样的示例之一。

while j < (N):
    j=j+1
    B=A[1+(10*j)+R][1:k] #Extraction expression.
    C=[float(i) for i in B] #Float conversion.
    D[0].append(C[0]),D[1].append(C[1]),D[2].append(C[2])
    if NC >= 4:
        D[3].append(C[3])
        if NC >= 5:
            D[4].append(C[4])
            if NC >= 6:
                D[5].append(C[5])
                if NC >= 7:
                    D[6].append(C[6])
                    if NC >= 8:
                        D[7].append(C[7])
                        if NC >= 9:
                            D[8].append(C[8])
                            if NC >= 10:
                                D[9].append(C[9])
                                if NC >= 11:
                                    D[10].append(C[10])
                                    if NC == 12:
                                        D[11].append(C[11])

C是一个嵌套列表。 我正在尝试附加包含在C内部列表中的特定于索引的元素。

即C = [[A1，B1，C1]，[A2，B2，C2]，[A3，B3，C3]，...]-> [A1，A2，A3，... An]，[B1 ，B2，B3，... Bn]，...

问题在于，如果NC等于某个索引N，则嵌套列表的索引具有相同的索引，并且每个NC值的追加算法都不同。

上面的代码段非常适合我的目的，但是随着程序的发展，长度和重复代码长期不可行。

有人可以指出我正确的方向吗？

干杯

Answer 1

首先请注意，没有必要嵌套它们。 如果NC >= x ，您也知道它也将是>= x - 1 。 这意味着您可以“展平”您的树，如下所示：

while j < (N):
    j=j+1
    B=A[1+(10*j)+R][1:k] #Extraction expression.
    C=[float(i) for i in B] #Float conversion.
    D[0].append(C[0]),D[1].append(C[1]),D[2].append(C[2])
    if NC >= 4:
        D[3].append(C[3])
    if NC >= 5:
        D[4].append(C[4])
    if NC >= 6:
        D[5].append(C[5])
    if NC >= 7:
        D[6].append(C[6])
    if NC >= 8:
        D[7].append(C[7])
    if NC >= 9:
        D[8].append(C[8])
    if NC >= 10:
        D[9].append(C[9])
    if NC >= 11:
        D[10].append(C[10])
    if NC == 12:
        D[11].append(C[11])

现在，在任何情况下，只要您一遍又一遍地使用略有不同的值重复做同一件事，就可以使用循环：

while j < (N):
    j=j+1
    B=A[1+(10*j)+R][1:k] #Extraction expression.
    C=[float(i) for i in B] #Float conversion.
    D[0].append(C[0]),D[1].append(C[1]),D[2].append(C[2])
    for i in range(4, 12):
        if NC >= i:
            D[i - 1].append(C[i - 1])
    if NC == 12:
        D[11].append(C[11])

编辑：我知道您提到这是为您的目的，但要知道当NC > 12时会发生什么情况。 这意味着您将追加所有内容，但不包括 D[11] 。 如果那是您想要的，那么您就是金。 但是，如果最后的比较确实应该是>=而不是== ，那么您当然可以将程序编写为

    for i in range(4, 13):
        if NC >= i:
            D[i - 1].append(C[i - 1])

如果最后没有if NC == 12 ，则没有该额外项。

Answer 2

首先，在每次迭代中，您都将值附加到D的范围内。 您可以仅循环正确的数量，而不必将范围硬编码为if语句的阶梯。 那是xrange(max(3, min(12, NC)))但如果您可以假设NC <= 12则可以进一步简化为xrange(max(3, NC)) 。

其次，您需要做很多工作才能将A转换为B然后转换为C ，但是每个值只使用一次。 相反，您可以将计算结果折叠到使用该值的位置。

第三，您无需初始化j ，但假设它从0开始，则while j < N循环可以简化为for循环。

放在一起：

for j in xrange(1, N+1):
    for i in xrange(max(3, min(12, NC))):
        D[i].append(float(A[2 + 10*j + R])

[注意：未经测试，因此可能存在持续存在的一一错误]。

Answer 3

而不是使用嵌套的if函数，而是使用while循环并在值> = 4时每转减小NC值：

import math
NC_floor = int(math.floor(NC))

while NC_floor >= 4:
    NC_floor -= 1
    D[NC_floor].append(NC_floor)