在Python中的列表列表中获取所有对角线

我正在寻找一种Python的方式来获取(正方形)矩阵的所有对角线，以列表的形式表示。

假设我有以下矩阵：

matrix = [[-2, 5, 3, 2],

[ 9, -6, 5, 1],

[ 3, 2, 7, 3],

[-1, 8, -4, 8]]

然后，大对角线很容易：

l = len(matrix[0])

print [matrix[i][i] for i in range(l)] # [-2, -6, 7, 8]

print [matrix[l-1-i][i] for i in range(l-1,-1,-1)] # [ 2, 5, 2, -1]

但是我很难想出一种生成所有对角线的方法。 我正在寻找的输出是：

[[-2], [9, 5], [3,-6, 3], [-1, 2, 5, 2], [8, 7, 1], [-4, 3], [8],

[2], [3,1], [5, 5, 3], [-2, -6, 7, 8], [9, 2, -4], [3, 8], [-1]]

7个解决方案

50 votes

在numpy中可能有比下面更好的方法，但是我对它还不太熟悉：

import numpy as np

matrix = np.array(

[[-2, 5, 3, 2],

[ 9, -6, 5, 1],

[ 3, 2, 7, 3],

[-1, 8, -4, 8]])

diags = [matrix[::-1,:].diagonal(i) for i in range(-3,4)]

diags.extend(matrix.diagonal(i) for i in range(3,-4,-1))

print [n.tolist() for n in diags]

输出量

[[-2], [9, 5], [3, -6, 3], [-1, 2, 5, 2], [8, 7, 1], [-4, 3], [8], [2], [3, 1], [5, 5, 3], [-2, -6, 7, 8], [9, 2, -4], [3, 8], [-1]]

编辑：更新以针对任何矩阵大小进行概括。

import numpy as np

# Alter dimensions as needed

x,y = 3,4

# create a default array of specified dimensions

a = np.arange(x*y).reshape(x,y)

print a

print

# a.diagonal returns the top-left-to-lower-right diagonal "i"

# according to this diagram:

#

# 0 1 2 3 4 ...

# -1 0 1 2 3

# -2 -1 0 1 2

# -3 -2 -1 0 1

# :

#

# You wanted lower-left-to-upper-right and upper-left-to-lower-right diagonals.

#

# The syntax a[slice,slice] returns a new array with elements from the sliced ranges,

# where "slice" is Python's [start[:stop[:step]] format.

# "::-1" returns the rows in reverse. ":" returns the columns as is,

# effectively vertically mirroring the original array so the wanted diagonals are

# lower-right-to-uppper-left.

#

# Then a list comprehension is used to collect all the diagonals. The range

# is -x+1 to y (exclusive of y), so for a matrix like the example above

# (x,y) = (4,5) = -3 to 4.

diags = [a[::-1,:].diagonal(i) for i in range(-a.shape[0]+1,a.shape[1])]

# Now back to the original array to get the upper-left-to-lower-right diagonals,

# starting from the right, so the range needed for shape (x,y) was y-1 to -x+1 descending.

diags.extend(a.diagonal(i) for i in range(a.shape[1]-1,-a.shape[0],-1))

# Another list comp to convert back to Python lists from numpy arrays,

# so it prints what you requested.

print [n.tolist() for n in diags]

输出量

[[ 0 1 2 3]

[ 4 5 6 7]

[ 8 9 10 11]]

[[0], [4, 1], [8, 5, 2], [9, 6, 3], [10, 7], [11], [3], [2, 7], [1, 6, 11], [0, 5, 10], [4, 9], [8]]

Mark Tolonen answered 2020-07-20T11:42:21Z

18 votes

从对角线倾斜的右上角开始。

如果(x，y)是矩阵内部的直角坐标，则要转换为坐标系(p，q)或从其中转换，其中p是对角线的数量，q是沿对角线的索引。 (因此，p = 0是[-2]对角线，p = 1是[9,5]对角线，p = 2是[3，-6,3]对角线，依此类推。)

要将(p，q)转换为(x，y)，可以使用：

x = q

y = p - q

尝试插入p和q的值以查看其工作原理。

现在，您只需循环...对于p从0到2N-1，q从max(0，p-N + 1)到min(p，N-1)。 将p，q转换为x，y并打印。

然后对于其他对角线，重复循环，但使用不同的变换：

x = N - 1 - q

y = p - q

(这实际上只是左右翻转矩阵。)

抱歉，我实际上没有在Python中编写代码。 :-)

Nemo answered 2020-07-20T11:43:12Z

10 votes

这是给Moe的，他问了类似的问题。

我首先通过简单的功能来复制任何矩形矩阵的行或列。

def get_rows(grid):

return [[c for c in r] for r in grid]

def get_cols(grid):

return zip(*grid)

然后使用这两个函数，通过在每行的开始/结尾添加一个增加/减少缓冲区来得到对角线。 然后，我获得了此缓冲网格的列，然后再删除每列上的缓冲区。 即

