4

我是 Python 新手。所以我想用循环来完成这件事，而不需要使用像生成器这样的花哨的东西。我有两个二维数组，一个整数数组和另一个字符串数组，如下所示：

  1. 整数二维列表：

    这里，dataset2d[0][0] 是表中的行数，dataset[0][1] 是列数。所以下面的二维列表有 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]
]

  2. 字符串二维列表：

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

    partition[*][0]即第一列是一个标签。对于 A 组，1,2 和 4 是我需要从 dataset2d 中提取并应用公式的行号。所以这意味着我将读取 1，转到第 1 行dataset2d并读取第一列值 ie dataset2d[1][0]，然后我将从 读取 2 partition2d，转到数据集 2d 的第 2 行并读取第一列 ie dataset2d[2][0]。同样，我将阅读下一篇dataset2d[4][0]。

    然后我将进行一些计算，获取一个值并将其存储在一个二维列表中，然后转到 dataset2d 中的下一列以获取这些行。因此，在此示例中，读取的下一列值将是dataset2d[1][1], dataset2d[2][1], dataset2d[4][1]。再次进行一些计算并为该列获取一个值，然后存储它。我会这样做，直到到达dataset2d.

    中的下一行partition2d是[B, 3, 5]。所以我将从dataset2d[3][0],开始dataset2d[5][0]。获取该列的值是一个公式。然后 realdataset2d [3][1]等，dataset2d[5][1]直到我到达最后一列。我这样做直到 partition2d 中的所有行都被读取。

我尝试了什么：

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

我面临什么问题：

  1. partition2d 是一个字符串数组，我需要在其中跳过具有 A、B、C 等字符的第一列。
  2. 我只想在 partition2d 中给出的行号上迭代 dataset2d 列。所以 colDataset 应该只有在我完成该列之后才会增加。

更新1：

我正在从文本文件中读取内容，二维列表中的数据可能会有所不同，具体取决于文件内容和大小，但 file1 即 dataset2d 和 file2 即 partition2d 的结构将是相同的。

Update2：因为 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 列的结果，即考虑第 1、2、4 行的组 A 的 dataset2d[parttionCol][0]。

第二个数字 0.94322 是对 dataset2d 的第 1 列应用公式的结果，即考虑第 1,2 4 行的 A 组的 dataset2d[partitionCol][1]。

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

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

4

5 回答 5

3

你可以使用Numpy（我希望这对你来说不是很有趣）：

import numpy
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] ]
dataset2D_size = dataset2D[0]
dataset2D = numpy.array(dataset2D)
partition2D = [ ['A', '1', '2', '4'], ['B', '3', '5'], ['C', '6'] ]

for partition in partition2D:
    label = partition[0]

    row_indices = [int(i) for i in partition[1:]]

    # Take the specified rows
    rows = dataset2D[row_indices]

    # Iterate the columns (this is the power of Python!)
    for column in zip(*rows):
        # Now, column will contain one column of data from specified row indices
        print column, # Apply your formula here
    print

或者如果您不想安装 Numpy，您可以执行以下操作（实际上，这就是您想要的）：

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] ]
partition2D = [ ['A', '1', '2', '4'], ['B', '3', '5'], ['C', '6'] ]

dataset2D_size = dataset2D[0]

for partition in partition2D:
    label = partition[0]

    row_indices = [int(i) for i in partition[1:]]

    rows = [dataset2D[row_idx] for row_idx in row_indices]

    for column in zip(*rows):
        print column,
    print

两者都将打印：

(0, 1, 1) (0, 0, 1) (0, 2, 1) (1, 0, 0)
(2, 0) (2, 0) (0, 1) (1, 1)
(1,) (​​0,) (2,) (1,)

第二个代码的解释（没有 Numpy）：

[dataset2D[row_idx] for row_idx in row_indices]

这基本上是您获取每一行 ( dataset2D[row_idx]) 并将它们作为一个列表整理在一起。所以这个表达式的结果是一个列表列表（来自指定的行索引）

for column in zip(*rows):

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

然后在里面for column in zip(*rows):你已经有了来自指定行的你想要的按列迭代的元素！

要应用您的公式，只需将其更改print column,为您想做的事情。例如，我修改代码以包含行号和列号：

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)

这将导致：

处理分区 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
列数：2
[6,3]：2
列数：3
[6,3]：1

我希望这有帮助。

于 2013-09-19T08:49:34.543 回答
2

这是使用迭代器的可扩展解决方案：

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
于 2013-09-19T09:55:31.740 回答
1

partition2d 是一个字符串数组，我需要在其中跳过具有 A、B、C 等字符的第一列。

这称为切片：

 for partitionCol in partitionRow[1:]:

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

 for colDataset in dataset2d:

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

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

这是一种非常糟糕的做事方式。对于数组和矩阵，我建议你不要重新发明轮子（这也是 Pythonic 的东西），看看Numpy. 尤其是在： numpy.loadtxt

于 2013-09-19T08:44:23.853 回答
1

解决您的问题：

我面临什么问题：

  1. partition2d 是一个字符串数组，我需要在其中跳过具有 A、B、C 等字符的第一列。
  2. 我只想在 partition2d 中给出的行号上迭代 dataset2d 列。所以 colDataset 应该只有在我完成该列之后才会增加。

问题 1 可以使用切片解决 - 如果您想从第二个元素对 partition2d 进行迭代，则只有您可以进行某些操作for partitionCol in partitionRow[1:]。这将从第二个元素开始对行进行切片。

所以像：

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

问题 2 我不明白你想要什么:)

于 2013-09-19T08:44:38.543 回答
1

设置：

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
                #...
于 2013-09-19T08:47:30.363 回答