Bu gibi bir başlangıç ​​uzunluğu olmadan iki boyutlu bir dizi tanımlamak istiyorum:

Matrix = [][]

ama bu çalışmıyor...

Aşağıdaki kodu denedim, ama çok yanlış:

Matrix = [5][5]

Hata:

Traceback ...

IndexError: list index out of range

Benim hatam nedir?

Teknik olarak başlatılmamış bir dizini dizine eklemeye çalışıyorsunuz. Öğe eklemeden önce dış listeyi listelerle başlatmanız gerekir; Python buna "liste kavraması" adını verir.

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

Artık listeye öğe ekleyebilirsiniz:

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

Matrisin "y" adres majör olduğunu, başka bir deyişle "y indeksinin" x indeksinden önce geldiğini unutmayın.

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

Bunları istediğiniz gibi adlandırabilseniz de, hem iç hem de dış listeler için "x" kullanırsanız ve kare olmayan bir Matris istiyorsanız, indekslemeyle ortaya çıkabilecek bazı karışıklıkları önlemek için bu şekilde bakarım.

Gerçekten bir matris istiyorsanız, kullanmaktan daha iyi olabilirsiniz numpy. Matris işlemleri numpyçoğunlukla iki boyutlu bir dizi türü kullanır. Yeni bir dizi oluşturmanın birçok yolu vardır; en kullanışlı olanlardan biri, zerosşekil parametresini alan ve verilen şeklin bir dizisini döndüren ve değerlerin sıfır olarak başlatılması işlevidir:

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

Aşağıda, 2 boyutlu diziler ve matrisler oluşturmanın başka yolları da vardır (kompaktlık için çıktı kaldırılmış olarak):

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

numpybir matrixtür sağlar , ancak artık herhangi bir kullanım için önerilmeznumpy ve gelecekte kaldırılabilir .

Listelerin bir listesini başlatmak için daha kısa bir gösterim:

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

Maalesef bunu aynı şekilde kısaltmak 5*[5*[0]]gerçekten işe yaramaz çünkü aynı listenin 5 kopyasını elde edersiniz, bu nedenle bunlardan birini değiştirdiğinizde hepsi değişir, örneğin:

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

Boş bir matris oluşturmak istiyorsanız, doğru sözdizimi

matrix = [[]]

Ve 0 ile dolu 5 büyüklüğünde bir matris oluşturmak istiyorsanız,

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

İstediğiniz tek şey bazı öğeleri tutmak için iki boyutlu bir kapsa, bunun yerine uygun bir sözlük kullanabilirsiniz:

Matrix = {}

Sonra şunları yapabilirsiniz:

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

Bu 1,2bir demet olduğu için çalışır ve sözlüğü dizine eklemek için bir anahtar olarak kullanırsınız. Sonuç, aptal seyrek bir matrise benzer.

Osa ve Josap Valls tarafından belirtildiği gibi Matrix = collections.defaultdict(lambda:0), eksik öğelerin varsayılan değeri olan bir değer de kullanabilirsiniz 0.

Vatsal ayrıca, bu yöntemin büyük matrisler için muhtemelen çok verimli olmadığını ve yalnızca kodun performans açısından kritik olmayan kısımlarında kullanılması gerektiğini belirtmektedir.

Python'da bir liste listesi oluşturacaksınız. Boyutları önceden bildirmek zorunda değilsiniz, ancak yapabilirsiniz. Örneğin:

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

Şimdi matris [0] [0] == 2 ve matris [1] [0] == 3. Liste anlama sözdizimini de kullanabilirsiniz. Bu örnek, iki boyutlu bir "iki boyutlu liste" oluşturmak için kullanır:

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

Kabul edilen cevap iyi ve doğru, ama tamamen boş bir dizi oluşturmak için de kullanabileceğimi anlamak biraz zaman aldı.

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

sonuç

[[], [], []]

Listelerin bir listesini yapmalısınız ve en iyi yol iç içe kavrayışları kullanmaktır:

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

Senin üzerinde [5][5]örneğin, bir tamsayı "5" içeride olan bir listesini oluşturarak, ve 5 öğeye erişmek için denemek ve hiçbir 5 öğe olduğundan bu doğal bir IndexError yükseltir gibidir:

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

