Tôi muốn xác định mảng hai chiều mà không có độ dài khởi tạo như thế này:

Matrix = [][]

Nhưng nó không hoạt động...

Tôi đã thử mã dưới đây, nhưng nó cũng sai:

Matrix = [5][5]

Lỗi:

Traceback ...

IndexError: list index out of range

Lỗi của tôi là gì?

Về mặt kỹ thuật, bạn đang cố gắng lập chỉ mục cho một mảng chưa được khởi tạo. Trước tiên, bạn phải khởi tạo danh sách bên ngoài với danh sách trước khi thêm các mục; Python gọi đây là "danh sách hiểu".

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

Bây giờ bạn có thể thêm các mục vào danh sách:

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

Lưu ý rằng ma trận là "y" địa chỉ chính, nói cách khác, "chỉ mục y" xuất hiện trước "chỉ số x".

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

Mặc dù bạn có thể đặt tên cho chúng theo ý muốn, tôi nhìn vào nó theo cách này để tránh một số nhầm lẫn có thể xảy ra với việc lập chỉ mục, nếu bạn sử dụng "x" cho cả danh sách bên trong và bên ngoài và muốn có Ma trận không vuông.

Nếu bạn thực sự muốn một ma trận, bạn có thể sử dụng tốt hơn numpy. Các phép toán ma trận numpythường sử dụng một kiểu mảng có hai chiều. Có nhiều cách để tạo một mảng mới; một trong những hữu ích nhất là zeroshàm, lấy tham số hình dạng và trả về một mảng của hình đã cho, với các giá trị được khởi tạo về 0:

>>> import numpy
>>> numpy.zeros((5, 5))
array([[ 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.]])

Dưới đây là một số cách khác để tạo mảng và ma trận 2 chiều (với đầu ra được loại bỏ để thu gọn):

numpy.arange(25).reshape((5, 5))         # create a 1-d range and reshape
numpy.array(range(25)).reshape((5, 5))   # pass a Python range and reshape
numpy.array([5] * 25).reshape((5, 5))    # pass a Python list and reshape
numpy.empty((5, 5))                      # allocate, but don't initialize
numpy.ones((5, 5))                       # initialize with ones

numpycũng cung cấp một matrixloại, nhưng nó không còn được khuyến nghị cho bất kỳ mục đích sử dụng nào và có thể bị xóa khỏi numpytrong tương lai.

Đây là một ký hiệu ngắn hơn để khởi tạo một danh sách các danh sách:

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

Thật không may, rút ​​ngắn điều này thành một cái gì đó như 5*[5*[0]]không thực sự hoạt động vì bạn kết thúc với 5 bản sao của cùng một danh sách, vì vậy khi bạn sửa đổi một trong số chúng, tất cả đều thay đổi, ví dụ:

>>> matrix = 5*[5*[0]]
>>> matrix
[[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]]
>>> matrix[4][4] = 2
>>> matrix
[[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]]

Nếu bạn muốn tạo một ma trận trống, cú pháp đúng là

matrix = [[]]

Và nếu bạn muốn tạo một ma trận có kích thước 5 chứa 0,

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

Nếu tất cả những gì bạn muốn là một thùng chứa hai chiều để chứa một số yếu tố, bạn có thể sử dụng từ điển một cách thuận tiện:

Matrix = {}

Sau đó, bạn có thể làm:

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

Điều này hoạt động vì 1,2là một tuple và bạn đang sử dụng nó làm chìa khóa để lập chỉ mục từ điển. Kết quả tương tự như một ma trận thưa thớt.

Như được chỉ định bởi osa và Josap Valls, bạn cũng có thể sử dụng Matrix = collections.defaultdict(lambda:0)để các phần tử bị thiếu có giá trị mặc định là 0.

Vatsal nói thêm rằng phương pháp này có thể không hiệu quả lắm đối với các ma trận lớn và chỉ nên được sử dụng trong các phần không quan trọng về hiệu năng của mã.

