如何遍歷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]