2022年 11月 5日

如何在Python中定义二维数组

我想定义一个没有初始化长度的二维数组，如下所示： 

Matrix = [][]

但这不起作用…

我已经尝试过下面的代码，但是它也是错误的： 

Matrix = [5][5]

错误： 

  1. Traceback ...
  2.  
  3. IndexError: list index out of range

我怎么了

#1楼

我读了这样的逗号分隔文件： 

  1. data=[]
  2. for l in infile:
  3.     l = split(',')
  4.     data.append(l)

然后，列表“数据”是带有索引数据的列表的列表[行] [列]

#2楼

声明零（一）矩阵： 

numpy.zeros((x, y))

例如 

  1. >>> numpy.zeros((3, 5))
  2.     array([[ 0.,  0.,  0.,  0.,  0.],
  3.    [ 0.,  0.,  0.,  0.,  0.],
  4.    [ 0.,  0.,  0.,  0.,  0.]])

或numpy.ones（（x，y））例如 

  1. >>> np.ones((3, 5))
  2. array([[ 1.,  1.,  1.,  1.,  1.],
  3.    [ 1.,  1.,  1.,  1.,  1.],
  4.    [ 1.,  1.,  1.,  1.,  1.]])

甚至三个尺寸都是可能的。 （ http://www.astro.ufl.edu/~warner/prog/python.html参见->多维数组）

#3楼

  1. # Creates a list containing 5 lists initialized to 0
  2. Matrix = [[0]*5]*5

请注意此简短表达，请参见@FJ答案中的完整解释

#4楼

我正在使用我的第一个Python脚本，我对方矩阵示例有些困惑，因此希望以下示例可以帮助您节省一些时间： 

  1.  # Creates a 2 x 5 matrix
  2.  Matrix = [[0 for y in xrange(5)] for x in xrange(2)]

以便 

  1. Matrix[1][4] = 2 # Valid
  2. Matrix[4][1] = 3 # IndexError: list index out of range

#5楼

如果只需要一个二维容器来容纳某些元素，则可以方便地使用字典： 

Matrix = {}

然后，您可以执行以下操作： 

  1. Matrix[1,2] = 15
  2. print Matrix[1,2]

这是可行的，因为1,2是一个元组，并且您将其用作索引字典的键。 结果类似于哑的稀疏矩阵。

如osa和Josap Valls所指出的，您也可以使用Matrix = collections.defaultdict(lambda:0)以便丢失的元素的默认值为0 。

Vatsal进一步指出，该方法对于大型矩阵可能不是很有效，并且仅应在代码的非关键性能部分使用。

#6楼

采用： 

matrix = [[0]*5 for i in range(5)]

第一维的* 5起作用是因为在此级别上，数据是不可变的。

#7楼

采用： 

  1. import copy
  2.  
  3. def ndlist(*args, init=0):
  4.     dp = init
  5.     for x in reversed(args):
  6.         dp = [copy.deepcopy(dp) for _ in range(x)]
  7.     return dp
  8.  
  9. l = ndlist(1,2,3,4) # 4 dimensional list initialized with 0's
  10. l[0][1][2][3] = 1

我确实认为NumPy是要走的路。 如果您不想使用NumPy，则以上是一种通用方法。

#8楼

可接受的答案是正确且正确的，但是花了我一段时间才了解到我也可以使用它来创建一个完全空的数组。 

l =  [[] for _ in range(3)]

结果是 

[[], [], []]

#9楼

重写以便于阅读： 

  1. # 2D array/ matrix
  2.  
  3. # 5 rows, 5 cols
  4. rows_count = 5
  5. cols_count = 5
  6.  
  7. # create
  8. #     creation looks reverse
  9. #     create an array of "cols_count" cols, for each of the "rows_count" rows
  10. #        all elements are initialized to 0
  11. two_d_array = [[0 for j in range(cols_count)] for i in range(rows_count)]
  12.  
  13. # index is from 0 to 4
  14. #     for both rows & cols
  15. #     since 5 rows, 5 cols
  16.  
  17. # use
  18. two_d_array[0][0] = 1
  19. print two_d_array[0][0]  # prints 1   # 1st row, 1st col (top-left element of matrix)
  20.  
  21. two_d_array[1][0] = 2
  22. print two_d_array[1][0]  # prints 2   # 2nd row, 1st col
  23.  
  24. two_d_array[1][4] = 3
  25. print two_d_array[1][4]  # prints 3   # 2nd row, last col
  26.  
  27. two_d_array[4][4] = 4
  28. print two_d_array[4][4]  # prints 4   # last row, last col (right, bottom element of matrix)

#10楼

