Python - สร้างรายการที่มีความจุเริ่มต้น

รหัสเช่นนี้มักจะเกิดขึ้น:

l = []
while foo:
    #baz
    l.append(bar)
    #qux

สิ่งนี้ช้ามากหากคุณกำลังจะผนวกองค์ประกอบหลายพันรายการไว้ในรายการของคุณเนื่องจากรายการจะต้องมีการปรับขนาดอย่างต่อเนื่องเพื่อให้พอดีกับองค์ประกอบใหม่

ใน Java คุณสามารถสร้าง ArrayList ด้วยความจุเริ่มต้น หากคุณมีความคิดว่ารายการของคุณจะใหญ่ขนาดไหนมันจะมีประสิทธิภาพมากขึ้น

ฉันเข้าใจว่ารหัสเช่นนี้มักจะถูกนำมารวมเข้ากับความเข้าใจในรายการอีกครั้ง ถ้าวนลูป for / while มีความซับซ้อนมากสิ่งนี้ไม่สามารถทำได้ มีอะไรที่เทียบเท่ากับโปรแกรมเมอร์ Python หรือไม่?

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

ผล (ประเมินแต่ละฟังก์ชั่น 144 ครั้งและระยะเวลาเฉลี่ย)

simple append 0.0102
pre-allocate  0.0098

ข้อสรุป มันแทบจะไม่สำคัญ

การเพิ่มประสิทธิภาพก่อนวัยอันควรเป็นรากของความชั่วร้ายทั้งหมด

รายการ Python ไม่มีการจัดสรรล่วงหน้าในตัว หากคุณต้องการทำรายการจริงๆและต้องการหลีกเลี่ยงค่าใช้จ่ายในการต่อท้าย (และคุณควรยืนยันว่าคุณทำ) คุณสามารถทำสิ่งนี้ได้:

l = [None] * 1000 # Make a list of 1000 None's
for i in xrange(1000):
    # baz
    l[i] = bar
    # qux

บางทีคุณสามารถหลีกเลี่ยงรายการโดยใช้ตัวสร้างแทน:

def my_things():
    while foo:
        #baz
        yield bar
        #qux

for thing in my_things():
    # do something with thing

ด้วยวิธีนี้รายการไม่ได้ถูกจัดเก็บไว้ในหน่วยความจำ แต่เพียงสร้างตามต้องการ

เวอร์ชั่นสั้น: ใช้

pre_allocated_list = [None] * size

เพื่อจัดสรรรายการล่วงหน้า (นั่นคือเพื่อให้สามารถระบุองค์ประกอบ 'ขนาด' ของรายการแทนที่จะค่อยๆสร้างรายการโดยผนวกท้าย) การดำเนินการนี้เร็วมากแม้ในรายการใหญ่ การจัดสรรออบเจ็กต์ใหม่ที่จะถูกกำหนดภายหลังให้กับรายการองค์ประกอบจะใช้เวลานานขึ้นและจะเป็นคอขวดในโปรแกรมของคุณ

รุ่นยาว:

ฉันคิดว่าควรคำนึงถึงเวลาในการเริ่มต้นด้วย เนื่องจากในทุก ๆ ไพ ธ อนเป็นการอ้างอิงมันไม่สำคัญว่าคุณจะตั้งค่าแต่ละองค์ประกอบเป็นไม่มีหรือบางสตริง - ไม่ว่าจะเป็นข้อมูลอ้างอิง แม้ว่าจะใช้เวลานานขึ้นหากคุณต้องการสร้างวัตถุใหม่สำหรับแต่ละองค์ประกอบเพื่ออ้างอิง

สำหรับ 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()

การประเมินผล:

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

อย่างที่คุณเห็นการสร้างรายการอ้างอิงขนาดใหญ่ไปยังวัตถุไม่มีตัวเดียวกันนั้นใช้เวลาน้อยมาก

การเตรียมหรือขยายใช้เวลานานขึ้น (ฉันไม่ได้เฉลี่ยอะไรเลย แต่หลังจากใช้งานไปสองสามครั้งฉันสามารถบอกคุณได้ว่าการขยายและต่อเติมใช้เวลาประมาณเดียวกัน)

