파이썬에서 2 차원 배열을 초기화하는 방법?

나는 파이썬을 시작하고 있으며 2 차원 목록을 사용하려고합니다. 처음에는 모든 곳에서 동일한 변수로 채워집니다. 나는 이것을 생각해 냈다.

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

원하는 결과를 제공하지만 해결 방법처럼 느껴집니다. 이 작업을 더 쉽고 짧고 우아한 방법이 있습니까?

파이썬에서 자주 등장한 패턴은

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

당신은 목록 이해를 사용할 수 있습니다 :

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)

이 방법은 중첩 된 목록 이해보다 빠릅니다.

[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]*1010 회 반복 된 동일한 객체의 목록을 만듭니다. 하나의 요소를 수정하면 각 행에서 동일한 요소가 수정되므로 이것을 사용할 수 없습니다!

x[:]list(X)이름 조회를 피하기 때문에 동등 하지만 조금 더 효율적입니다. 어느 쪽이든, 각 행의 얕은 사본을 작성하므로 이제 모든 요소가 독립적입니다.

모든 요소는 동일한 foo객체이므로 foo변경할 수 있으면 이 체계를 사용할 수 없습니다.

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

또는 s Foo를 반환 하는 클래스 (또는 함수) 를 가정foo

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

사용하지 마십시오 [[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]]

그러나

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

잘 작동합니다.

파이썬에서 2 차원 배열을 초기화하려면 :

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

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

일반적으로 다차원 배열을 원할 때 목록 목록이 아니라 numpy 배열 또는 dict이 필요합니다.

예를 들어, numpy를 사용하면 다음과 같은 작업을 수행합니다

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

당신은 이것을 할 수 있습니다 :

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

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

n은 행 수이고 m은 열 수이며 foo는 값입니다.

드물게 인구가 많은 배열 인 경우 튜플이있는 사전을 사용하는 것이 좋습니다.

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

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

각 요소마다 새로운 [0]*10것이 만들어 질 것입니다 ..

잘못된 접근 방식 : [[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

이 방법을 사용하면 파이썬은 외부 열에 대해 다른 주소 공간을 만들 수 없으므로 예상보다 다양한 오작동을 일으킬 수 있습니다.

올바른 접근 방식이지만 예외는 다음과 같습니다.

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

따라서이 방법을 사용하여 기본값을 올바르게 설정하십시오.

절대 맞습니다 :

마이크의 이중 루프 답장을 따르십시오 .

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

2 차원 배열을 초기화하려면 다음을 사용하십시오. arr = [[]*m for i in range(n)]

실제로 arr = [[]*m]*n모든 n 배열이 동일한 배열을 가리키는 2D 배열을 생성하므로 모든 요소의 값 변경은 모든 n 목록에 반영됩니다

자세한 설명은 https://www.geeksforgeeks.org/python-using-2d-arrays-lists-the-right-way/를 참조 하십시오.

이것을 만들려면 가장 간단한 생각을 사용하십시오.

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

@Arnab과 @Mike가 지적했듯이 배열은 목록이 아닙니다. 몇 가지 차이점은 1) 초기화 중에 배열의 크기가 고정 된 것입니다. 2) 배열은 일반적으로 목록보다 적은 연산을 지원합니다.

아마도 대부분의 경우 과잉 일 수도 있지만 여기에는 파이썬 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])

내가 이해 한 중요한 것은 : 배열을 초기화하는 동안 (어떤 차원에서든) 배열의 모든 위치에 기본값을 지정해야합니다. 그런 다음 초기화 만 완료됩니다. 그런 다음 배열의 임의의 위치로 새 값을 변경하거나 수신 할 수 있습니다. 아래 코드는 완벽하게 작동했습니다.

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)

numpy 를 사용 하면 2D 배열을 쉽게 만들 수 있습니다.

import numpy as np

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

엑스

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

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

위의 내용은 5x5 2D 배열입니다.

[[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-> x in->
x에 대해 평가되는 최종 표현식 은 반복자에 의해 제공되는 값입니다
[범위 (행)에서 b의 경우 b]]-> 반복자.

[범위 (행)의 b에 대한 b]]]는 row = 5
이므로 [0,1,2,3,4]로 평가 되므로 이제는

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

이것은 [0,1,2,3,4]에서 x에 대해 [[0] * 5로 평가됨]-> x = 0으로 첫 번째 반복
[[1] * 5에 대해 [0,1,2에서 x에 대해] 3,4]]-> x = 1 인 2 번째 반복
[[1,2,3,4]]에서 x의 x에 대한 [[2] * 5]-> x = 2 인 3 번째 반복
[[3] * 5 x의 경우 [0,1,2,3,4]의 x에 대해 x = 3 일 때 4 번 반복
[[4] * 5의 경우 [0,1,2,3,4]의 x에 대해-> x의 경우 = 4 5 번째 반복

이것은 새로운 프로그래머를 가르치고 추가 라이브러리를 사용하지 않고 내가 찾은 최고의 것입니다. 그래도 더 좋은 것을 원합니다.

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

더 쉬운 방법은 다음과 같습니다.

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

'x'값으로 모든 셀을 초기화하려면 다음을 사용하십시오.

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

종종이 방법을 사용하여 2 차원 배열을 초기화합니다.

n=[[int(x) for x in input().split()] for i in range(int(input())]

이 시리즈에서 치수를 추가하는 일반적인 패턴을 그릴 수 있습니다.

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)

이 [[0] * 10] * 10을 시도 할 수 있습니다. 그러면 각 셀에 대해 값이 0 인 10 개의 행과 10 개의 열로 구성된 2 차원 배열이 반환됩니다.

범위 (n)의 i에 대한 lst = [[0] * m]

모든 행렬 초기화 n = 행 및 m = 열

다른 방법은 사전을 사용하여 2 차원 배열을 보유하는 것입니다.

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

이것은 1D, 2D 값을 보유 할 수 있으며 이것을 0int 또는 다른 int 값 으로 초기화 하려면 collections를 사용하십시오 .

import collections
twoD = collections.defaultdict(int)
print(twoD[0,0]) # ==> prints 0
twoD[1,1] = 1
print(twoD[1,1]) # ==> prints 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 불변이어야합니다.

from random import randint
l = []

for i in range(10):
    k=[]
    for j in range(10):
        a= randint(1,100)
        k.append(a)

    l.append(k)




print(l)
print(max(l[2]))

b = []
for i in range(10):
    a = l[i][5]
    b.append(a)

print(min(b))