如何初始化Python中的二维数组（如果不使用Numpy的列表）？

Question

我正在开始Python，并且正在尝试使用二维列表，最初我在每个地方都用相同的变量填充。我想到了这一点：

def initialize_twodlist(foo):
    twod_list = []
    new = []
    for i in range (0, 10):
        for j in range (0, 10):
            new.append(foo)
        twod_list.append(new)
        new = []

它给出了理想的结果，但感觉就像是解决方法。是否可以更轻松/更短/更优雅的方式来做到这一点？

Answer 1

代码：

num_rows, num_cols = 4, 2
initial_val = 0
matrix = [[initial_val] * num_cols for _ in range(num_rows)]
print(matrix) 
# [[0, 0], [0, 0], [0, 0], [0, 0]]

initial_val 必须不可变。

Answer 2

t = [ [0]*10 for i in [0]*10]

对于每个元素，将创建一个新的 [0]*10 。

Answer 3

方法不正确：[[[none*m]*n]

>>> m, n = map(int, raw_input().split())
5 5
>>> x[0][0] = 34
>>> x
[[34, None, None, None, None], [34, None, None, None, None], [34, None, None, None, None], [34, None, None, None, None], [34, None, None, None, None]]
>>> id(x[0][0])
140416461589776
>>> id(x[3][0])
140416461589776

使用这种方法，Python不允许为外柱创建不同的地址空间，并且会导致与您的期望相比各种行为。

正确的方法，但除了例外：

y = [[0 for i in range(m)] for j in range(n)]
>>> id(y[0][0]) == id(y[1][0])
False

这是很好的方法，但是如果将默认值设置为 none ，则有例外，

>>> r = [[None for i in range(5)] for j in range(5)]
>>> r
[[None, None, None, None, None], [None, None, None, None, None], [None, None, None, None, None], [None, None, None, None, None], [None, None, None, None, None]]
>>> id(r[0][0]) == id(r[2][0])
True

因此使用此方法正确设置默认值。

绝对正确：

请按照Mike的答复 double loop 。

Answer 4

初始化二维数组的使用：
arr = [[]*m for I in range（n）]

实际上，
arr = [[]*m]*n 将创建一个2D数组，其中所有N数组都指向同一数组，因此任何元素中的任何值的任何更改都会反映在所有n列表中，

以获取更多信息进一步说明访问：

Answer 5

使用最简单的想法来创建这个。

wtod_list = []

并添加大小：

wtod_list = [[0 for x in xrange(10)] for x in xrange(10)]

或者如果我们想首先声明大小。我们只使用：

   wtod_list = [[0 for x in xrange(10)] for x in xrange(10)]

Answer 6

初始化一个大小为m x n的2D矩阵，0

m,n = map(int,input().split())
l = [[0 for i in range(m)] for j in range(n)]
print(l)

Answer 7

我使用它来创建 mxn 矩阵其中 m = m = number（行）和 n = number（列（列）。

arr = [[None]*(n) for _ in range(m)]

Answer 8

Matrix={}
for i in range(0,3):
  for j in range(0,3):
    Matrix[i,j] = raw_input("Enter the matrix:")

Answer 9

如果使用 numpy ，可以轻松创建2D数组：

import numpy as np

row = 3
col = 5
num = 10
x = np.full((row, col), num)

x

array([[10, 10, 10, 10, 10],
       [10, 10, 10, 10, 10],
       [10, 10, 10, 10, 10]])

Answer 10

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

以上将为您提供一个

[[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]]

使用嵌套列表理解的5x5 2D数组。
如下：

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

[x]*col-＆gt;评估的最终表达
对于x in - ＆gt; x将是迭代器提供的值
[B范围内的B（行）]] - ＆GT;迭代器。

[b对于范围（row）]]这将评估为[0,1,2,3,4]，因为行= 5
为

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

因此，现在它简化
[[0]*5对于[0,1,1,2,3,4]] - ＆gt; x = 0 1st迭代
[[1]*5对于[0,1,2,3,4]] - ＆gt; x = 1 2迭代
[[2]*5 for x in [0,1,2,3,4]] - ＆gt; x = 2 3迭代
[[3]*5 for x in [0,1,2,3,4]] - ＆gt; x = 3第四迭代
[[4]*5 for x in [0,1,2,3,4]] - ＆gt; x = 4第五迭代

Answer 11

正如@arnab和@mike指出的那样，数组不是列表。很少有差异是1）阵列在初始化期间的固定尺寸2）数组通常比列表相比支持较少的操作。

在大多数情况下，也许是过度杀伤力，但这是使用Python CTypes（C库）利用硬件阵列实现的基本2D数组实现

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])

Answer 12

这是一个更简单的方法：

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

使用任何“ x”值初始化所有单元格：

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

Answer 13

可以以以下方式初始化一个空的2D矩阵：

temp = [[]，[]]

Answer 14

这是我发现新程序员的最好的，而没有使用其他库。我想要更好的东西。

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

Answer 15

通常，我使用此方法来初始化二维数组

