Python “大型”的替代方案；如有其他",；树算法？

这里是全新的，对编程来说也是全新的。我用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])

而j<（N）：
j=j+1
B=A[1+（10*j）+R][1:k]#提取表达式。
C=[B中i的浮点（i）]#浮点转换。
D[0]。追加（C[0]），D[1]。追加（C[1]），D[2]。追加（C[2]）
如果NC>=4：
D[3]。追加（C[3]）
如果NC>=5：
D[4]。追加（C[4]）
如果NC>=6：
D[5]。追加（C[5]）
如果NC>=7：
D[6]。追加（C[6]）
如果NC>=8：
D[7]。追加（C[7]）
如果NC>=9：
D[8]。追加（C[8]）
如果NC>=10：
D[9]。追加（C[9]）
如果NC>=11：
D[10]。追加（C[10]）
如果NC==12：
D[11]。追加（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的每个值，追加算法都不同

上面的代码片段非常适合我的目的，但是随着程序的发展，代码的长度和重复性从长远来看是不可行的

有人能给我指出正确的方向吗

---

干杯

首先要注意的是，没有必要将它们嵌套；如果

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])

---

如果NC==12，则不需要额外的

。
首先注意，不需要嵌套它们；如果
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])

如果NC==12，则在结束时不使用额外的
。
不要使用嵌套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)

不要使用嵌套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)

首先，在每次迭代中，您都要将值附加到
D
的范围中。不必将范围硬编码为
if
语句的阶梯，只需循环正确的数量即可。这是
xrange（max（3，min（12，NC））
但是如果您可以假设
NC首先，在每次迭代中，您将在
D
的范围中附加值。不必将范围硬编码为
if
语句的阶梯，只需循环正确的数量即可。这是
xrange（最大值（3，最小值（12，NC））
但是如果你能假设
ncah是的，工作很好，我知道你做了什么。NC实际上不会穿过12，因为我们使用的分光光度计基本上可以读取12×8的微孔板。然而，你的编辑实际上让我意识到，有些微孔板的尺寸大于12×8。值得深思！很高兴我能帮忙！啊，是的，很完美，我知道你做了什么。NC实际上不会穿过12，因为我们使用的分光光度计基本上可以读取12×8的微孔板。然而，你的编辑实际上让我意识到，有些微孔板的尺寸大于12×8。值得深思！很高兴我能帮忙！
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])