Ik wil een tweedimensionale array definiëren zonder een geïnitialiseerde lengte zoals deze:

Matrix = [][]

Maar het werkt niet …

Ik heb de onderstaande code geprobeerd, maar het is ook verkeerd:

Matrix = [5][5]

FOUT:

Traceback ...
IndexError: list index out of range

Wat is mijn fout?

Antwoord 1, Autoriteit 100%

U probeert technisch een niet-geïnitialiseerde array in te voegen. U moet eerst de buitenlijst met lijsten initialiseren voordat u artikelen toevoegt; Python noemt dit
“Lijst begrijpen”.

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

U kunt nu items toevoegen aan de lijst:

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

Merk op dat de matrix “y” -adres is, met andere woorden, de “y-index” komt vóór de “X-index”.

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

Hoewel u ze kunt noemen zoals u wilt, kijk ik deze op deze manier om wat verwarring te voorkomen die kan ontstaan ​​met de indexering, als u “X” gebruikt voor zowel de binnen- als de buitenlijsten, en een niet-vierkante matrix wil. .

Antwoord 2, Autoriteit 39%

Als u echt een matrix wilt, kunt u beter afsluiten met numpy. Matrix-operaties in numpyGebruik meestal een array-type met twee dimensies. Er zijn veel manieren om een ​​nieuwe array te maken; Een van de nuttigste is de zeros-functie, die een vormparameter neemt en een reeks van de gegeven vorm retourneert, met de waarden geïnitialiseerd naar nul:

>>> 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 zijn enkele andere manieren om 2-D-arrays en matrices te maken (met uitgang verwijderd voor compactheid):

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

numpyBiedt een matrixtype ook, maar het is Niet langer aanbevolen voor ELKE Gebruik en kan in de toekomst worden verwijderd van numpy.

Antwoord 3, Autoriteit 32%

Hier is een kortere notatie voor het initialiseren van een lijst met lijsten:

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

Helaas, dit inkorten tot iets als 5*[5*[0]]werkt niet echt omdat je uiteindelijk 5 exemplaren van dezelfde lijst krijgt, dus als je er een wijzigt, veranderen allemaal, bijvoorbeeld:

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

Antwoord 4, autoriteit 11%

Als u een lege matrix wilt maken, is de juiste syntaxis

matrix = [[]]

En als u een matrix van grootte 5 wilt genereren gevuld met 0,

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

Antwoord 5, autoriteit 7%

Als je alleen maar een tweedimensionale container wilt om enkele elementen te bevatten, kun je in plaats daarvan gemakkelijk een woordenboek gebruiken:

Matrix = {}

Dan kun je het volgende doen:

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

Dit werkt omdat 1,2een tuple is, en je gebruikt het als een sleutel om het woordenboek te indexeren. Het resultaat is vergelijkbaar met een domme schaarse matrix.

Zoals aangegeven door osa en Josap Valls, kunt u ook Matrix = collections.defaultdict(lambda:0)gebruiken zodat de ontbrekende elementen de standaardwaarde 0hebben .

Vatsal wijst er verder op dat deze methode waarschijnlijk niet erg efficiënt is voor grote matrices en alleen mag worden gebruikt in niet-prestatiekritieke delen van de code.

Antwoord 6, autoriteit 4%

In Python maak je een lijst met lijsten. U hoeft de afmetingen niet van tevoren aan te geven, maar dat kan wel. Bijvoorbeeld:

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

Nu matrix[0][0] == 2 en matrix[1][0] == 3. U kunt ook de syntaxis voor lijstbegrip gebruiken. In dit voorbeeld wordt het twee keer gebruikt om een “tweedimensionale lijst” op te bouwen:

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

Antwoord 7, autoriteit 2%

U zou een lijst met lijsten moeten maken en de beste manier is om geneste begrippen te gebruiken:

>>> 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 uw voorbeeld [5][5]maakt u een lijst met een geheel getal “5” erin en probeert u toegang te krijgen tot het 5e item, en dat levert natuurlijk een IndexError op omdat er geen 5e item:

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

Antwoord 8, autoriteit 2%

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)

Waarom zo’n lange code, dat ook in Pythonvraagt ​​u?

Lang terug toen ik niet comfortabel was met Python, zag ik de enkele regel antwoorden voor het schrijven van 2D-matrix en vertelde mezelf dat ik nog geen 2-D matrix in Python ga gebruiken. (Die enkele regels waren behoorlijk eng en het gaf me geen informatie over wat Python aan het doen was. Merk ook op dat ik niet op de hoogte ben van deze steno.)