如果您希望能够将其视为2D数组，而不是被迫以列表列表的方式思考（我认为这自然得多），则可以执行以下操作： 

  1. import numpy
  2. Nx=3; Ny=4
  3. my2Dlist= numpy.zeros((Nx,Ny)).tolist()

结果是一个列表（不是NumPy数组），您可以用数字，字符串或其他内容覆盖各个位置。

#11楼

这就是字典的用途！ 

matrix = {}

您可以通过两种方式定义键和值 ： 

matrix[0,0] = value

要么 

matrix = { (0,0)  : value }

结果： 

  1.    [ value,  value,  value,  value,  value],
  2.    [ value,  value,  value,  value,  value],
  3.    ...

#12楼

如果在开始之前没有尺寸信息，请创建两个一维列表。 

  1. list 1: To store rows
  2. list 2: Actual two-dimensional matrix

将整个行存储在第一个列表中。 完成后，将列表1附加到列表2： 

  1. from random import randint
  2.  
  3. coordinates=[]
  4. temp=[]
  5. points=int(raw_input("Enter No Of Coordinates >"))
  6. for i in range(0,points):
  7.     randomx=randint(0,1000)
  8.     randomy=randint(0,1000)
  9.     temp=[]
  10.     temp.append(randomx)
  11.     temp.append(randomy)
  12.     coordinates.append(temp)
  13.  
  14. print coordinates

输出： 

  1. Enter No Of Coordinates >4
  2. [[522, 96], [378, 276], [349, 741], [238, 439]]

#13楼

使用NumPy，您可以像这样初始化空矩阵： 

  1. import numpy as np
  2. mm = np.matrix([])

然后像这样追加数据： 

mm = np.append(mm, [[1,2]], axis=1)

#14楼

通过使用列表： 

matrix_in_python  = [['Roy',80,75,85,90,95],['John',75,80,75,85,100],['Dave',80,80,80,90,95]]

通过使用dict：您还可以将此信息存储在哈希表中，以进行快速搜索，例如 

matrix = { '1':[0,0] , '2':[0,1],'3':[0,2],'4' : [1,0],'5':[1,1],'6':[1,2],'7':[2,0],'8':[2,1],'9':[2,2]};

matrix [‘1’]将为您提供O（1）时间的结果

* nb ：您需要处理哈希表中的冲突

#15楼

这就是我通常在python中创建2D数组的方式。 

  1. col = 3
  2. row = 4
  3. array = [[0] * col for _ in range(row)]

与在列表理解中使用两个for循环相比，我发现此语法易于记住。

#16楼

  1. rows = int(input())
  2. cols = int(input())
  3.  
  4. matrix = []
  5. for i in range(rows):
  6.   row = []
  7.   for j in range(cols):
  8.     row.append(0)
  9.   matrix.append(row)
  10.  
  11. print(matrix)

为什么要用这么长的代码，而您在Python也这样问？

很久以前，当我不熟悉Python时，我看到了编写2D矩阵的单行答案，并告诉自己我不会再在Python中使用2D矩阵。 （这些行很吓人，它没有给我有关Python所做的任何信息。还要注意，我不知道这些速记法。）

无论如何，这是一个来自C，CPP和Java背景的初学者的代码

给Python爱好者和专家的说明：请不要因为我编写了详细的代码而投了反对票。

#17楼

l=[[0]*(L) for _ in range(W)]

将比： 

l = [[0 for x in range(L)] for y in range(W)]

#18楼

尝试这个： 

  1. rows = int(input('Enter rows\n'))
  2. my_list = []
  3. for i in range(rows):
  4.     my_list.append(list(map(int, input().split())))

#19楼

如果您需要带有预定义数字的矩阵，则可以使用以下代码： 

  1. def matrix(rows, cols, start=0):
  2.     return [[c + start + r * cols for c in range(cols)] for r in range(rows)]
  3.  
  4.  
  5. assert matrix(2, 3, 1) == [[1, 2, 3], [4, 5, 6]]

#20楼

您可以通过将两个或多个方括号或第三个方括号（ [] ，以逗号分隔）嵌套在方括号中来创建一个空的二维列表，如下所示： 

Matrix = [[], []]

现在假设您要将1附加到Matrix[0][0]然后键入： 

Matrix[0].append(1)

现在，键入Matrix并按Enter。 输出将是： 

[[1], []]

#21楼

从技术上讲，您正在尝试索引未初始化的数组。 您必须先使用列表初始化外部列表，然后再添加项目。 Python将其称为“列表理解”。 

  1. # Creates a list containing 5 lists, each of 8 items, all set to 0
  2. w, h = 8, 5;
  3. Matrix = [[0 for x in range(w)] for y in range(h)]