1 2 3 |X|X|1|2|3| | | |1|2|3|

4 5 6 => |X|4|5|6|X| => | |4|5|6| | => [[7],[4,8],[1,5,9],[2,6],[3]]

7 8 9 |7|8|9|X|X| |7|8|9| | |

.

def get_backward_diagonals(grid):

b = [None] * (len(grid) - 1)

grid = [b[i:] + r + b[:i] for i, r in enumerate(get_rows(grid))]

return [[c for c in r if c is not None] for r in get_cols(grid)]

def get_forward_diagonals(grid):

b = [None] * (len(grid) - 1)

grid = [b[:i] + r + b[i:] for i, r in enumerate(get_rows(grid))]

return [[c for c in r if c is not None] for r in get_cols(grid)]

flakes answered 2020-07-20T11:43:46Z

7 votes

我遇到了另一个有趣的解决方案。通过查看x和y的组合，可以立即发现行，列，向前和向后的对角线。

Column = x Row = y F-Diag = x+y B-Diag = x-y B-Diag` = x-y-MIN

| 0 1 2 | 0 1 2 | 0 1 2 | 0 1 2 | 0 1 2

--|--------- --|--------- --|--------- --|--------- --|---------

0 | 0 1 2 0 | 0 0 0 0 | 0 1 2 0 | 0 1 2 0 | 2 3 4

1 | 0 1 2 1 | 1 1 1 1 | 1 2 3 1 |-1 0 1 1 | 1 2 3

2 | 0 1 2 2 | 2 2 2 2 | 2 3 4 2 |-2 -1 0 2 | 0 1 2

从图中可以看到，使用这些方程式，每个对角线和轴都是唯一可识别的。 从每个表中获取每个唯一编号，然后为该标识符创建一个容器。

请注意，向后对角线已从零索引处开始偏移，并且向前对角线的长度始终等于向后对角线的长度。

test = [[1,2,3],[4,5,6],[7,8,9],[10,11,12]]

max_col = len(test[0])

max_row = len(test)

cols = [[] for _ in range(max_col)]

rows = [[] for _ in range(max_row)]

fdiag = [[] for _ in range(max_row + max_col - 1)]

bdiag = [[] for _ in range(len(fdiag))]

min_bdiag = -max_row + 1

for x in range(max_col):

for y in range(max_row):

cols[x].append(test[y][x])

rows[y].append(test[y][x])

fdiag[x+y].append(test[y][x])

bdiag[x-y-min_bdiag].append(test[y][x])

print(cols)

print(rows)

print(fdiag)

print(bdiag)

哪个会打印

[[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12]]

[[1, 4, 7, 10], [2, 5, 8, 11], [3, 6, 9, 12]]

[[1], [2, 4], [3, 5, 7], [6, 8, 10], [9, 11], [12]]

[[10], [7, 11], [4, 8, 12], [1, 5, 9], [2, 6], [3]]

flakes answered 2020-07-20T11:44:19Z

4 votes

我最近终于重新发明了这个轮子。 这是一种易于使用/扩展的方法，用于在方形列表列表中查找对角线：

def get_diagonals(grid, bltr = True):

dim = len(grid)

assert dim == len(grid[0])

return_grid = [[] for total in xrange(2 * len(grid) - 1)]

for row in xrange(len(grid)):

for col in xrange(len(grid[row])):

if bltr: return_grid[row + col].append(grid[col][row])

else: return_grid[col - row + (dim - 1)].append(grid[row][col])

return return_grid

假设列表索引：

00 01 02 03

10 11 12 13

20 21 22 23

30 31 32 33

然后设置bltr = False(默认值)，则返回从左下角到右上角的对角线，即

00 # row + col == 0

10 01 # row + col == 1

20 11 02 # row + col == 2

30 21 12 03 # row + col == 3

31 22 13 # row + col == 4

32 23 # row + col == 5

33 # row + col == 6

设置bltr = False，则返回从左下角到右上角的对角线，即

30 # (col - row) == -3

20 31 # (col - row) == -2

10 21 32 # (col - row) == -1

00 11 22 33 # (col - row) == 0

01 12 23 # (col - row) == +1

02 13 # (col - row) == +2

03 # (col - row) == +3

这是使用OP输入矩阵的可运行版本。

Jedi answered 2020-07-20T11:45:14Z

1 votes

这仅适用于宽度和高度相等的矩阵。但是它也不依赖任何第三方。

matrix = [[11, 2, 4],[4, 5, 6],[10, 8, -12]]

# only works for diagnoals of equal width and height

def forward_diagonal(matrix):

if not isinstance(matrix, list):

raise TypeError("Must be of type list")

results = []

x = 0

for k, row in enumerate(matrix):

# next diag is (x + 1, y + 1)

for i, elm in enumerate(row):

if i == 0 and k == 0:

results.append(elm)

break

if (x + 1 == i):

results.append(elm)

x = i

break

return results

print 'forward diagnoals', forward_diagonal(matrix)

willredington315 answered 2020-07-20T11:45:33Z

-1 votes

基于上述Nemo答案的代码：

def print_diagonals(matrix):

n = len(matrix)

diagonals_1 = [] # lower-left-to-upper-right diagonals

diagonals_2 = [] # upper-left-to-lower-right diagonals

for p in range(2*n-1):

diagonals_1.append([matrix[p-q][q] for q in range(max(0, p - n + 1), min(p, n - 1) + 1)])

diagonals_2.append([matrix[n-p+q-1][q] for q in range(max(0, p - n + 1), min(p, n - 1) + 1)])

print("lower-left-to-upper-right diagonals: ", diagonals_1)

print("upper-left-to-lower-right diagonals: ", diagonals_2)

print_diagonals([

[1, 2, 1, 1],

[1, 1, 4, 1],

[1, 3, 1, 6],

[1, 7, 2, 5],

])

lower-left-to-upper-right diagonals: [[1], [1, 2], [1, 1, 1], [1, 3, 4, 1], [7, 1, 1], [2, 6], [5]]

upper-left-to-lower-right diagonals: [[1], [1, 7], [1, 3, 2], [1, 1, 1, 5], [2, 4, 6], [1, 1], [1]]

Martin answered 2020-07-20T11:45:54Z

1．编写程序，把下面的数据输入到一个二维数组中： 25 36 78 13 12 26 8我自己编的，用VISUAL C++6.0 测试过了 #include"stdio.h" void Print(int a[4][4]) { int i,j; for(i=0;i

输入4行4列的二维数组,CSS布局HTML小编今天和大家分享计算主对角线各元素之和,2 3 5 8 1 0 1 2 4 5 7 6 1 0 2 3 i=0 to 3 j=0 to 3 if(i==j) sum=su#include int main(void) { int a[4][4]={1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16}; int i,j,sum1,sum2;//定义sum1,sum2,分别存放两条对线元素的和； sum1=sum2=0; for(i=0;i

C语言编程题：定义一个5╳5的矩阵，CSS布局HTML小编今天和大家分享对角线上的元要CSS布局HTML小编今天和大家分享：1)5╳5的矩阵是一个整型二维数组。 2)对角线上交叉的元素只加一次。

#include #include #include void main() { int a[4][4],i,j,s1=0,s2=0,sum=0; srand(time(NULL));//生成随机种子 for(i=0;i

CSS布局HTML小编今天和大家分享一个5行5列的整型二维数组对角线元素之和(数组#include int main() { int i,j,sum=0; int arr[5][5]; printf("请输入数组元素的值:\n"); for(i=0;i

CSS布局HTML小编今天和大家分享二维数组对角线之和的C++程序。

用C++编一个程序，要CSS布局HTML小编今天和大家分享输入一个4*4矩阵对角线之和，并CSS布局HTML小编今天和大家分享其最大最小值，简述思路吧 定义一个存放最大值的变量max 定义一个存放最小值的变量Min 定义一个存放对角线之和变量sum 遍历二维数组所有元素 for(i=0;i

c语言 二维数组 对角线相加

通过java语言编程实现输出二维数组主对角线上的最大值

import java.util.Scanner;public class max { public static void main(String[] args) { Scanner stdIn = new Scanner(System.in); int rows, cols; // 行数与列数 System.out.print("Enter number of rows" + " for the matrix: "); rows = s

输出二维数组主对角线上元素中， if(i == j) prin很简单，就是在主对角线的下标都相等的时候，肯定就是主对角线上的元素了，判断对了，就输出来了啊，。

c语言中如何输出二维数组a[5][5]的对角线元素

/* * Date: 2015/12/18 */#include #include int main(int argc, char *argv[]){ int a[5][5] = { {1, 2, 3, 4, 5}, {6, 7, 8, 9, 10}, {11,12,13,14,15}, {16,17,18,19,20}, {21,22,23,24,25} }; int i; for ( i = 0; i < 5; i++ ) { printf("%

大家好，我是时间财富网智能客服时间君，上述问题将由我为大家进行解答。

以Excel为例，表格里对角线的插入步骤是：

1、首先打开Excel文档，将需要调整的表格稍微拉大一点。

2、然后单击鼠标右键，在弹出的下拉菜单中选择设置单元格格式。

3、切换到边框选项卡，单击斜线选项。

4、然后确定即可。

Microsoft Excel是Microsoft为使用Windows和Apple Macintosh操作系统的电脑编写的一款电子表格软件。直观的界面、出色的计算功能和图表工具，再加上成功的市场营销，使Excel成为最流行的个人计算机数据处理软件。在1993年，作为Microsoft Office的组件发布了5.0版之后，Excel就开始成为所适用操作平台上的电子制表软件的霸主。Office最初是一个推广名称，出现于1990年代早期，指一些以前曾单独发售的软件的合集。当时主要的推广重点是：购买合集比单独购买要省很多钱。最初的Office版本包含Word、Excel和PowerPoint。