Hoe dan ook, hier is de code voor een beginner waarvan het komt van C, CPP en Java-achtergrond

Notitie op Python Lovers and Experts: Stamp niet alleen omdat ik een gedetailleerde code schreef.

Antwoord 9, Autoriteit 2%

Het geaccepteerde antwoord is goed en correct, maar het kostte me een tijdje om te begrijpen dat ik het ook kon gebruiken om een ​​volledig lege array te maken.

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

resulteert in

[[], [], []]

Antwoord 10

Dit is hoe ik meestal 2D-arrays in Python maak.

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

Ik vind deze syntaxis eenvoudig te onthouden in vergelijking met het gebruik van twee voor loops in een lijstbegrip.

Antwoord 11

Gebruik:

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

De * 5 voor de eerste dimensie werkt omdat op dit niveau de gegevens onveranderlijk zijn.

Antwoord 12

een herschrijving voor eenvoudig lezen:

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

Antwoord 13

Om een ​​matrix van nullen (ones) te declareren:

numpy.zeros((x, y))

b.g

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

of
numpy.ones ((x, y))
b.g

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

Zelfs drie dimensies zijn mogelijk.
(http://www.astro.ufl.edu/~Warner/prog/ python.html see – & gt; multi-dimensionale arrays)

Antwoord 14

Ik sta op mijn eerste Python-script, en ik was een beetje in de war door het vierkant matrixvoorbeeld, dus ik hoop dat het onderstaande voorbeeld u zal helpen wat tijd te besparen:

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

zodat

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

Antwoord 15

Numpy gebruiken U kunt lege matrix als volgt initialiseren:

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

en later gegevens toevoegen als volgt:

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

Antwoord 16

U kunt een lege tweedimensionale lijst maken door twee of meer vierkante bracing of derde beugel te nestelen ([], gescheiden door komma) met een vierkant bracing, net als hieronder:

Matrix = [[], []]

Stel nu dat u 1 wilt toevoegen aan Matrix[0][0]dan typt u:

Matrix[0].append(1)

Typ Matrix nu en druk op Enter. De uitvoer is:

[[1], []]

Als u in plaats daarvan de volgende verklaring hebt ingevoerd

Matrix[1].append(1)

Dan zou de matrix

zijn

[[], [1]]

Antwoord 17

Dat is wat woordenboek is gemaakt voor!

matrix = {}

U kunt sleutels en waarden definiëren op twee manieren:

matrix[0,0] = value

of

matrix = { (0,0)  : value }

Resultaat:

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

Antwoord 18

Ik lees in door komma’s gescheiden bestanden als volgt:

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

De lijst “gegevens” is dan een lijst met lijsten met indexgegevens[rij][col]

Antwoord 19

Als je het als een 2D-array wilt zien in plaats van gedwongen te worden om te denken in termen van een lijst met lijsten (naar mijn mening veel natuurlijker), kun je het volgende doen:

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

Het resultaat is een lijst (geen NumPy-array), en je kunt de individuele posities overschrijven met getallen, strings, wat dan ook.

Antwoord 20

Gebruik:

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

Ik denk dat NumPy de juiste keuze is. Het bovenstaande is een algemene als u NumPy niet wilt gebruiken.

Antwoord 21

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

Wees voorzichtig met deze korte uitdrukking, zie de volledige uitleg in het antwoord van @F.J

Antwoord 22

door lijst te gebruiken:

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

Door DICT te gebruiken:
U kunt deze info ook opslaan in de Hash-tabel voor snel zoeken als

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’] geeft je resultaat in O (1) -tijd

* NB : u moet omgaan met een botsing in de Hash-tabel

Antwoord 23

Als u geen grootte-informatie hebt voordat u begint, maak dan twee eendimensionale lijsten.

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

Bewaar de hele rij in de 1e lijst. Eenmaal klaar, Lijst 1 toevoegen in de lijst 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

Uitgang:

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

Antwoord 24

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

is sneller dan:

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

Antwoord 25

Hier is het codefragment voor het maken van een 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=" ")

Stel alsjeblieft voor of ik iets heb gemist.

Antwoord 26

Probeer dit:

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

Antwoord 27

Als u een matrix met vooraf gedefinieerde getallen nodig heeft, kunt u de volgende code gebruiken:

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

Antwoord 28

Gebruikersdefinitiefunctie om Matrix in te voeren en af te drukken

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