Ich möchte ein zweidimensionales Array ohne eine initialisierte Länge wie folgt definieren:

Matrix = [][]

aber es funktioniert nicht...

Ich habe den folgenden Code ausprobiert, aber er ist auch falsch:

Matrix = [5][5]

Error:

Traceback ...

IndexError: list index out of range

Was ist mein Fehler?

Sie versuchen technisch, ein nicht initialisiertes Array zu indizieren. Sie müssen zuerst die äußere Liste mit Listen initialisieren, bevor Sie Elemente hinzufügen. Python nennt dies "Listenverständnis".

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

Sie können der Liste jetzt Elemente hinzufügen:

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

Beachten Sie, dass die Matrix "y" -Adresse major ist, mit anderen Worten, der "y-Index" steht vor dem "x-Index".

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

Obwohl Sie sie nach Ihren Wünschen benennen können, sehe ich das so, um Verwirrung zu vermeiden, die bei der Indizierung auftreten kann, wenn Sie "x" sowohl für die innere als auch für die äußere Liste verwenden und eine nicht quadratische Matrix wünschen.

Wenn Sie wirklich eine Matrix wollen, ist es möglicherweise besser, sie zu verwenden numpy. Matrixoperationen verwenden numpymeistens einen Array-Typ mit zwei Dimensionen. Es gibt viele Möglichkeiten, ein neues Array zu erstellen. Eine der nützlichsten zerosFunktionen ist die Funktion, die einen Formparameter verwendet und ein Array der angegebenen Form mit den auf Null initialisierten Werten zurückgibt:

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

Hier sind einige andere Möglichkeiten, um 2D-Arrays und Matrizen zu erstellen (wobei die Ausgabe aus Gründen der Kompaktheit entfernt wurde):

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

numpystellt auch einen matrixTyp zur Verfügung, wird jedoch für keine Verwendung mehr empfohlen und kann in Zukunft entfernt werden.numpy

Hier ist eine kürzere Notation zum Initialisieren einer Liste von Listen:

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

Leider 5*[5*[0]]funktioniert es nicht wirklich, dies auf so etwas wie zu kürzen, da Sie am Ende 5 Kopien derselben Liste haben. Wenn Sie also eine davon ändern, ändern sich alle, zum Beispiel:

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

Wenn Sie eine leere Matrix erstellen möchten, lautet die korrekte Syntax

matrix = [[]]

Und wenn Sie eine Matrix der Größe 5 erzeugen möchten, die mit 0 gefüllt ist,

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

Wenn Sie nur einen zweidimensionalen Container für einige Elemente benötigen, können Sie stattdessen bequem ein Wörterbuch verwenden:

Matrix = {}

Dann können Sie tun:

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

Dies funktioniert, weil 1,2es sich um ein Tupel handelt und Sie es als Schlüssel zum Indizieren des Wörterbuchs verwenden. Das Ergebnis ähnelt einer dummen, spärlichen Matrix.

Wie von osa und Josap Valls angegeben, können Sie auch verwenden, Matrix = collections.defaultdict(lambda:0)damit die fehlenden Elemente den Standardwert von haben 0.

Vatsal weist ferner darauf hin, dass diese Methode für große Matrizen wahrscheinlich nicht sehr effizient ist und nur in nicht leistungskritischen Teilen des Codes verwendet werden sollte.

In Python erstellen Sie eine Liste von Listen. Sie müssen die Dimensionen nicht im Voraus deklarieren, können dies aber. Zum Beispiel:

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

Jetzt Matrix [0] [0] == 2 und Matrix [1] [0] == 3. Sie können auch die Syntax des Listenverständnisses verwenden. In diesem Beispiel wird es zweimal verwendet, um eine "zweidimensionale Liste" zu erstellen:

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

Die akzeptierte Antwort ist gut und richtig, aber ich habe eine Weile gebraucht, um zu verstehen, dass ich damit auch ein vollständig leeres Array erstellen kann.

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

führt zu

[[], [], []]

Sie sollten eine Liste mit Listen erstellen. Der beste Weg ist, verschachtelte Verständnisse zu verwenden:

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

In Ihrem [5][5]Beispiel erstellen Sie eine Liste mit einer Ganzzahl "5" und versuchen, auf das fünfte Element zuzugreifen. Dadurch wird natürlich ein IndexError ausgelöst, da kein fünftes Element vorhanden ist:

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

Warum so ein langer Code, den PythonSie auch fragen?