Neden bu kadar uzun bir kod, Pythonsizde de soruyorsunuz?

Python ile rahat olmadığımda, 2D matris yazmak için tek satırlık cevapları gördüm ve kendime tekrar Python'da 2-D matris kullanmayacağımı söyledim. (Bu tek satırlar oldukça korkutucuydu ve bana Python'un ne yaptığına dair herhangi bir bilgi vermedi. Ayrıca bu kısayolların farkında olmadığımı da unutmayın.)

Her neyse, C, CPP ve Java arka planından gelen yeni başlayanlar için kod

Python Lovers ve Experts'e not: Sadece ayrıntılı bir kod yazdığım için lütfen oy vermeyin.

kullanın:

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

İlk boyut için * 5 işe yarıyor çünkü bu seviyede veriler değişmez.

Kolay okuma için yeniden yazma:

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

Python'da genellikle 2D diziler oluşturuyorum.

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

Bu sözdizimini bir liste kavrayışında döngüler için iki kullanmaya kıyasla hatırlaması kolay buluyorum.

Sıfırlardan oluşan bir matris bildirmek için:

numpy.zeros((x, y))

Örneğin

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

veya numpy.ones ((x, y)) ör.

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

Üç boyut bile mümkündür. ( http://www.astro.ufl.edu/~warner/prog/python.html bkz. -> Çok boyutlu diziler)

İlk Python betiğimin üzerindeyim ve kare matris örneği ile biraz kafam karıştı, bu yüzden aşağıdaki örneğin biraz zaman kazanmanıza yardımcı olacağını umuyorum:

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

Böylece

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

NumPy'yi kullanarak boş matrisi şu şekilde başlatabilirsiniz:

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

Ve daha sonra bunun gibi veriler ekleyin:

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

Virgülle ayrılmış dosyalarda şöyle okudum:

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

"Veri" listesi, dizin verileri [satır] [col] içeren listelerin listesidir.

Ne en That Sözlük için yapılır!

matrix = {}

Anahtarları ve değerleri iki şekilde tanımlayabilirsiniz :

matrix[0,0] = value

veya

matrix = { (0,0)  : value }

Sonuç:

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

Liste listesi açısından düşünmeye zorlanmak yerine bunu 2D bir dizi olarak düşünmek istiyorsanız (bence çok daha doğal), aşağıdakileri yapabilirsiniz:

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

Sonuç bir listedir (NumPy dizisi değil) ve sayı, dize, her neyse ayrı ayrı konumların üzerine yazabilirsiniz.

kullanın:

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

Ben NumPy gitmek için bir yol olduğunu düşünüyorum. NumPy'yi kullanmak istemiyorsanız yukarıdaki genel bir işlemdir.

listeyi kullanarak:

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

dict kullanarak: bu bilgileri hızlı arama için karma tabloda da saklayabilirsiniz.

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

matris ['1'] size O (1) süresi ile sonuç verecektir

* nb : karma tablosundaki bir çarpışma ile başa çıkmanız gerekiyor

Başlamadan önce boyut bilginiz yoksa, iki adet tek boyutlu liste oluşturun.

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

Satırın tamamını 1. listede saklayın. Tamamlandığında, liste 1'i liste 2'ye ekleyin:

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

Çıktı:

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

Bu kısa ifadeye dikkat edin, @ FJ'nin cevabında tam açıklamaya bakın

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

Şundan daha hızlı olacak:

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

İki veya daha fazla köşeli parantez veya üçüncü köşeli parantezleri ( []virgülle ayrılmış olarak) tıpkı aşağıdaki gibi köşeli parantez içine yerleştirerek boş iki boyutlu bir liste oluşturabilirsiniz :

Matrix = [[], []]

Şimdi şunu Matrix[0][0]yazın 1 eklemek istediğinizi varsayalım :

Matrix[0].append(1)

Şimdi Matrix yazın ve Enter tuşuna basın. Çıktı şöyle olacaktır:

[[1], []]

Bunu dene:

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

Önceden tanımlanmış sayılara sahip bir matrise ihtiyacınız varsa, aşağıdaki kodu kullanabilirsiniz:

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

Python'da bir matris oluşturmak için kod snippet'i:

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

Bir şey kaçırırsam lütfen önerin.