如何遍历python中的矩阵列

Question

我有一个只有0 或1 的单元格值的矩阵。

我想计算给定单元格的同一行或同一列中有多少个 1 或 0。

例如matrix[r][c]的值是1，所以我想知道同一行有多少个。这段代码就是这样做的：

count_in_row = 0
value = matrix[r][c]
for i in matrix[r]:
    if i == value:
        count_in_row += 1

for 循环遍历同一行并计算所有行（具有相同值的单元格）。

如果我想对列执行相同的过程怎么办？我会遍历整个矩阵还是只遍历一列？

PS：我不想用numpy、transpose或zip；复合循环效果更好。

Answer 1

您尚未指定矩阵的数据类型。如果是列表的列表，那么就没有办法“只得到一列”，但是代码还是差不多的（假设r和c的类型是int）：

我添加了仅计算与相关单元格相邻的单元格的功能（上方、下方、左侧和右侧；不考虑对角线）；这是通过检查索引之间的差异不大于 1 来完成的。

count_in_row = 0
count_in_col = 0
value = matrix[r][c]

for j in range(len(matrix[r])):
    if abs(j - c) <= 1:             # only if it is adjacent
        if matrix[r][j] == value:
            count_in_row += 1
for i in range(len(matrix)):
    if abs(i - r) <= 1:             # only if it is adjacent
        if matrix[i][c] == value:
            count_in_col += 1

或者如果按照您开始的方式（整行和整列，而不仅仅是相邻的）：

for col_val in matrix[r]:
    if col_val == value:
        count_in_row += 1
for row in matrix:
    if row[c] == value:
        count_in_col += 1

---

如果您要对很多单元进行此操作，那么有更好的方法可以做到这一点（即使没有numpy，但numpy 绝对是一个非常好的选择）。

Answer 2

您可以为行和列创建一个列表，然后简单地迭代您的矩阵一次，同时将正确的部分相加：

创建演示数据：

import random

random.seed(42)

matrix = []
for n in range(10):
    matrix.append(random.choices([0,1],k=10))

print(*matrix,sep="\n")

输出：

[1, 0, 0, 0, 1, 1, 1, 0, 0, 0]
[0, 1, 0, 0, 1, 1, 0, 1, 1, 0]
[1, 1, 0, 0, 1, 0, 0, 0, 1, 1]
[1, 1, 1, 1, 0, 1, 1, 1, 1, 1]
[1, 0, 0, 0, 0, 0, 0, 0, 1, 0]
[0, 0, 0, 1, 1, 1, 0, 1, 0, 0]
[1, 1, 1, 1, 1, 1, 0, 0, 0, 0]
[0, 1, 1, 0, 1, 0, 1, 0, 0, 0]
[1, 0, 1, 1, 0, 0, 1, 1, 0, 0]
[0, 1, 1, 0, 0, 0, 1, 1, 1, 1]

数数：

rows =  []                   # empty list for rows - you can simply sum over each row
cols =  [0]*len(matrix[0])   # list of 0 that you can increment while iterating your matrix

for row in matrix:
    for c,col in enumerate(row):  # enumerate gives you the (index,value) tuple
        rows.append( sum(x for x in row) )    # simply sum over row
        cols[c] += col                        # adds either 0 or 1 to the col-index           

print("rows:",rows)
print("cols:",cols)

输出：

rows: [4, 5, 5, 9, 2, 4, 6, 4, 5, 6] # row 0 == 4, row 1 == 5, ...
cols: [6, 6, 5, 4, 6, 5, 5, 5, 5, 3] # same for cols

---

代码更少，但使用 zip() 对矩阵进行 2 次完整传递以转置数据：

rows =  [sum(r) for r in matrix]
cols =  [sum(c) for c in zip(*matrix)]

print("rows:",rows)
print("cols:",cols)

输出：（相同）

rows: [4, 5, 5, 9, 2, 4, 6, 4, 5, 6]  
cols: [6, 6, 5, 4, 6, 5, 5, 5, 5, 3]  

您将不得不计时，但两次完整迭代和压缩的开销可能仍然值得，因为 zip() 方式在继承上比在列表上循环更优化。权衡可能只值得/最多/从某些矩阵大小......

Answer 3

我不会为你解决这个问题，但也许会提示正确的方向......

# assuming a list of lists of equal length
# without importing any modules

matrix = [
    [1, 0, 0, 0],
    [1, 1, 0, 0],
    [1, 1, 1, 0],
    [1, 1, 1, 1],
]

sum_rows = [sum(row) for row in matrix]
print(sum_rows)  # [1, 2, 3, 4]

sum_columns = [sum(row[i] for row in matrix) for i in range(len(matrix[0]))]
print(sum_columns)  # [4, 3, 2, 1]

Answer 4

这是一个只有一个 for 循环的解决方案：

count_in_row = 0
count_in_column = 0
value = matrix[r][c]

for index, row in enumerate(matrix):
  if index == r:
    count_in_row = row.count(value)
  if row[c] == value:
    count_in_column += 1

print(count_in_row, count_in_column)

Answer 5

使用 numpy，它是 1 个命令（每个方向），而且速度更快

import numpy as np

A = np.array([[1, 0, 0, 0, 1, 1, 1, 0, 0, 0],
    [0, 1, 0, 0, 1, 1, 0, 1, 1, 0],
    [1, 1, 0, 0, 1, 0, 0, 0, 1, 1],
    [1, 1, 1, 1, 0, 1, 1, 1, 1, 1],
    [1, 0, 0, 0, 0, 0, 0, 0, 1, 0],
    [0, 0, 0, 1, 1, 1, 0, 1, 0, 0],
    [1, 1, 1, 1, 1, 1, 0, 0, 0, 0],
    [0, 1, 1, 0, 1, 0, 1, 0, 0, 0],
    [1, 0, 1, 1, 0, 0, 1, 1, 0, 0],
    [0, 1, 1, 0, 0, 0, 1, 1, 1, 1]])

rowsum = A.sum(axis=1)
colsum = A.sum(axis=0)

print("A ="); print(A);print()
print("rowsum:",rowsum)
print("colsum:",colsum)


rowsum: [4 5 5 9 2 4 6 4 5 6]
colsum: [6 6 5 4 6 5 5 5 5 3]