Python 迭代两个嵌套的2D列表，其中list2具有list1'；s行数

我是Python新手。所以我想用循环来完成这件事，而不用像发电机这样的花哨的东西。我有两个2D数组，一个是整数数组，另一个是字符串数组，如下所示：

整数2D列表：

partition2d = [
    ['A', '1', '2', '4'],
    ['B', '3', '5'],
    ['C', '6']
]

这里，dataset2d[0][0]是表中的行数，dataset[0][1]是列数。因此，下面的2D列表有6行4列

dataset2d = [
    [6, 4],
    [0, 0, 0, 1],
    [1, 0, 2, 0],
    [2, 2, 0, 1],
    [1, 1, 1, 0],
    [0, 0, 1, 1],
    [1, 0, 2, 1]
]

字符串2D列表：

partition2d = [
    ['A', '1', '2', '4'],
    ['B', '3', '5'],
    ['C', '6']
]

分区[*][0]

即第一列是标签。对于A组，1、2和4是我需要从dataset2d中提取并应用公式的行号。这意味着我将读取1，转到数据集2d中的第1行，读取第一列值，即数据集2d[1][0]，然后从分区2d中读取2，转到数据集2d的第2行，读取第一列值，即数据集2d[2][0]。类似地，下一篇我将阅读

dataset2d[4][0]

然后我将进行一些计算，获取一个值并将其存储在2D列表中，然后转到dataset2d中这些行的下一列。因此在本例中，读取的下一列值将是

dataset2d[1][1]

，

dataset2d[2][1]

，

dataset2d[4][1]

。再次进行一些计算，得到该列的一个值，并将其存储。我将一直这样做，直到到达

dataset2d

的最后一列

partition2d

中的下一行是

[B，3，5]

。因此，我将从

dataset2d[3][0]

，

dataset2d[5][0]

开始。获取该列的值，该值必须是公式。然后是real

dataset2d[3][1]

，

dataset2d[5][1]

等等，直到我到达最后一列。我这样做直到读取分区2D中的所有行

我尝试的是：

 for partitionRow in partition2d:
        for partitionCol in partitionRow:
                for colDataset in dataset2d:
                     print dataset2d[partitionCol][colDataset] 

我面临的问题是：

partition2d是一个字符串数组，我需要跳过第一列，它包含像a、B、C这样的字符

我只想在dataset2d中按列遍历partition2d中给定的行号。所以colDataset应该只在我处理完该列之后才递增

更新1：

我从文本文件中读取内容，2D列表中的数据可能会有所不同，这取决于文件内容和大小，但file1（即dataset2d）和file2（即partition2d）的结构是相同的

更新2：因为Eric询问了输出应该是什么样子

 0.842322 0.94322 0.34232 0.900009    (For A)
 0.642322 0.44322 0.24232 0.800009    (For B)

这只是一个例子，数字是我随机输入的。 因此，第一个数字0.842322是将公式应用于dataset2d第0列的结果，即A组的dataset2d[PartitionCol][0]考虑了第1、2、4行

第二个数字0.94322是将公式应用于dataset2d第1列的结果，即A组的dataset2d[partitionCol][1]考虑了第1、2和4行

第三个数字0.34232是将公式应用于dataset2d第2列的结果，即A组的dataset2d[partitionCol][2]考虑了第1、2和4行。同样，我们得到0.900009

第二行中的第一个数字，即0.642322，是将公式应用于B组的dataset2d第0列的结果，即dataset2d[PartitionCol][0]，考虑了第3,5行。等等

partition2d是一个字符串数组，我需要跳过第一列 它有像A，B，C这样的字符

这称为切片：

 for partitionCol in partitionRow[1:]:

上面的代码段将跳过第一列

 for colDataset in dataset2d:

已经做了你想做的。这里没有结构，就像C++循环一样。虽然你可以用一种非常不和谐的方式做一些事情：

 i=0
 for i in range(len(dataset2d)):
    print dataset2d[partitionCol][i]  
    i=+1

这是一种非常糟糕的方法。对于数组和矩阵，我建议你不要再发明轮子（这也是Pythonic的东西），看看

Numpy

。特别是：

---

要解决您的问题：

我面临的问题是：

partition2d是一个字符串数组，我需要 跳过包含A、B、C等字符的第一列

我想 在dataset2d中按列仅对中给出的行号进行迭代 分区2D。所以colDataset应该只在我完成之后才递增 和那个专栏

