Làm cách nào để khởi tạo một mảng hai chiều trong Python?

Tôi đang bắt đầu python và tôi đang cố gắng sử dụng một danh sách hai chiều, ban đầu tôi điền vào cùng một biến ở mọi nơi. Tôi nghĩ ra cái này:

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

Nó cho kết quả mong muốn, nhưng cảm thấy như một cách giải quyết. Có một cách dễ dàng hơn / ngắn hơn / thanh lịch hơn để làm điều này?

Một mô hình thường xuất hiện trong Python là

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

đã giúp thúc đẩy việc giới thiệu danh sách, giúp chuyển đổi đoạn mã đó thành

bar = [SOME EXPRESSION for item in some_iterable]

đó là ngắn hơn và đôi khi rõ ràng hơn. Thông thường bạn có thói quen nhận ra những điều này và thường thay thế các vòng lặp bằng sự hiểu biết.

Mã của bạn theo mẫu này hai lần

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

Bạn có thể sử dụng một danh sách hiểu :

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)

Cách này nhanh hơn cách hiểu danh sách lồng nhau

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

Dưới đây là một số thời gian python3, cho danh sách nhỏ và lớn

$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

Giải trình:

[[foo]*10]*10tạo một danh sách của cùng một đối tượng được lặp lại 10 lần. Bạn không thể chỉ sử dụng điều này, bởi vì sửa đổi một yếu tố sẽ sửa đổi cùng một yếu tố đó trong mỗi hàng!

x[:]tương đương list(X)nhưng hiệu quả hơn một chút vì nó tránh được việc tra cứu tên. Dù bằng cách nào, nó tạo ra một bản sao nông của mỗi hàng, vì vậy bây giờ tất cả các yếu tố là độc lập.

Tất cả các yếu tố là cùng một foođối tượng, vì vậy nếu foocó thể thay đổi , bạn không thể sử dụng lược đồ này., Bạn phải sử dụng

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

hoặc giả sử một lớp (hoặc hàm) Footrả về foos

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

Đừng sử dụng [[v]*n]*n, đó là một cái bẫy!

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

nhưng

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

làm việc tuyệt vời

Để khởi tạo một mảng hai chiều trong Python:

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

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

Thông thường khi bạn muốn các mảng nhiều chiều, bạn không muốn có một danh sách các danh sách, mà là một mảng khó hiểu hoặc có thể là một lệnh.

Ví dụ, với numpy bạn sẽ làm một cái gì đó như

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

Bạn có thể làm điều này:

[[element] * numcols] * numrows

Ví dụ:

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

Nhưng điều này có tác dụng phụ không mong muốn:

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

với n là số hàng và m là số cột và foo là giá trị.

Nếu đó là một mảng dân cư thưa thớt, bạn có thể tốt hơn bằng cách sử dụng một từ điển được khóa với một tuple:

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

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

đối với mỗi phần tử, một phần tử mới [0]*10sẽ được tạo ..

Cách tiếp cận không chính xác: [[Không * 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

Với phương pháp này, python không cho phép tạo không gian địa chỉ khác nhau cho các cột bên ngoài và sẽ dẫn đến nhiều hành vi sai trái hơn mong đợi của bạn.

Cách tiếp cận đúng nhưng ngoại lệ:

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

Đó là cách tiếp cận tốt nhưng có ngoại lệ nếu bạn đặt giá trị mặc định thành 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

Vì vậy, đặt giá trị mặc định của bạn đúng cách sử dụng phương pháp này.

Hoàn toàn chính xác:

Thực hiện theo câu trả lời của mike của vòng lặp đôi .

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

Để khởi tạo mảng 2 chiều, hãy sử dụng: arr = [[]*m for i in range(n)]

thực ra, arr = [[]*m]*n sẽ tạo ra một mảng 2D trong đó tất cả các mảng n sẽ trỏ đến cùng một mảng, do đó, mọi thay đổi về giá trị trong bất kỳ phần tử nào sẽ được phản ánh trong tất cả các danh sách n

để được giải thích thêm, hãy truy cập: https://www.geekforgeek.org/python-USE-2d-arrays-lists-the-right-way/

sử dụng suy nghĩ đơn giản nhất để tạo ra điều này.

wtod_list = []

và thêm kích thước:

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

hoặc nếu chúng ta muốn khai báo kích thước trước tiên. chúng tôi chỉ sử dụng:

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

Như @Arnab và @Mike đã chỉ ra, một mảng không phải là một danh sách. Một số khác biệt là 1) mảng có kích thước cố định trong quá trình khởi tạo 2) mảng thường hỗ trợ các hoạt động ít hơn so với danh sách.