การจัดสรรวัตถุใหม่สำหรับแต่ละองค์ประกอบ - นั่นคือสิ่งที่ต้องใช้เวลามากที่สุด และคำตอบของ S.Lott ก็ทำเช่นนั้น - จัดรูปแบบสตริงใหม่ทุกครั้ง ซึ่งไม่จำเป็นต้องใช้อย่างเคร่งครัด - หากคุณต้องการจัดสรรพื้นที่บางส่วนล่วงหน้าเพียงแค่สร้างรายการไม่มีจากนั้นกำหนดข้อมูลให้กับองค์ประกอบรายการที่ต้องการ วิธีใดก็ตามที่จะใช้เวลาในการสร้างข้อมูลมากกว่าที่จะผนวก / ขยายรายการไม่ว่าคุณจะสร้างในขณะที่สร้างรายการหรือหลังจากนั้น แต่ถ้าคุณต้องการรายการที่มีประชากรเบาบางการเริ่มต้นด้วยรายการไม่มีจะเร็วขึ้นแน่นอน

วิธี Pythonic สำหรับสิ่งนี้คือ:

x = [None] * numElements

หรือค่าเริ่มต้นใด ๆ ที่คุณต้องการจะเติมด้วยเช่น

bottles = [Beer()] * 99
sea = [Fish()] * many
vegetarianPizzas = [None] * peopleOrderingPizzaNotQuiche

[แก้ไข: ข้อแม้ Emptor[Beer()] * 99ไวยากรณ์สร้างหนึ่ง Beerแล้ว populates อาร์เรย์ 99 อ้างอิงถึงเช่นเดียวเดียวกัน]

วิธีการเริ่มต้นของ Python นั้นค่อนข้างมีประสิทธิภาพแม้ว่าประสิทธิภาพนั้นจะลดลงเมื่อคุณเพิ่มจำนวนองค์ประกอบ

เปรียบเทียบ

import time

class Timer(object):
    def __enter__(self):
        self.start = time.time()
        return self

    def __exit__(self, *args):
        end = time.time()
        secs = end - self.start
        msecs = secs * 1000  # millisecs
        print('%fms' % msecs)

Elements   = 100000
Iterations = 144

print('Elements: %d, Iterations: %d' % (Elements, Iterations))


def doAppend():
    result = []
    i = 0
    while i < Elements:
        result.append(i)
        i += 1

def doAllocate():
    result = [None] * Elements
    i = 0
    while i < Elements:
        result[i] = i
        i += 1

def doGenerator():
    return list(i for i in range(Elements))


def test(name, fn):
    print("%s: " % name, end="")
    with Timer() as t:
        x = 0
        while x < Iterations:
            fn()
            x += 1


test('doAppend', doAppend)
test('doAllocate', doAllocate)
test('doGenerator', doGenerator)

กับ

#include <vector>
typedef std::vector<unsigned int> Vec;

static const unsigned int Elements = 100000;
static const unsigned int Iterations = 144;

void doAppend()
{
    Vec v;
    for (unsigned int i = 0; i < Elements; ++i) {
        v.push_back(i);
    }
}

void doReserve()
{
    Vec v;
    v.reserve(Elements);
    for (unsigned int i = 0; i < Elements; ++i) {
        v.push_back(i);
    }
}

void doAllocate()
{
    Vec v;
    v.resize(Elements);
    for (unsigned int i = 0; i < Elements; ++i) {
        v[i] = i;
    }
}

#include <iostream>
#include <chrono>
using namespace std;

void test(const char* name, void(*fn)(void))
{
    cout << name << ": ";

    auto start = chrono::high_resolution_clock::now();
    for (unsigned int i = 0; i < Iterations; ++i) {
        fn();
    }
    auto end = chrono::high_resolution_clock::now();

    auto elapsed = end - start;
    cout << chrono::duration<double, milli>(elapsed).count() << "ms\n";
}

int main()
{
    cout << "Elements: " << Elements << ", Iterations: " << Iterations << '\n';

    test("doAppend", doAppend);
    test("doReserve", doReserve);
    test("doAllocate", doAllocate);
}

ใน Windows 7 i7 ของฉัน Python 64 บิตให้

Elements: 100000, Iterations: 144
doAppend: 3587.204933ms
doAllocate: 2701.154947ms
doGenerator: 1721.098185ms

ขณะที่ C ++ ให้ (สร้างด้วย MSVC, 64- บิต, เปิดใช้งานการปรับให้เหมาะสมที่สุด)

Elements: 100000, Iterations: 144
doAppend: 74.0042ms
doReserve: 27.0015ms
doAllocate: 5.0003ms

