如何遍历 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

您没有指定矩阵的数据类型。如果是列表的列表，那就没办法"get just one column"了，但是代码还是类似的（假设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

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

# 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 3

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

创建演示数据：

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

如何遍历 python 中的矩阵列

How to iterate through a matrix column in python

python

loops

matrix

cycle

创建演示数据：

数数：