Vor langer Zeit, als ich mit Python nicht vertraut war, sah ich die einzeiligen Antworten zum Schreiben einer 2D-Matrix und sagte mir, dass ich in Python keine 2-D-Matrix mehr verwenden werde. (Diese einzelnen Zeilen waren ziemlich beängstigend und gaben mir keine Informationen darüber, was Python tat. Beachten Sie auch, dass mir diese Abkürzungen nicht bekannt sind.)

Hier ist der Code für Anfänger mit C-, CPP- und Java-Hintergrund

Hinweis für Python-Liebhaber und Experten: Bitte stimmen Sie nicht ab, nur weil ich einen detaillierten Code geschrieben habe.

Ein Umschreiben zum einfachen Lesen:

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

Verwenden:

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

Die * 5 für die erste Dimension funktioniert, da auf dieser Ebene die Daten unveränderlich sind.

So deklarieren Sie eine Matrix von Nullen (Einsen):

numpy.zeros((x, y))

z.B

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

oder numpy.ones ((x, y)) z

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

Es sind sogar drei Dimensionen möglich. ( http://www.astro.ufl.edu/~warner/prog/python.html siehe -> Mehrdimensionale Arrays)

So erstelle ich normalerweise 2D-Arrays in Python.

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

Ich finde diese Syntax leicht zu merken, verglichen mit der Verwendung von zwei for-Schleifen in einem Listenverständnis.

Ich bin in meinem ersten Python-Skript und war durch das Beispiel mit der quadratischen Matrix ein wenig verwirrt. Ich hoffe, das folgende Beispiel hilft Ihnen dabei, Zeit zu sparen:

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

damit

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

Mit NumPy können Sie eine leere Matrix wie folgt initialisieren:

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

Und später Daten wie folgt anhängen:

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

Ich habe in Kommas getrennte Dateien wie folgt gelesen:

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

Die Liste "Daten" ist dann eine Liste von Listen mit Indexdaten [Zeile] [Spalte]

Wenn Sie es als 2D-Array betrachten möchten, anstatt gezwungen zu sein, in Form einer Liste von Listen zu denken (meiner Meinung nach viel natürlicher), können Sie Folgendes tun:

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

Das Ergebnis ist eine Liste (kein NumPy-Array), und Sie können die einzelnen Positionen mit Zahlen, Zeichenfolgen usw. überschreiben.

Dafür ist das Wörterbuch gemacht!

matrix = {}

Sie können Schlüssel und Werte auf zwei Arten definieren:

matrix[0,0] = value

oder

matrix = { (0,0)  : value }

Ergebnis:

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

Verwenden:

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

Ich denke, NumPy ist der richtige Weg. Das Obige ist generisch, wenn Sie NumPy nicht verwenden möchten.

mit Liste:

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

Mit dict: Sie können diese Informationen auch in der Hash-Tabelle speichern, um schnell suchen zu können

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

Matrix ['1'] gibt Ihnen das Ergebnis in O (1) Zeit

* nb : Sie müssen sich mit einer Kollision in der Hash-Tabelle befassen

Wenn Sie vor dem Start keine Größeninformationen haben, erstellen Sie zwei eindimensionale Listen.

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

Speichern Sie die gesamte Zeile in der 1. Liste. Wenn Sie fertig sind, fügen Sie Liste 1 in Liste 2 ein:

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

Ausgabe:

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

Seien Sie vorsichtig mit diesem kurzen Ausdruck, siehe die vollständige Erklärung unten in der Antwort von @ FJ

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

Wird schneller sein als:

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

Sie können eine leere zweidimensionale Liste erstellen, indem Sie zwei oder mehr eckige Klammern oder dritte Klammern ( []durch Komma getrennt) mit einer quadratischen Klammer verschachteln , wie unten dargestellt:

Matrix = [[], []]

Angenommen, Sie möchten 1 anhängen und Matrix[0][0]dann Folgendes eingeben:

Matrix[0].append(1)

Geben Sie nun Matrix ein und drücken Sie die Eingabetaste. Die Ausgabe wird sein:

[[1], []]

Versuche dies:

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

Wenn Sie eine Matrix mit vordefinierten Zahlen benötigen, können Sie den folgenden Code verwenden:

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

Hier ist das Code-Snippet zum Erstellen einer Matrix in 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=" ")

Bitte schlagen Sie vor, wenn ich etwas verpasst habe.