如何在Python中初始化二维数组？

row=5
col=5
[[x]*col for x in [b for b in range(row)]]

上面的代码将为您提供一个5x5的二维数组。

[[0, 0, 0, 0, 0],
 [1, 1, 1, 1, 1],
 [2, 2, 2, 2, 2],
 [3, 3, 3, 3, 3],
 [4, 4, 4, 4, 4]]

这是使用嵌套列表推导式。 具体如下：

[[x]*col for x in [b for b in range(row)]]

[x]*col --> 最终表达式的计算结果
for x in --> x 是迭代器提供的值
[b for b in range(row)]] --> 迭代器。

[b for b in range(row)]] 将计算为 [0,1,2,3,4]，因为 row=5
现在它简化为

[[x]*col for x in [0,1,2,3,4]]

这将被解释为

[[0]*5 for x in [0,1,2,3,4]] --> 在第一次迭代中，x=0

[[1]*5 for x in [0,1,2,3,4]] --> 在第二次迭代中，x=1

[[2]*5 for x in [0,1,2,3,4]] --> 在第三次迭代中，x=2

[[3]*5 for x in [0,1,2,3,4]] --> 在第四次迭代中，x=3

[[4]*5 for x in [0,1,2,3,4]] --> 在第五次迭代中，x=4

正如@Arnab和@Mike所指出的那样，数组不是列表。一些区别是1）数组在初始化期间大小固定2）数组通常支持比列表更少的操作。
也许在大多数情况下有点过度，但这里有一个基本的2D数组实现，利用了使用Python ctypes（C库）的硬件数组实现。

import ctypes
class Array:
    def __init__(self,size,foo): #foo is the initial value
        self._size = size
        ArrayType = ctypes.py_object * size
        self._array = ArrayType()
        for i in range(size):
            self._array[i] = foo
    def __getitem__(self,index):
        return self._array[index]
    def __setitem__(self,index,value):
        self._array[index] = value
    def __len__(self):
        return self._size

class TwoDArray:
    def __init__(self,columns,rows,foo):
        self._2dArray = Array(rows,foo)
        for i in range(rows):
            self._2dArray[i] = Array(columns,foo)

    def numRows(self):
        return len(self._2dArray)
    def numCols(self):
        return len((self._2dArray)[0])
    def __getitem__(self,indexTuple):
        row = indexTuple[0]
        col = indexTuple[1]
        assert row >= 0 and row < self.numRows() \
               and col >=0 and col < self.numCols(),\
               "Array script out of range"
        return ((self._2dArray)[row])[col]

if(__name__ == "__main__"):
    twodArray = TwoDArray(4,5,5)#sample input
    print(twodArray[2,3])

一个空的二维矩阵可以按照以下方式初始化：

temp=[[],[]]

（注：该代码为Python语言，表示创建了一个空的二维列表）

这里有一个更简单的方法：

import numpy as np
twoD = np.array([[]*m]*n)

如果要将所有单元格初始化为任何“x”值，请使用以下方法：

twoD = np.array([[x]*m]*n

这是我发现的最好的教授新程序员的方法，而且不需要使用额外的库。不过我还想要更好的东西。

def initialize_twodlist(value):
    list=[]
    for row in range(10):
        list.append([value]*10)
    return list

添加维度的通用模式可以从这个系列中得出：

x = 0
mat1 = []
for i in range(3):
    mat1.append(x)
    x+=1
print(mat1)


x=0
mat2 = []
for i in range(3):
    tmp = []
    for j in range(4):
        tmp.append(x)
        x+=1
    mat2.append(tmp)

print(mat2)


x=0
mat3 = []
for i in range(3):
    tmp = []
    for j in range(4):
        tmp2 = []
        for k in range(5):
            tmp2.append(x)
            x+=1
        tmp.append(tmp2)
    mat3.append(tmp)

print(mat3)

通常我使用这种方法来初始化一个二维数组：
n = [[int(x) for x in input().split()] for i in range(int(input()))]

另一种方法是使用字典来保存二维数组。

twoD = {}
twoD[0,0] = 0
print(twoD[0,0]) # ===> prints 0

这个可以容纳任何一维、二维的值，要将其初始化为0或其他整数值，请使用collections。

import collections
twoD = collections.defaultdict(int)
print(twoD[0,0]) # ==> prints 0
twoD[1,1] = 1
print(twoD[1,1]) # ==> prints 1

我理解的重要事情是：在初始化数组（无论是哪个维度）时，我们应该给数组的所有位置赋一个默认值。只有这样，初始化才能完成。之后，我们可以更改或接收新值到数组的任何位置。下面的代码对我完美地起作用了。

N=7
F=2

#INITIALIZATION of 7 x 2 array with deafult value as 0
ar=[[0]*F for x in range(N)]

#RECEIVING NEW VALUES TO THE INITIALIZED ARRAY
for i in range(N):
    for j in range(F):
        ar[i][j]=int(input())
print(ar)

lst=[[0]*n]*m
np.array(lst)

初始化所有矩阵，m为行数，n为列数