Question

我有一个矩阵，其单元格值仅为0或1。

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

例如，值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循环遍历同一行并计数所有1（具有相同值的单元格）。

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

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

Answer 1

您可以为行和列创建一个列表，并只需一次一次遍历矩阵，同时添加正确的部分：

创建演示数据：

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压缩的开销仍然值得，因为zip（）方式在继承上得到了优化，然后遍历了列表。权衡可能仅在某些矩阵大小的情况下值得/最多/…

Answer 2

您尚未指定矩阵的数据类型是什么。如果是列表列表，则无法“仅获得一列”，但是代码仍然相似（假设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 3

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

$(document).ready(function(){
  $('img').hover(function(){
    var current = $(this).attr("src");
    var swap = $(this).attr("data-alt-src");
    $(this).attr("src",swap);
    $(this).attr("data-alt-src",current);
  }, function(){
    var current = $(this).attr("src");
    var swap = $(this).attr("data-alt-src");
    $(this).attr("data-alt-src",current);
    $(this).attr("src",swap);
  });
})

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中的矩阵列中进行迭代

5 个答案:

创建演示数据：

计数：