Trong Python bạn sẽ tạo một danh sách các danh sách. Bạn không phải khai báo kích thước trước thời hạn, nhưng bạn có thể. Ví dụ:

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

Bây giờ ma trận [0] [0] == 2 và ma trận [1] [0] == 3. Bạn cũng có thể sử dụng cú pháp hiểu danh sách. Ví dụ này sử dụng nó hai lần để xây dựng "danh sách hai chiều":

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

Câu trả lời được chấp nhận là tốt và chính xác, nhưng tôi phải mất một thời gian để hiểu rằng tôi cũng có thể sử dụng nó để tạo ra một mảng hoàn toàn trống rỗng.

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

kết quả trong

[[], [], []]

Bạn nên lập một danh sách các danh sách, và cách tốt nhất là sử dụng các cách hiểu lồng nhau:

>>> matrix = [[0 for i in range(5)] for j in range(5)]
>>> pprint.pprint(matrix)
[[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]]

Trong [5][5]ví dụ của bạn , bạn đang tạo một danh sách có số nguyên "5" bên trong và cố gắng truy cập mục thứ 5 của nó và điều đó làm tăng IndexError một cách tự nhiên vì không có mục thứ 5:

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

rows = int(input())
cols = int(input())

matrix = []
for i in range(rows):
  row = []
  for j in range(cols):
    row.append(0)
  matrix.append(row)

print(matrix)

Tại sao một mã dài như vậy, mà quá Python bạn hỏi?

Lâu rồi tôi không thấy thoải mái với Python, tôi đã thấy các câu trả lời một dòng để viết ma trận 2D và tự nhủ rằng tôi sẽ không sử dụng ma trận 2 chiều trong Python nữa. (Những dòng đơn đó khá đáng sợ và nó không cung cấp cho tôi bất kỳ thông tin nào về những gì Python đang làm. Cũng lưu ý rằng tôi không biết về những tốc ký này.)

Dù sao, đây là mã cho người mới bắt đầu đến từ nền tảng C, CPP và Java

Lưu ý cho những người yêu thích và các chuyên gia về Python: Xin đừng bỏ phiếu chỉ vì tôi đã viết một mã chi tiết.

Viết lại để dễ đọc:

# 2D array/ matrix

# 5 rows, 5 cols
rows_count = 5
cols_count = 5

# create
#     creation looks reverse
#     create an array of "cols_count" cols, for each of the "rows_count" rows
#        all elements are initialized to 0
two_d_array = [[0 for j in range(cols_count)] for i in range(rows_count)]

# index is from 0 to 4
#     for both rows & cols
#     since 5 rows, 5 cols

# use
two_d_array[0][0] = 1
print two_d_array[0][0]  # prints 1   # 1st row, 1st col (top-left element of matrix)

two_d_array[1][0] = 2
print two_d_array[1][0]  # prints 2   # 2nd row, 1st col

two_d_array[1][4] = 3
print two_d_array[1][4]  # prints 3   # 2nd row, last col

two_d_array[4][4] = 4
print two_d_array[4][4]  # prints 4   # last row, last col (right, bottom element of matrix)

Sử dụng:

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

* 5 cho kích thước đầu tiên hoạt động vì ở cấp độ này, dữ liệu là bất biến.

Để khai báo một ma trận các số không (những cái):

numpy.zeros((x, y))

ví dụ

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

hoặc numpy.ones ((x, y)) vd

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