Có thể là quá mức trong hầu hết các trường hợp, nhưng đây là cách triển khai mảng 2d cơ bản, thúc đẩy triển khai mảng phần cứng bằng cách sử dụng python ctypes (thư viện 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])

Điều quan trọng tôi hiểu là: Trong khi khởi tạo một mảng (ở bất kỳ chiều nào) Chúng ta nên đưa ra một giá trị mặc định cho tất cả các vị trí của mảng. Sau đó, chỉ khởi tạo hoàn thành. Sau đó, chúng ta có thể thay đổi hoặc nhận các giá trị mới cho bất kỳ vị trí nào của mảng. Các mã dưới đây làm việc cho tôi hoàn hảo

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)

Nếu bạn sử dụng numpy , bạn có thể dễ dàng tạo các mảng 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]])

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

Ở trên sẽ cung cấp cho bạn một mảng 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]]

Đó là sử dụng sự hiểu biết danh sách lồng nhau. Phân tích như sau:

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

[x] * col -> biểu thức cuối cùng được ước tính
cho x in -> x sẽ là giá trị được cung cấp bởi iterator
[b cho b trong phạm vi (hàng)]] -> Iterator.

[b cho b trong phạm vi (hàng)]] điều này sẽ ước tính thành [0,1,2,3,4] vì hàng = 5
nên giờ nó đơn giản hóa thành

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

Điều này sẽ ước tính thành [[0] * 5 cho x trong [0,1,2,3,4]] -> với x = 0 lần lặp đầu tiên
[[1] * 5 cho x trong [0,1,2, 3,4]] -> với x = 1 lần lặp thứ 2
[[2] * 5 cho x trong [0,1,2,3,4]] -> với x = 2 lần lặp thứ 3
[[3] * 5 cho x trong [0,1,2,3,4]] -> với x = 3 lần lặp thứ 4
[[4] * 5 cho x trong [0,1,2,3,4]] -> với x = 4 lần lặp thứ 5

Đây là cách tốt nhất tôi tìm thấy để dạy lập trình viên mới và không sử dụng các thư viện bổ sung. Tôi muốn một cái gì đó tốt hơn mặc dù.

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

Đây là một cách dễ dàng hơn:

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

Để khởi tạo tất cả các ô với bất kỳ giá trị 'x' nào, hãy sử dụng:

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

Thường thì tôi sử dụng phương pháp này để khởi tạo mảng 2 chiều

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

Mẫu chung để thêm kích thước có thể được rút ra từ loạt bài này:

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)

Bạn có thể thử điều này [[0] * 10] * 10. Điều này sẽ trả về mảng 2d gồm 10 hàng và 10 cột có giá trị 0 cho mỗi ô.

lst = [[0] * m cho i trong phạm vi (n)]

khởi tạo tất cả ma trận n = hàng và m = cột

Một cách khác là sử dụng từ điển để giữ một mảng hai chiều.

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

Điều này chỉ có thể giữ bất kỳ giá trị 1D, 2D nào và để khởi tạo giá trị này thành 0hoặc bất kỳ giá trị int nào khác, hãy sử dụng các bộ sưu tập .

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

Mã số:

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 phải bất biến.

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