像這樣的代碼經(jīng)常發(fā)生：l = []while foo: #baz l.append(bar) #qux如果您要將數(shù)千個(gè)元素追加到列表中，這非常慢，因?yàn)楸仨毑粩嗾{(diào)整列表大小以適應(yīng)新元素。在Java中，您可以創(chuàng)建具有初始容量的ArrayList。如果您對(duì)列表的大小有所了解，那么效率會(huì)更高。我知道像這樣的代碼通?？梢灾匦驴紤]到列表理解中。但是，如果for / while循環(huán)非常復(fù)雜，那么這是不可行的。我們的Python程序員有沒(méi)有相同的東西？
3 回答
偶然的你
TA貢獻(xiàn)1841條經(jīng)驗(yàn) 獲得超3個(gè)贊
def doAppend( size=10000 ):
result = []
for i in range(size):
message= "some unique object %d" % ( i, )
result.append(message)
return result
def doAllocate( size=10000 ):
result=size*[None]
for i in range(size):
message= "some unique object %d" % ( i, )
result[i]= message
return result
結(jié)果。（評(píng)估每個(gè)功能144次并平均持續(xù)時(shí)間）
simple append 0.0102
pre-allocate 0.0098
結(jié)論。這幾乎不重要。
過(guò)早優(yōu)化是萬(wàn)惡之源。
慕沐林林
TA貢獻(xiàn)2016條經(jīng)驗(yàn) 獲得超9個(gè)贊
簡(jiǎn)短版：使用
pre_allocated_list = [None] * size
預(yù)先分配一個(gè)列表（即，能夠解決列表的'size'元素，而不是通過(guò)附加逐漸形成列表）。即使在大型列表中，此操作也非常快。分配稍后將分配給列表元素的新對(duì)象將花費(fèi)更長(zhǎng)時(shí)間，并且將成為程序中的瓶頸，性能方面。
長(zhǎng)版：
我認(rèn)為應(yīng)該考慮初始化時(shí)間。因?yàn)樵趐ython中，一切都是引用，無(wú)論你是將每個(gè)元素設(shè)置為None還是一些字符串都無(wú)關(guān)緊要 - 無(wú)論哪種方式，它都只是一個(gè)引用。如果要為每個(gè)要引用的元素創(chuàng)建新對(duì)象，則需要更長(zhǎng)的時(shí)間。
對(duì)于Python 3.2：
import time
import copy
def print_timing (func):
def wrapper (*arg):
t1 = time.time ()
res = func (*arg)
t2 = time.time ()
print ("{} took {} ms".format (func.__name__, (t2 - t1) * 1000.0))
return res
return wrapper
@print_timing
def prealloc_array (size, init = None, cp = True, cpmethod=copy.deepcopy, cpargs=(), use_num = False):
result = [None] * size
if init is not None:
if cp:
for i in range (size):
result[i] = init
else:
if use_num:
for i in range (size):
result[i] = cpmethod (i)
else:
for i in range (size):
result[i] = cpmethod (cpargs)
return result
@print_timing
def prealloc_array_by_appending (size):
result = []
for i in range (size):
result.append (None)
return result
@print_timing
def prealloc_array_by_extending (size):
result = []
none_list = [None]
for i in range (size):
result.extend (none_list)
return result
def main ():
n = 1000000
x = prealloc_array_by_appending(n)
y = prealloc_array_by_extending(n)
a = prealloc_array(n, None)
b = prealloc_array(n, "content", True)
c = prealloc_array(n, "content", False, "some object {}".format, ("blah"), False)
d = prealloc_array(n, "content", False, "some object {}".format, None, True)
e = prealloc_array(n, "content", False, copy.deepcopy, "a", False)
f = prealloc_array(n, "content", False, copy.deepcopy, (), False)
g = prealloc_array(n, "content", False, copy.deepcopy, [], False)
print ("x[5] = {}".format (x[5]))
print ("y[5] = {}".format (y[5]))
print ("a[5] = {}".format (a[5]))
print ("b[5] = {}".format (b[5]))
print ("c[5] = {}".format (c[5]))
print ("d[5] = {}".format (d[5]))
print ("e[5] = {}".format (e[5]))
print ("f[5] = {}".format (f[5]))
print ("g[5] = {}".format (g[5]))
if __name__ == '__main__':
main()
評(píng)價(jià)：
prealloc_array_by_appending took 118.00003051757812 ms
prealloc_array_by_extending took 102.99992561340332 ms
prealloc_array took 3.000020980834961 ms
prealloc_array took 49.00002479553223 ms
prealloc_array took 316.9999122619629 ms
prealloc_array took 473.00004959106445 ms
prealloc_array took 1677.9999732971191 ms
prealloc_array took 2729.999780654907 ms
prealloc_array took 3001.999855041504 ms
x[5] = None
y[5] = None
a[5] = None
b[5] = content
c[5] = some object blah
d[5] = some object 5
e[5] = a
f[5] = []
g[5] = ()
正如您所看到的，只需創(chuàng)建一個(gè)對(duì)同一None對(duì)象的引用的大列表，只需要很少的時(shí)間。
前置或延長(zhǎng)需要更長(zhǎng)的時(shí)間（我沒(méi)有做任何平均值，但是在運(yùn)行幾次后我可以告訴你，延伸和追加大致需要相同的時(shí)間）。
為每個(gè)元素分配新對(duì)象 - 這是花費(fèi)最多時(shí)間的。而S.Lott的答案就是這樣 - 每次都會(huì)格式化一個(gè)新的字符串。這不是嚴(yán)格要求的 - 如果您想預(yù)先分配一些空間，只需創(chuàng)建一個(gè)None列表，然后隨意將數(shù)據(jù)分配給列表元素。無(wú)論哪種方式，生成數(shù)據(jù)都需要花費(fèi)更多時(shí)間而不是追加/擴(kuò)展列表，無(wú)論是在創(chuàng)建列表時(shí)生成還是在生成列表之后生成數(shù)據(jù)。但是如果你想要一個(gè)人口稀少的列表，那么從None列表開(kāi)始肯定會(huì)更快。
添加回答
舉報(bào)
0/150
提交
取消