Технически вы пытаетесь проиндексировать неинициализированный массив. Перед добавлением элементов необходимо сначала инициализировать внешний список списками; Python называет это «пониманием списка».

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

Теперь вы можете добавлять элементы в список:

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

Обратите внимание, что матрица является основным адресом «y», другими словами, «индекс y» стоит перед «индексом x».

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

Хотя вы можете называть их как хотите, я смотрю на это таким образом, чтобы избежать некоторой путаницы, которая может возникнуть при индексировании, если вы используете «x» как для внутреннего, так и для внешнего списков и хотите получить неквадратную матрицу.

Если вам действительно нужна матрица, возможно, вам лучше использовать numpy. Матричные операции в numpy чаще всего используют тип массива с двумя измерениями. Есть много способов создать новый массив; одной из наиболее полезных является функция zeros, которая принимает параметр формы и возвращает массив данной формы со значениями, инициализированными равными нулю:

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

Вот еще несколько способов создания двумерных массивов и матриц (с удалением вывода для компактности):

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

numpy также предоставляет тип matrix, но больше не рекомендуется для любого использования и может быть удален из numpy в будущем.

Вот более короткое обозначение для инициализации списка списков:

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

К сожалению, сокращение этого до чего-то вроде 5*[5*[0]] на самом деле не работает, потому что вы получаете 5 копий одного и того же списка, поэтому, когда вы изменяете одну из них, все они изменяются, например:

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

Если вы хотите создать пустую матрицу, правильный синтаксис:

matrix = [[]]

И если вы хотите сгенерировать матрицу размера 5, заполненную 0,

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

Если все, что вам нужно, это двухмерный контейнер для хранения некоторых элементов, вы можете вместо этого использовать словарь:

Matrix = {}

Тогда вы сможете:

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

Это работает, потому что 1,2 - это кортеж, и вы используете его как ключ для индексации словаря. Результат похож на тупую разреженную матрицу.

Как указано osa и Josap Valls, вы также можете использовать Matrix = collections.defaultdict(lambda:0), чтобы отсутствующие элементы имели значение по умолчанию 0.

Ватсал также указывает, что этот метод, вероятно, не очень эффективен для больших матриц и должен использоваться только в частях кода, не критичных для производительности.

В Python вы будете создавать список списков. Размеры не нужно объявлять заранее, но можно. Например:

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

Теперь матрица [0] [0] == 2 и матрица [1] [0] == 3. Вы также можете использовать синтаксис понимания списка. В этом примере он используется дважды для построения «двумерного списка»:

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

Вы должны составить список списков, и лучше всего использовать вложенные понимания:

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

В вашем [5][5] примере вы создаете список с целым числом «5» внутри и пытаетесь получить доступ к его 5-му элементу, что, естественно, вызывает IndexError, потому что 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)

Почему такой длинный код, это тоже в Python, спросите вы?

Давным-давно, когда мне было неудобно с Python, я увидел однострочные ответы для написания 2D-матрицы и сказал себе, что больше не собираюсь использовать 2D-матрицу в Python. (Эти отдельные строки были довольно пугающими, и они не давали мне никакой информации о том, что делал Python. Также обратите внимание, что я не знаю об этих сокращениях.)

В любом случае, вот код для новичка, который имеет опыт работы с C, CPP и Java.

Примечание для любителей и экспертов Python: пожалуйста, не голосуйте против только потому, что я написал подробный код.

Принятый ответ хорош и верен, но мне потребовалось время, чтобы понять, что я могу также использовать его для создания полностью пустого массива.

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

приводит к

[[], [], []]

Вот как я обычно создаю 2D-массивы в Python.

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

Я считаю, что этот синтаксис легче запомнить по сравнению с использованием двух циклов for в понимании списка.

Использовать:

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

* 5 для первого измерения работает, потому что на этом уровне данные неизменяемы.

Переписано для удобства чтения:

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

Чтобы объявить матрицу нулей (единиц):

numpy.zeros((x, y))

e.g.

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

или numpy.ones ((x, y)), например.

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

Возможны даже три измерения. (http://www.astro.ufl.edu/~warner/prog/python.html см. -> Многомерные массивы)

Я использую свой первый скрипт Python, и меня немного смутил пример квадратной матрицы, поэтому я надеюсь, что приведенный ниже пример поможет вам сэкономить время:

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

так что

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

Используя NumPy, вы можете инициализировать пустую матрицу следующим образом:

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

А потом добавьте такие данные:

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

Вы можете создать пустой двумерный список, вложив две или более квадратных распорок или третью скобку ([], разделенных запятыми) с квадратными распорками, как показано ниже:

Matrix = [[], []]

Теперь предположим, что вы хотите добавить 1 к Matrix[0][0], затем введите:

Matrix[0].append(1)

Теперь введите Matrix и нажмите Enter. Результатом будет:

[[1], []]

Если вместо этого вы ввели следующий оператор

Matrix[1].append(1)

тогда Матрица будет

[[], [1]]

Вот для чего создан словарь!

matrix = {}

Вы можете определить ключи и значения двумя способами:

matrix[0,0] = value

or

matrix = { (0,0)  : value }

Результат:

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

Я читаю файлы, разделенные запятыми, например:

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

Список «данные» тогда представляет собой список списков с индексными данными [строка] [столбец]

Если вы хотите думать о нем как о 2D-массиве, а не о том, чтобы вас заставляли думать в терминах списка списков (что, на мой взгляд, гораздо более естественно), вы можете сделать следующее:

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

Результатом является список (а не массив NumPy), и вы можете перезаписать отдельные позиции числами, строками и т. Д.

Использовать:

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

Я действительно думаю, что NumPy - это то, что нужно. Вышеупомянутое является общим, если вы не хотите использовать NumPy.

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

Будьте осторожны с этим коротким выражением, см. Полное объяснение в ответе @ F.J.

используя список:

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

используя dict: вы также можете сохранить эту информацию в хеш-таблице для быстрого поиска, например

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

матрица ['1'] даст результат за время O (1)

* nb: вам нужно иметь дело с конфликтом в хеш-таблице

Если у вас нет информации о размере до начала, создайте два одномерных списка.

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

Сохраните всю строку в первом списке. После этого добавьте список 1 в список 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

Выход:

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

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

Будет быстрее, чем:

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

Вот фрагмент кода для создания матрицы на 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=" ")

Пожалуйста, предложите, если я что-то пропустил.

Попробуй это:

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

В случае, если вам нужна матрица с предопределенными числами, вы можете использовать следующий код:

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

Пользовательская функция для ввода матрицы и печати

def inmatrix(m,n):
    #Start function and pass row and column as parameter
    a=[] #create a blank matrix
    for i in range(m): #Row input
        b=[]#blank list
        for j in range(n): # column input
            elm=int(input("Enter number in Pocket ["+str(i)+"]["+str(j)+"] ")) #Show Row And column  number 
            b.append(elm) #add value to b list
        a.append(b)# Add list to matrix
    return  a #return Matrix 

def Matrix(a): #function for print Matrix
    for i in range(len(a)): #row
        for j in range(len(a[0])): #column
            print(a[i][j],end=" ") #print value with space
        print()#print a line After a row print

m=int(input("Enter number of row")) #input row
n=int(input("Enter number of column"))
a=inmatrix(m,n) #call input matrix function 

print("Matrix is ... ")

Matrix(a) #print matrix function