您现在可以将项目添加到列表中： 

  1. Matrix[0][0] = 1
  2. Matrix[6][0] = 3 # error! range... 
  3. Matrix[0][6] = 3 # valid

请注意，矩阵是“ y”地址主地址，换句话说，“ y索引”位于“ x索引”之前。 

  1. print Matrix[0][0] # prints 1
  2. x, y = 0, 6 
  3. print Matrix[x][y] # prints 3; be careful with indexing!

尽管您可以根据需要命名它们，但如果您对内部和外部列表都使用“ x”，并且希望使用非平方矩阵，那么我会以这种方式来避免因索引而引起的混淆。

#22楼

如果要创建一个空矩阵，则正确的语法是 

matrix = [[]]

如果您要生成大小为5的矩阵，并用0填充， 

matrix = [[0 for i in xrange(5)] for i in xrange(5)]

#23楼

您应该列出列表，最好的方法是使用嵌套的理解： 

  1. >>> matrix = [[0 for i in range(5)] for j in range(5)]
  2. >>> pprint.pprint(matrix)
  3. [[0, 0, 0, 0, 0],
  4.  [0, 0, 0, 0, 0],
  5.  [0, 0, 0, 0, 0],
  6.  [0, 0, 0, 0, 0],
  7.  [0, 0, 0, 0, 0]]

在您的[5][5]示例中，您正在创建一个内部带有整数“ 5”的列表，并尝试访问其第五项，这自然会引发IndexError，因为没有第五项： 

  1. >>> l = [5]
  2. >>> l[5]
  3. Traceback (most recent call last):
  4.   File "<stdin>", line 1, in <module>
  5. IndexError: list index out of range

#24楼

在Python中，您将创建一个列表列表。 您不必提前声明尺寸，但是可以声明。 例如： 

  1. matrix = []
  2. matrix.append([])
  3. matrix.append([])
  4. matrix[0].append(2)
  5. matrix[1].append(3)

现在，matrix [0] [0] == 2和matrix [1] [0] ==3。您还可以使用列表理解语法。 此示例两次使用它来构建“二维列表”： 

  1. from itertools import count, takewhile
  2. matrix = [[i for i in takewhile(lambda j: j < (k+1) * 10, count(k*10))] for k in range(10)]

#25楼

如果您真的想要一个矩阵，最好使用numpy 。 numpy矩阵运算最常使用具有二维的数组类型。 有很多方法可以创建一个新数组。 最有用的函数之一是zeros函数，该函数采用shape参数并返回给定形状的数组，并将值初始化为零： 

  1. >>> import numpy
  2. >>> numpy.zeros((5, 5))
  3. array([[ 0.,  0.,  0.,  0.,  0.],
  4.        [ 0.,  0.,  0.,  0.,  0.],
  5.        [ 0.,  0.,  0.,  0.,  0.],
  6.        [ 0.,  0.,  0.,  0.,  0.],
  7.        [ 0.,  0.,  0.,  0.,  0.]])

numpy还提供matrix类型。 它不太常用，有人建议不要使用它。 但这对于从Matlab或其他一些场合变得numpy人很有用。 我以为我会包括在内，因为我们在谈论矩阵！ 

  1. >>> numpy.matrix([[1, 2], [3, 4]])
  2. matrix([[1, 2],
  3.         [3, 4]])

这是创建二维数组和矩阵的其他一些方法（为了紧凑起见，删除了输出）： 

  1. numpy.matrix('1 2; 3 4')                 # use Matlab-style syntax
  2. numpy.arange(25).reshape((5, 5))         # create a 1-d range and reshape
  3. numpy.array(range(25)).reshape((5, 5))   # pass a Python range and reshape
  4. numpy.array([5] * 25).reshape((5, 5))    # pass a Python list and reshape
  5. numpy.empty((5, 5))                      # allocate, but don't initialize
  6. numpy.ones((5, 5))                       # initialize with ones
  7. numpy.ndarray((5, 5))                    # use the low-level constructor

#26楼

这是用于初始化列表列表的简短表示法： 

matrix = [[0]*5 for i in range(5)]

不幸的是，将其缩短为5*[5*[0]]并不会真正起作用，因为最终您会得到5个相同列表的副本，因此，当您修改其中一个副本时，它们都会改变，例如： 

  1. >>> matrix = 5*[5*[0]]
  2. >>> matrix
  3. [[0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0]]
  4. >>> matrix[4][4] = 2
  5. >>> matrix
  6. [[0, 0, 0, 0, 2], [0, 0, 0, 0, 2], [0, 0, 0, 0, 2], [0, 0, 0, 0, 2], [0, 0, 0, 0, 2]]