n = [[int（）in input（）。split（）。

Answer 16

可以从该系列中得出要添加维度的一般模式：

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)

Answer 17

我了解的重要一件事是：在初始化数组（在任何维度上）时，我们应该为所有数组的所有位置给出默认值。然后只有初始化才能完成。之后，我们可以将新值更改或接收到数组的任何位置。以下代码非常适合我

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)

Answer 18

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

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

这只是可以容纳任何1D，2D值，并将其初始化为 0 或任何其他INT值，请使用 collections 。

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

Answer 19

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

初始化所有矩阵M =行，n =列

Answer 20

要初始化Python中的二维列表，请使用

t = [ [0]*3 for i in range(3)]

但不要使用 [[V]*n]*n ，这是一个陷阱！

>>> a = [[0]*3]*3
>>> a
[[0, 0, 0], [0, 0, 0], [0, 0, 0]]
>>> a[0][0]=1
>>> a
[[1, 0, 0], [1, 0, 0], [1, 0, 0]]

Answer 21

Python经常出现的一种模式

bar = []
for item in some_iterable:
    bar.append(SOME EXPRESSION)

有助于激发列表综合的引入，这些模式将摘要转换为

bar = [SOME_EXPRESSION for item in some_iterable]

较短，有时更清晰。通常，您会养成识别这些习惯，并经常用综合替代循环。

您的代码遵循此模式两次

twod_list = []                                       \                      
for i in range (0, 10):                               \
    new = []                  \ can be replaced        } this too
    for j in range (0, 10):    } with a list          /
        new.append(foo)       / comprehension        /
    twod_list.append(new)                           /

Answer 22

您可以使用 list consections ：

x = [[foo for i in range(10)] for j in range(10)]
# x is now a 10x10 array of 'foo' (which can depend on i and j if you want)

Answer 23

这种方式比嵌套列表的理解更快

[x[:] for x in [[foo] * 10] * 10]    # for immutable foo!

，这里是一些python3时间安排，对于小列表，大小列表

$python3 -m timeit '[x[:] for x in [[1] * 10] * 10]'
1000000 loops, best of 3: 1.55 usec per loop

$ python3 -m timeit '[[1 for i in range(10)] for j in range(10)]'
100000 loops, best of 3: 6.44 usec per loop

$ python3 -m timeit '[x[:] for x in [[1] * 1000] * 1000]'
100 loops, best of 3: 5.5 msec per loop

$ python3 -m timeit '[[1 for i in range(1000)] for j in range(1000)]'
10 loops, best of 3: 27 msec per loop

说明：

[[FOO]*10]*10 创建一个列表相同的对象重复10次。您不能仅使用此功能，因为修改一个元素将在每一行中修改相同的元素！

x [：] 等效于 list（x），但效率更高，因为它避免了名称查找。无论哪种方式，它都会创建每行的浅副本，因此现在所有元素都是独立的。

所有元素都是相同的 foo 对象，因此，如果 foo 是可变的，您无法使用此方案。使用

import copy
[[copy.deepcopy(foo) for x in range(10)] for y in range(10)]

或假设返回 foo s的类（或函数） foo

[[Foo() for x in range(10)] for y in range(10)]

Answer 24

在Python中初始化二维阵列：

a = [[0 for x in range(columns)] for y in range(rows)]

Answer 25

[[foo for x in xrange(10)] for y in xrange(10)]

Answer 26

通常，当您想要多维阵列时，您不需要列表列表，而是一个numpy数组或可能的dict。

例如，使用numpy，您会做类似的事情

import numpy
a = numpy.empty((10, 10))
a.fill(foo)

Answer 27

为什么 [['']*m]*n 不好。

对于那些感到困惑的人， ”或“通过分配呼叫”。 info ）

最佳方法是 [[''for range（列）的j in range（行）]
这将解决所有问题。

为了获得更多澄清
例子：

>>> x = [['']*3]*3
[['', '', ''], ['', '', ''], ['', '', '']]
>>> x[0][0] = 1
>>> print(x)
[[1, '', ''], [1, '', ''], [1, '', '']]

>>> y = [['' for i in range(3)] for j in range(3)]
[['', '', ''], ['', '', ''], ['', '', '']]
>>> y[0][0]=1
>>> print(y)
[[1, '', ''], ['', '', ''], ['', '', '']]

Answer 28

您可以做到这一点：

[[element] * numcols] * numrows

例如：

>>> [['a'] *3] * 2
[['a', 'a', 'a'], ['a', 'a', 'a']]

但这具有不希望的副作用：

>>> b = [['a']*3]*3
>>> b
[['a', 'a', 'a'], ['a', 'a', 'a'], ['a', 'a', 'a']]
>>> b[1][1]
'a'
>>> b[1][1] = 'b'
>>> b
[['a', 'b', 'a'], ['a', 'b', 'a'], ['a', 'b', 'a']]

Answer 29

twod_list = [[foo for _ in range(m)] for _ in range(n)]

对于n，是行的数量，m是列的数量，而foo是值。

Answer 30

如果它是一个稀疏的人口组成的阵列，则最好使用带有元组键入的字典：

dict = {}
key = (a,b)
dict[key] = value
...