Acum eu sunt, folosind o listă, și așteptam ceva de genul:
verts = list (1000)
Ar trebui să folosesc matrice în loc?
Nu știu de ce toată lumea este oferindu-vă un timp de greu pentru dorința de a face acest lucru - există mai multe scenarii în cazul în care'd vreau o dimensiune fixă inițializează lista. Și tu'am dedus corect ca matrice sunt sensibil în aceste cazuri.
import array
verts=array.array('i',(0,)*1000)
Pentru non-pythonistas, la (0,)*1000
termenul este de a crea un tuplu care conține 1000 de zerouri. Virgula forțele python să recunoască (0)
ca un tuplu, în caz contrar acesta va fi evaluat ca fiind 0.
Am'am folosit un tuplu în loc de o listă, deoarece acestea sunt în general mai mici deasupra.
Una evidentă și probabil că nu eficient mod este
verts = [0 for x in range(1000)]
Rețineți că acest lucru poate fi extins pentru a 2-a dimensiune cu ușurință. De exemplu, pentru a obține o 10x100 "matrice" puteți face
verts = [[0 for x in range(100)] for y in range(10)]
Doresc să initalize o matrice de dimensiune fixă este un lucru perfect acceptabil pentru a face în orice limbaj de programare; e't ca programator vrea să pună o pauză declarație într-un timp(adevărat) buclă. Crede-mă, mai ales, dacă elementele sunt doar de gând să fie suprascrise, și nu doar adaugă/scade, așa cum este cazul multor algoritmi de programare dinamică, nu't doriți să mizerie în jurul cu append declarații și verificarea dacă elementul nu't a fost inițializat încă de pe acoperi (ca's o mulțime de cod domnilor).
Acest lucru va lucra pentru ceea ce programatorul încearcă să realizeze.
@Steve-a dat deja un răspuns bun la întrebarea ta:
verts = [None] * 1000
Avertisment: Ca @Joachim Wuttke a subliniat, lista trebuie să fie inițializat cu un element imuabil. [[]] * 1000
nu funcționează cum era de așteptat, pentru că veți obține o listă de 1000 de liste identice (similar cu o lista de 1000 de puncte de la aceeași listă în C). Imuabil obiecte, cum ar fi int, str, sau tuplu va face bine.
Redimensionarea liste este lent. Următoarele rezultate nu sunt foarte surprinzătoare:
>>> N = 10**6
>>> %timeit a = [None] * N
100 loops, best of 3: 7.41 ms per loop
>>> %timeit a = [None for x in xrange(N)]
10 loops, best of 3: 30 ms per loop
>>> %timeit a = [None for x in range(N)]
10 loops, best of 3: 67.7 ms per loop
>>> a = []
>>> %timeit for x in xrange(N): a.append(None)
10 loops, best of 3: 85.6 ms per loop
Dar redimensionarea nu este foarte lent, dacă nu't au liste foarte mari. În loc de inițializare listă cu un singur element (de exemplu, Nici unul
) și o lungime fixă, pentru a evita lista redimensionarea, tu ar trebui să ia în considerare utilizarea list comprehensions și direct umple lista cu valorile corecte. De exemplu:
>>> %timeit a = [x**2 for x in xrange(N)]
10 loops, best of 3: 109 ms per loop
>>> def fill_list1():
"""Not too bad, but complicated code"""
a = [None] * N
for x in xrange(N):
a[x] = x**2
>>> %timeit fill_list1()
10 loops, best of 3: 126 ms per loop
>>> def fill_list2():
"""This is slow, use only for small lists"""
a = []
for x in xrange(N):
a.append(x**2)
>>> %timeit fill_list2()
10 loops, best of 3: 177 ms per loop
Pentru mare set de date numpy sau alte optimizat biblioteci sunt mult mai rapide:
from numpy import ndarray, zeros
%timeit empty((N,))
1000000 loops, best of 3: 788 ns per loop
%timeit zeros((N,))
100 loops, best of 3: 3.56 ms per loop
Ai putea face acest lucru:
verts = lista(xrange(1000))
Asta ar da o lista de 1000 de elemente în dimensiunea și care se întâmplă să fie inițializate cu valori de la 0-999. Ca
Tu ar trebui să ia în considerare, folosind un dict` tip, în loc de pre-inițializat lista. Costul unui dicționar look-up este mic și comparabil cu costul de accesare arbitrare element de listă.
Și atunci când se utilizează o cartografiere te poate scrie:
aDict = {}
aDict[100] = fetchElement()
putElement(fetchElement(), fetchPosition(), aDict)
Și `putElement funcția poate stoca element de la orice poziție. Și dacă aveți nevoie pentru a verifica în cazul în care colecția conține elementul cel dat de indicele este mai Pythonic să scrie:
if anIndex in aDict:
print "cool!"
Decât:
if not myList[anIndex] is None:
print "cool!"
Deoarece aceasta din urmă presupune că nu real element din colecție pot fi "Nici unul". Și dacă se întâmplă asta - codul se poarta urat.
Și dacă ai nevoie cu disperare de performanță și care's de ce încercați să pre-a inițializa variabilele, și să scrie cel mai rapid codul posibil - schimba limba. Cel mai rapid cod poate't fi scris în Python. Ar trebui să încerci C în loc să-și pună în aplicare ambalaje pentru a apela dvs. de pre-inițializat și pre-compilat codul de Python.
Fără să știe mai multe despre domeniul problemei, l'e greu să-ți răspund la întrebare. Dacă nu sunteți sigur că aveți nevoie pentru a face ceva mai mult, pythonic mod de a inițializa o lista este:
verts = []
Sunt te văd, de fapt o problemă de performanță? Dacă este așa, ceea ce este o performanță strangulare? Don't să încerce să rezolve o problemă pe care nu't au. L's probabil ca performanta costa dinamic pentru a umple o serie de 1000 de elemente este complet irelevant pentru programul're într-adevăr încercarea de a scrie.
Matrice de clasă este util dacă lucrurile din lista ta sunt întotdeauna o să fie o anumită primitive de lungime fixă tip (de exemplu, char, int, float). Dar, nu't nevoie de pre-inițializare fie.