问题1可以通过切片来解决-如果您想在partition2d上从第二个元素开始迭代，那么只能在partitionRow[1://code>中为partitionCol迭代

。这将从第二个元素到最后对行进行切片

比如：

 for partitionRow in partition2d:
        for partitionCol in partitionRow[1:]:
                for colDataset in dataset2d:
                    print dataset2d[partitionCol][colDataset]

问题2我不明白您想要什么：）
设置：

d = [[6,4],[0,0,0,1],[1,0,2,0],[2,2,0,1],[1,1,1,0],[0,0,1,1],[1,0,2,1]]
s = [['A',1,2,4],['B',3,5],['C',6]]

结果被放入列表l中

l = []
for r in s: #go over each [character,index0,index1,...]
    new_r = [r[0]] #create a new list to values given by indexN. Add in the character by default
    for i,c in enumerate(r[1:]): #go over each indexN. Using enumerate to keep track of what N is. 
        new_r.append(d[c][i]) #i is now the N in indexN. c is the column.
    l.append(new_r) #add that new list to l

导致

>>> l
[['A', 0, 0, 1], ['B', 2, 0], ['C', 1]]

第一次迭代的执行情况如下所示：

for r in s:
    #-> r = ['A',1,2,4]

    new_r = [r[0]] #= ['A']

    for i,c in enumerate([r[1:] = [1,2,4])
            #-> i = 0, c = 1
                new_r.append(d[1][i])
            #-> i = 1, c = 2
                #...

您可以使用（我希望这不是您喜欢的）：

或者如果您不想安装Numpy，下面是您可以做的事情（实际上这就是您想要的）：

两者都将打印：

(0, 1, 1) (0, 0, 1) (0, 2, 1) (1, 0, 0)
(2, 0) (2, 0) (0, 1) (1, 1)
(1,) (0,) (2,) (1,)
这基本上是您获取每一行（
dataset2D[row\u idx]
），并将它们作为一个列表整理在一起。因此，这个表达式的结果是一个列表列表（来自指定的行索引）

然后
zip（*行）
将逐列迭代（您想要的）。这是通过获取每行的第一个元素，然后将它们组合在一起形成一个数组来实现的。在每次迭代中，结果存储在变量
列
中

然后在zip（*行）中的
列中：
您已经从指定行中获得了预期的按列迭代元素

要应用您的公式，只需将
打印列，
更改为您想要做的事情。例如，我修改代码以包括行和列编号：

print 'Processing partition %s' % label
for (col_num, column) in enumerate(zip(*rows)):
    print 'Column number: %d' % col_num
    for (row_num, element) in enumerate(column):
        print '[%d,%d]: %d' % (row_indices[row_num], col_num, element)

这将导致：

Processing partition A
Column number: 0
[1,0]: 0
[2,0]: 1
[4,0]: 1
Column number: 1
[1,1]: 0
[2,1]: 0
[4,1]: 1
Column number: 2
[1,2]: 0
[2,2]: 2
[4,2]: 1
Column number: 3
[1,3]: 1
[2,3]: 0
[4,3]: 0
Processing partition B
Column number: 0
[3,0]: 2
[5,0]: 0
Column number: 1
[3,1]: 2
[5,1]: 0
Column number: 2
[3,2]: 0
[5,2]: 1
Column number: 3
[3,3]: 1
[5,3]: 1
Processing partition C
Column number: 0
[6,0]: 1
Column number: 1
[6,1]: 0
Column number: 2
[6,3]: 2
Column number: 3
[6,3]: 1
处理分区A
列号：0
[1,0]: 0
[2,0]: 1
[4,0]: 1
列号：1
[1,1]: 0
[2,1]: 0
[4,1]: 1
列号：2
[1,2]: 0
[2,2]: 2
[4,2]: 1
列号：3
[1,3]: 1
[2,3]: 0
[4,3]: 0
处理分区B
列号：0
[3,0]: 2
[5,0]: 0
列号：1
[3,1]: 2
[5,1]: 0
列号：2
[3,2]: 0
[5,2]: 1
列号：3
[3,3]: 1
[5,3]: 1
处理分区C
列号：0
[6,0]: 1
列号：1
[6,1]: 0
列数
for column in zip(*rows):

print 'Processing partition %s' % label
for (col_num, column) in enumerate(zip(*rows)):
    print 'Column number: %d' % col_num
    for (row_num, element) in enumerate(column):
        print '[%d,%d]: %d' % (row_indices[row_num], col_num, element)

Processing partition A
Column number: 0
[1,0]: 0
[2,0]: 1
[4,0]: 1
Column number: 1
[1,1]: 0
[2,1]: 0
[4,1]: 1
Column number: 2
[1,2]: 0
[2,2]: 2
[4,2]: 1
Column number: 3
[1,3]: 1
[2,3]: 0
[4,3]: 0
Processing partition B
Column number: 0
[3,0]: 2
[5,0]: 0
Column number: 1
[3,1]: 2
[5,1]: 0
Column number: 2
[3,2]: 0
[5,2]: 1
Column number: 3
[3,3]: 1
[5,3]: 1
Processing partition C
Column number: 0
[6,0]: 1
Column number: 1
[6,1]: 0
Column number: 2
[6,3]: 2
Column number: 3
[6,3]: 1
def partitions(data, p):
    for partition in p:
        label = partition[0]
        row_indices = partition[1:]
        rows = [dataset2D[row_idx] for row_idx in row_indices]
        columns = zip(*rows)

        yield label, columns

for label, columns in partitions(dataset2D, partitions2d):
    print "Processing", label
    for column in columns:
        print column