Vreau să definesc un tablou bidimensional, fără o inițializat lungime astfel:
Matrix = [][]
dar nu merge...
Am'am incercat codul de mai jos, dar este greșit:
Matrix = [5][5]
Error:
Traceback ...
IndexError: list index out of range
Ce este greseala mea?
Te're din punct de vedere tehnic încearcă să indice o neinitializata matrice. În primul rând trebuie să inițializa exterior lista cu liste înainte de adăugarea de elemente; solicită acest Python "lista de înțelegere".
# 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
Rețineți că matricea a este "y" adresa majore, cu alte cuvinte, "y indicele de" vine înainte "x indicele".
print Matrix[0][0] # prints 1
x, y = 0, 6
print Matrix[x][y] # prints 3; be careful with indexing!
Deși le poți numi cum vrei, mă uit la ea în acest fel pentru a evita unele confuzii care ar putea apărea cu indexare, dacă utilizați "x" pentru interioare și exterioare liste, și vreau un non-Matrice pătrată.
Dacă vrei într-adevăr o matrice, s-ar putea fi mai bine folosind numpy
. Operațiunile de matrice în numpy cele mai multe ori folosesc un tip de matrice cu două dimensiuni. Există multe modalități de a crea o nouă gamă, una dintre cele mai utile este
zero` funcție, care ia o forma parametru și returnează o matrice de forma dată, cu valori inițializat la zero:
>>> 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
oferă o "matrice" tip la fel de bine. L's mai puțin frecvent utilizate, și unii oameni recomand folosind-o. Dar's util pentru persoanele care vin la `numpy din Matlab, și în alte contexte. Am crezut că am'd-l includă când ne-am're vorbesc despre matrici!
>>> numpy.matrix([[1, 2], [3, 4]])
matrix([[1, 2],
[3, 4]])
Aici sunt câteva alte modalități de a crea 2-d matrice și matrici (cu ieșire eliminat pentru compact):
numpy.matrix('1 2; 3 4') # use Matlab-style syntax
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.ndarray((5, 5)) # use the low-level constructor
Aici este o scurtă notație pentru inițializarea o listă de liste:
matrix = [[0]*5 for i in range(5)]
Din păcate scurtarea asta la ceva de genul5*[5*[0]]
nu't într-adevăr de lucru pentru că ajungi cu 5 exemplare din aceeași listă, astfel încât atunci când se modifică una dintre ele s-au schimbat, de exemplu:
>>> 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]]
Dacă tot ce vrei este un două dimensiuni container de a deține anumite elemente, ai putea convenabil de a utiliza un dicționar în loc:
Matrix = {}
Apoi, puteți face:
Matrix[1,2] = 15
print Matrix[1,2]
Acest lucru functioneaza pentru 1,2
este un tuplu, iar tu're folosind-o ca o cheie pentru indicele dicționar. Rezultatul este similar cu un prost matrice rară.
Cum este indicat de către osa și Josap Valls, puteți utiliza, de asemenea, Matricea a = colecții.defaultdict(lambda:0)
astfel încât elementele lipsă au o valoare implicită de "0".
Vatsal puncte suplimentare pe care această metodă este, probabil, nu foarte eficient pentru matrice mari și ar trebui să fie utilizate numai în performanță non-critice părți din cod.
În Python va fi crearea unei liste de liste. Nu trebuie să declare dimensiuni înainte de timp, dar puteți. De exemplu:
matrix = []
matrix.append([])
matrix.append([])
matrix[0].append(2)
matrix[1].append(3)
Acum matrix[0][0] == 2 și matricea[1][0] == 3. Puteți folosi, de asemenea, lista de înțelegere sintaxă. Acest exemplu folosește de două ori pentru a construi o "de două-dimensional lista":
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)]
Tu ar trebui să facă o listă de liste, și cel mai bun mod este de a utiliza imbricate comprehensions:
>>> 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]]
Pe `[5][5] de exemplu, creați o listă cu un număr întreg de "5" în interiorul, și să încerce să acceseze sale 5th element, și care în mod natural se ridică o eroare indexerror pentru că nu există nici 5 articol:
>>> 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)
De ce astfel de o lungă perioadă de cod, că prea în Python
ai cere?
Mult înapoi, atunci când am fost confortabil cu Python, am văzut o singură linie răspunsuri pentru scris matrice 2D și mi-am spus că nu sunt de gând să utilizeze 2-D matrice în Python din nou. (Aceste linii unice au fost destul de înfricoșător și n't da informații cu privire la ceea ce Python face. De asemenea, rețineți că nu sunt conștienți de aceste shorthands.)
Oricum, aici's codul pentru un începător în ale căror vine de la C, CPP și Java fundal
Notă pentru Python și Experți: vă Rugăm să nu voteze în jos doar pentru că am scris un cod detaliat.
Pentru a declara o matrice de zerouri (altele):
numpy.zeros((x, y))
de exemplu
>>> numpy.zeros((3, 5))
array([[ 0., 0., 0., 0., 0.],
[ 0., 0., 0., 0., 0.],
[ 0., 0., 0., 0., 0.]])
sau numpy.cele((x, y)) de exemplu
>>> np.ones((3, 5))
array([[ 1., 1., 1., 1., 1.],
[ 1., 1., 1., 1., 1.],
[ 1., 1., 1., 1., 1.]])
Chiar trei dimensiuni sunt posibile. (http://www.astro.ufl.edu/~warner/prog/python.html vezi --> matrice Multi-dimensionale)
O rescrie pentru o citire ușoară:
# 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)
Am'm pe primul meu script Python, și am fost un pic confuz de matrice pătrată, de exemplu, sper ca exemplul de mai jos vă va ajuta să economisiți timp:
# Creates a 2 x 5 matrix
Matrix = [[0 for y in xrange(5)] for x in xrange(2)]
așa că
Matrix[1][4] = 2 # Valid
Matrix[4][1] = 3 # IndexError: list index out of range
Acest lucru este cum am de obicei, a crea matrice 2D în python.
col = 3
row = 4
array = [[0] * col for _ in range(row)]
Am găsit această sintaxă ușor să vă amintiți în comparație cu folosind două pentru bucle la o listă de înțelegere.
Folosind NumPy puteți inițializa gol matrice astfel:
import numpy as np
mm = np.matrix([])
Și mai târziu adăugați date astfel:
mm = np.append(mm, [[1,2]], axis=1)
Dacă doriți să fie în măsură să-l cred ca o matrice 2D, mai degrabă decât să fie forțat să se gândească în termen de o listă de liste (mult mai natural în opinia mea), puteți face următoarele:
import numpy
Nx=3; Ny=4
my2Dlist= numpy.zeros((Nx,Ny)).tolist()
Rezultatul este o lista (nu este un NumPy matrice), și puteți suprascrie pozițiilor individuale cu numere, siruri de caractere, orice.
matrix = {}
Puteți defini taste și valori în două moduri:
matrix[0,0] = value
sau
matrix = { (0,0) : value }
Rezultatul:
[ value, value, value, value, value],
[ value, value, value, value, value],
...
Utilizare:
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
Cred NumPy este calea de a merge. De mai sus este unul generic, dacă nu't doriți să utilizați NumPy.
Dacă tu nu't au dimensiunea de informații înainte de a începe apoi creați două-dimensional liste.
lista 1: Pentru a stoca rânduri lista 2: Efective de două-dimensional matrice
Magazin întregul rând în 1 lista. Odată terminat, adăugați lista 1 lista 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
Ieșire:
Enter No Of Coordinates >4
[[522, 96], [378, 276], [349, 741], [238, 439]]