Thậm chí ba chiều là có thể. ( http://www.astro.ufl.edu/~warner/prog/python.html xem -> mảng đa chiều)

Đây là cách tôi thường tạo các mảng 2D trong python.

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

Tôi thấy cú pháp này dễ nhớ so với việc sử dụng hai vòng lặp cho việc hiểu danh sách.

Tôi đang sử dụng tập lệnh Python đầu tiên của mình và tôi hơi bối rối với ví dụ ma trận vuông nên tôi hy vọng ví dụ dưới đây sẽ giúp bạn tiết kiệm thời gian:

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

vậy nên

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

Sử dụng NumPy, bạn có thể khởi tạo ma trận trống như thế này:

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

Và sau đó nối thêm dữ liệu như thế này:

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

Tôi đọc các tệp được phân tách bằng dấu phẩy như thế này:

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

Danh sách "dữ liệu" sau đó là danh sách các danh sách có dữ liệu chỉ mục [hàng] [col]

Nếu bạn muốn có thể nghĩ nó như một mảng 2D thay vì bị buộc phải suy nghĩ theo danh sách các danh sách (theo ý kiến ​​của tôi tự nhiên hơn nhiều), bạn có thể làm như sau:

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

Kết quả là một danh sách (không phải là mảng NumPy) và bạn có thể ghi đè lên các vị trí riêng lẻ bằng số, chuỗi, bất cứ thứ gì.

Đó là những gì từ điển được làm cho!

matrix = {}

Bạn có thể xác định khóa và giá trị theo hai cách:

matrix[0,0] = value

hoặc là

matrix = { (0,0)  : value }

Kết quả:

   [ value,  value,  value,  value,  value],
   [ value,  value,  value,  value,  value],
   ...

Sử dụng:

import copy

def ndlist(*args, init=0):
    dp = init
    for x in reversed(args):
        dp = [copy.deepcopy(dp) for _ in range(x)]
    return dp

l = ndlist(1,2,3,4) # 4 dimensional list initialized with 0's
l[0][1][2][3] = 1

Tôi nghĩ NumPy là con đường để đi. Trên đây là một cái chung nếu bạn không muốn sử dụng NumPy.

bằng cách sử dụng danh sách:

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

bằng cách sử dụng dict: bạn cũng có thể lưu trữ thông tin này trong bảng băm để tìm kiếm nhanh như

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

ma trận ['1'] sẽ cho bạn kết quả trong thời gian O (1)

* nb : bạn cần xử lý một vụ va chạm trong bảng băm

Nếu bạn không có thông tin kích thước trước khi bắt đầu thì hãy tạo hai danh sách một chiều.

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

Lưu trữ toàn bộ hàng trong danh sách 1. Sau khi hoàn thành, nối danh sách 1 vào danh sách 2:

from random import randint

coordinates=[]
temp=[]
points=int(raw_input("Enter No Of Coordinates >"))
for i in range(0,points):
    randomx=randint(0,1000)
    randomy=randint(0,1000)
    temp=[]
    temp.append(randomx)
    temp.append(randomy)
    coordinates.append(temp)

print coordinates

Đầu ra:

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

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

Hãy cẩn thận về biểu thức ngắn này, xem phần giải thích đầy đủ trong câu trả lời của @ FJ

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

Sẽ nhanh hơn:

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

Bạn có thể tạo một danh sách hai chiều trống bằng cách lồng hai hoặc nhiều dấu ngoặc vuông hoặc dấu ngoặc thứ ba ( [], được phân tách bằng dấu phẩy) bằng một dấu ngoặc vuông, giống như dưới đây:

Matrix = [[], []]

Bây giờ giả sử bạn muốn nối thêm 1 vào Matrix[0][0]thì bạn gõ:

Matrix[0].append(1)

Bây giờ, gõ Matrix và nhấn Enter. Đầu ra sẽ là:

[[1], []]

Thử cái này:

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

Trong trường hợp nếu bạn cần một ma trận với các số được xác định trước, bạn có thể sử dụng mã sau:

def matrix(rows, cols, start=0):
    return [[c + start + r * cols for c in range(cols)] for r in range(rows)]


assert matrix(2, 3, 1) == [[1, 2, 3], [4, 5, 6]]

Đây là đoạn mã để tạo ma trận trong python:

# get the input rows and cols
rows = int(input("rows : "))
cols = int(input("Cols : "))

# initialize the list
l=[[0]*cols for i in range(rows)]

# fill some random values in it
for i in range(0,rows):
    for j in range(0,cols):
        l[i][j] = i+j

# print the list
for i in range(0,rows):
    print()
    for j in range(0,cols):
        print(l[i][j],end=" ")

Xin đề nghị nếu tôi đã bỏ lỡ một cái gì đó.