สร้างการดีบัก C ++:

Elements: 100000, Iterations: 144
doAppend: 2166.12ms
doReserve: 2082.12ms
doAllocate: 273.016ms

ประเด็นก็คือเมื่อใช้ Python คุณจะสามารถปรับปรุงประสิทธิภาพได้ 7-8% และถ้าคุณคิดว่าคุณกำลังเขียนแอพที่มีประสิทธิภาพสูง (หรือถ้าคุณกำลังเขียนสิ่งที่ใช้ในบริการเว็บหรืออะไรก็ตาม) ที่ไม่ควรสูดดม แต่คุณอาจต้องคิดใหม่เกี่ยวกับภาษาที่คุณเลือก

นอกจากนี้รหัส Python ที่นี่ไม่ใช่รหัส Python จริงๆ การเปลี่ยนเป็นรหัส Pythonesque อย่างแท้จริงให้ประสิทธิภาพที่ดีกว่า:

import time

class Timer(object):
    def __enter__(self):
        self.start = time.time()
        return self

    def __exit__(self, *args):
        end = time.time()
        secs = end - self.start
        msecs = secs * 1000  # millisecs
        print('%fms' % msecs)

Elements   = 100000
Iterations = 144

print('Elements: %d, Iterations: %d' % (Elements, Iterations))


def doAppend():
    for x in range(Iterations):
        result = []
        for i in range(Elements):
            result.append(i)

def doAllocate():
    for x in range(Iterations):
        result = [None] * Elements
        for i in range(Elements):
            result[i] = i

def doGenerator():
    for x in range(Iterations):
        result = list(i for i in range(Elements))


def test(name, fn):
    print("%s: " % name, end="")
    with Timer() as t:
        fn()


test('doAppend', doAppend)
test('doAllocate', doAllocate)
test('doGenerator', doGenerator)

ซึ่งจะช่วยให้

Elements: 100000, Iterations: 144
doAppend: 2153.122902ms
doAllocate: 1346.076965ms
doGenerator: 1614.092112ms

(ใน doGenerator แบบ 32 บิตทำได้ดีกว่า doAllocate)

ที่นี่ช่องว่างระหว่าง doAppend และ doAllocate มีขนาดใหญ่กว่าอย่างมาก

เห็นได้ชัดว่าความแตกต่างที่นี่มีผลเฉพาะเมื่อคุณทำสิ่งนี้มากกว่าหนึ่งครั้งหรือหากคุณกำลังทำสิ่งนี้บนระบบที่มีการโหลดจำนวนมากซึ่งตัวเลขเหล่านั้นจะถูกลดขนาดโดยคำสั่งของขนาดหรือถ้าคุณกำลังติดต่อกับ รายการที่มีขนาดใหญ่มาก

จุดที่นี่: ทำมันด้วยวิธีไพทอนเพื่อประสิทธิภาพที่ดีที่สุด

แต่ถ้าคุณกังวลเรื่องประสิทธิภาพทั่วไปในระดับสูง Python เป็นภาษาที่ผิด ปัญหาพื้นฐานที่สุดคือการเรียกใช้ฟังก์ชั่นของ Python นั้นช้ากว่าภาษาอื่นถึง 300x เนื่องจากคุณสมบัติของ Python เช่น decorators etc ( https://wiki.python.org/moin/PythonSpeed/PerformanceTips#Data_Aggregation#Data_Aggregation )

ดังที่คนอื่น ๆ พูดถึงวิธีที่ง่ายที่สุดในการเตรียมรายการของNoneTypeวัตถุไว้ล่วงหน้า

ดังที่ได้กล่าวไปแล้วคุณควรเข้าใจวิธีการที่รายการ Python ใช้งานได้จริงก่อนที่จะตัดสินใจเลือกสิ่งนี้ ในการใช้งาน CPython ของรายการอาร์เรย์พื้นฐานจะถูกสร้างขึ้นพร้อมกับห้องที่มีขนาดใหญ่ขึ้นเรื่อย ๆ ในขนาดที่ใหญ่ขึ้นเรื่อย( 4, 8, 16, 25, 35, 46, 58, 72, 88, 106, 126, 148, 173, 201, 233, 269, 309, 354, 405, 462, 526, 598, 679, 771, 874, 990, 1120, etc)ๆ ดังนั้นการปรับขนาดรายการจะไม่เกิดขึ้นบ่อยนัก

เพราะพฤติกรรมนี้มากที่สุด list.append()ฟังก์ชั่นที่มีความซับซ้อนสำหรับการผนวกเพียงมีความซับซ้อนเพิ่มขึ้นเมื่อข้ามหนึ่งในขอบเขตเหล่านี้จุดที่ซับซ้อนจะเป็นO(1) O(n)พฤติกรรมนี้เป็นสิ่งที่นำไปสู่การเพิ่มขึ้นเล็กน้อยในเวลาดำเนินการในคำตอบของ S. Lott

ที่มา: http://www.laurentluce.com/posts/python-list-implementation/

ฉันรันโค้ดของ @ s.lott และสร้างการเพิ่มขึ้น 10% เหมือนกันโดยการจัดสรรล่วงหน้า ลองใช้ความคิดของ @ jeremy โดยใช้เครื่องกำเนิดไฟฟ้าและสามารถเห็นความสมบูรณ์แบบของยีนได้ดีกว่าของ doAllocate สำหรับโครงการของฉันมีการปรับปรุง 10% ดังนั้นขอขอบคุณทุกคนเพราะนี่เป็นประโยชน์

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

def doGen( size=10000 ):
    return list("some unique object %d" % ( i, ) for i in xrange(size))

size=1000
@print_timing
def testAppend():
    for i in xrange(size):
        doAppend()

@print_timing
def testAlloc():
    for i in xrange(size):
        doAllocate()

@print_timing
def testGen():
    for i in xrange(size):
        doGen()


testAppend()
testAlloc()
testGen()

testAppend took 14440.000ms
testAlloc took 13580.000ms
testGen took 13430.000ms

ความกังวลเกี่ยวกับการจัดสรรล่วงหน้าใน Python เกิดขึ้นหากคุณทำงานกับ numpy ซึ่งมีอาร์เรย์เหมือน C มากขึ้น ในอินสแตนซ์นี้การจัดสรรล่วงหน้าเกี่ยวข้องกับรูปร่างของข้อมูลและค่าเริ่มต้น

พิจารณาจำนวนมากหากคุณทำการคำนวณเชิงตัวเลขกับรายการจำนวนมากและต้องการประสิทธิภาพ

สำหรับบางแอปพลิเคชันพจนานุกรมอาจเป็นสิ่งที่คุณกำลังมองหา ตัวอย่างเช่นในวิธี find_totient ฉันพบว่าการใช้พจนานุกรมสะดวกกว่าเพราะไม่มีดัชนีเป็นศูนย์

def totient(n):
    totient = 0

    if n == 1:
        totient = 1
    else:
        for i in range(1, n):
            if math.gcd(i, n) == 1:
                totient += 1
    return totient

def find_totients(max):
    totients = dict()
    for i in range(1,max+1):
        totients[i] = totient(i)

    print('Totients:')
    for i in range(1,max+1):
        print(i,totients[i])

ปัญหานี้สามารถแก้ไขได้ด้วยรายการที่จัดสรรล่วงหน้า:

def find_totients(max):
    totients = None*(max+1)
    for i in range(1,max+1):
        totients[i] = totient(i)

    print('Totients:')
    for i in range(1,max+1):
        print(i,totients[i])

ฉันรู้สึกว่านี่ไม่ได้สง่างามและมีแนวโน้มที่จะเป็นแมลงเพราะฉันเก็บไม่มีใครสามารถยกเว้นถ้าฉันใช้พวกเขาผิดโดยไม่ได้ตั้งใจและเพราะฉันต้องคิดเกี่ยวกับกรณีขอบที่แผนที่ให้ฉันหลีกเลี่ยง

เป็นความจริงที่พจนานุกรมจะไม่มีประสิทธิภาพ แต่อย่างที่คนอื่น ๆ ได้แสดงความคิดเห็นความแตกต่างเล็ก ๆ ของความเร็วนั้นไม่คุ้มกับการบำรุงรักษาที่สำคัญ

จากสิ่งที่ฉันเข้าใจรายการหลามนั้นค่อนข้างคล้ายกับ ArrayLists แต่ถ้าคุณต้องการปรับเปลี่ยนพารามิเตอร์เหล่านั้นฉันพบโพสต์นี้ในเน็ตที่น่าสนใจ (โดยทั่วไปเพียงแค่สร้างScalableListส่วนขยายของคุณเอง):

http://mail.python.org/pipermail/python-list/2000-May/035082.html