Create a list with initial capacity in Python

Question

Code like this often happens  l      while foo        baz     l append bar        qux  This is really slow if you re about to append thousands of elements to your list  as the list will have to be constantly resized to fit the new elements  In Java  you can create an ArrayList with an initial capacity  If you have some idea how big your list will be  this will be a lot more efficient  I understand that code like this can often be refactored into a list comprehension  If the for while loop is very complicated  though  this is unfeasible  Is there an equivalent for us Python programmers

User · Answer

Python lists have no built-in pre-allocation. If you really need to make a list, and need to avoid the overhead of appending (and you should verify that you do), you can do this:

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

Perhaps you could avoid the list by using a generator instead:

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

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

This way, the list isn't every stored all in memory at all, merely generated as needed.

User · Answer

I ran S Lott s code and produced the same 10  performance increase by preallocating  I tried Ned Batchelder s idea using a generator and was able to see the performance of the generator better than that of the doAllocate  For my project the 10  improvement matters  so thanks to everyone as this helps a bunch  def doAppend size 10000       result          for i in range size           message    quot some unique object  d quot      i            result append message      return result  def doAllocate size 10000       result   size  None      for i in range size           message    quot some unique object  d quot      i            result i    message     return result  def doGen size 10000       return list  quot some unique object  d quot      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    Output testAppend took 14440 000ms testAlloc took 13580 000ms testGen took 13430 000ms

User · Answer

Python lists have no built-in pre-allocation. If you really need to make a list, and need to avoid the overhead of appending (and you should verify that you do), you can do this:

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

Perhaps you could avoid the list by using a generator instead:

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

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

This way, the list isn't every stored all in memory at all, merely generated as needed.

User · Answer

The Pythonic way for this is  x    None    numElements  Or whatever default value you wish to prepopulate with  e g  bottles    Beer      99 sea    Fish      many vegetarianPizzas    None    peopleOrderingPizzaNotQuiche   Caveat Emptor  The  Beer      99 syntax creates one Beer and then populates an array with 99 references to the same single instance  Python s default approach can be pretty efficient  although that efficiency decays as you increase the number of elements  Compare 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  lt  Elements          result append i          i    1  def doAllocate        result    None    Elements     i   0     while i  lt  Elements          result i    i         i    1  def doGenerator        return list i for i in range Elements     def test name  fn       print  quot  s   quot    name  end  quot  quot       with Timer   as t          x   0         while x  lt  Iterations              fn               x    1   test  doAppend   doAppend  test  doAllocate   doAllocate  test  doGenerator   doGenerator   with  include  lt vector gt  typedef std  vector lt unsigned int gt  Vec   static const unsigned int Elements   100000  static const unsigned int Iterations   144   void doAppend         Vec v      for  unsigned int i   0  i  lt  Elements    i            v push back i            void doReserve         Vec v      v reserve Elements       for  unsigned int i   0  i  lt  Elements    i            v push back i            void doAllocate         Vec v      v resize Elements       for  unsigned int i   0  i  lt  Elements    i            v i    i            include  lt iostream gt   include  lt chrono gt  using namespace std   void test const char  name  void  fn  void         cout  lt  lt  name  lt  lt   quot    quot        auto start   chrono  high resolution clock  now        for  unsigned int i   0  i  lt  Iterations    i            fn              auto end   chrono  high resolution clock  now         auto elapsed   end - start      cout  lt  lt  chrono  duration lt double  milli gt  elapsed  count    lt  lt   quot ms n quot      int main         cout  lt  lt   quot Elements   quot   lt  lt  Elements  lt  lt   quot   Iterations   quot   lt  lt  Iterations  lt  lt    n        test  quot doAppend quot   doAppend       test  quot doReserve quot   doReserve       test  quot doAllocate quot   doAllocate      On my Windows 7 Core  i7  64-bit Python gives Elements  100000  Iterations  144 doAppend  3587 204933ms doAllocate  2701 154947ms doGenerator  1721 098185ms  While C   gives  built with Microsoft Visual C    64-bit  optimizations enabled  Elements  100000  Iterations  144 doAppend  74 0042ms doReserve  27 0015ms doAllocate  5 0003ms  C   debug build produces  Elements  100000  Iterations  144 doAppend  2166 12ms doReserve  2082 12ms doAllocate  273 016ms  The point here is that with Python you can achieve a 7-8  performance improvement  and if you think you re writing a high-performance application  or if you re writing something that is used in a web service or something  then that isn t to be sniffed at  but you may need to rethink your choice of language  Also  the Python code here isn t really Python code  Switching to truly Pythonesque code here gives better performance  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  quot  s   quot    name  end  quot  quot       with Timer   as t          fn     test  doAppend   doAppend  test  doAllocate   doAllocate  test  doGenerator   doGenerator   Which gives Elements  100000  Iterations  144 doAppend  2153 122902ms doAllocate  1346 076965ms doGenerator  1614 092112ms   in 32-bit  doGenerator does better than doAllocate   Here the gap between doAppend and doAllocate is significantly larger  Obviously  the differences here really only apply if you are doing this more than a handful of times or if you are doing this on a heavily loaded system where those numbers are going to get scaled out by orders of magnitude  or if you are dealing with considerably larger lists  The point here  Do it the Pythonic way for the best performance  But if you are worrying about general  high-level performance  Python is the wrong language  The most fundamental problem being that Python function calls has traditionally been up to 300x slower than other languages due to Python features like decorators  etc   PythonSpeed PerformanceTips  Data Aggregation

User · Answer

Python lists have no built-in pre-allocation. If you really need to make a list, and need to avoid the overhead of appending (and you should verify that you do), you can do this:

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

Perhaps you could avoid the list by using a generator instead:

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

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

This way, the list isn't every stored all in memory at all, merely generated as needed.

User · Answer

Short version  use pre allocated list    None    size  to preallocate a list  that is  to be able to address  size  elements of the list instead of gradually forming the list by appending   This operation is very fast  even on big lists  Allocating new objects that will be later assigned to list elements will take much longer and will be the bottleneck in your program  performance-wise  Long version  I think that initialization time should be taken into account  Since in Python everything is a reference  it doesn t matter whether you set each element into None or some string - either way it s only a reference  Though it will take longer if you want to create a new object for each element to reference  For Python 3 2  import time import copy  def print timing  func     def wrapper   arg       t1   time time       res   func   arg      t2   time time        print   quot    took    ms quot  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   quot content quot   True    c   prealloc array n   quot content quot   False   quot some object    quot  format    quot blah quot    False    d   prealloc array n   quot content quot   False   quot some object    quot  format  None  True    e   prealloc array n   quot content quot   False  copy deepcopy   quot a quot   False    f   prealloc array n   quot content quot   False  copy deepcopy      False    g   prealloc array n   quot content quot   False  copy deepcopy      False     print   quot x 5       quot  format  x 5      print   quot y 5       quot  format  y 5      print   quot a 5       quot  format  a 5      print   quot b 5       quot  format  b 5      print   quot c 5       quot  format  c 5      print   quot d 5       quot  format  d 5      print   quot e 5       quot  format  e 5      print   quot f 5       quot  format  f 5      print   quot g 5       quot  format  g 5     if   name         main       main    Evaluation  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        As you can see  just making a big list of references to the same None object takes very little time  Prepending or extending takes longer  I didn t average anything  but after running this a few times I can tell you that extending and appending take roughly the same time   Allocating new object for each element - that is what takes the most time  And S Lott s answer does that - formats a new string every time  Which is not strictly required - if you want to preallocate some space  just make a list of None  then assign data to list elements at will  Either way it takes more time to generate data than to append extend a list  whether you generate it while creating the list  or after that  But if you want a sparsely-populated list  then starting with a list of None is definitely faster

User · Answer

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   Results   evaluate each function 144 times and average the duration   simple append 0 0102 pre-allocate  0 0098   Conclusion   It barely matters     Premature optimization is the root of all evil

User · Answer

I ran S Lott s code and produced the same 10  performance increase by preallocating  I tried Ned Batchelder s idea using a generator and was able to see the performance of the generator better than that of the doAllocate  For my project the 10  improvement matters  so thanks to everyone as this helps a bunch  def doAppend size 10000       result          for i in range size           message    quot some unique object  d quot      i            result append message      return result  def doAllocate size 10000       result   size  None      for i in range size           message    quot some unique object  d quot      i            result i    message     return result  def doGen size 10000       return list  quot some unique object  d quot      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    Output testAppend took 14440 000ms testAlloc took 13580 000ms testGen took 13430 000ms

User · Answer

Concerns about preallocation in Python arise if you re working with NumPy  which has more C-like arrays  In this instance  preallocation concerns are about the shape of the data and the default value  Consider NumPy if you re doing numerical computation on massive lists and want performance

User · Answer

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   Results   evaluate each function 144 times and average the duration   simple append 0 0102 pre-allocate  0 0098   Conclusion   It barely matters     Premature optimization is the root of all evil

User · Answer

Short version  use pre allocated list    None    size  to preallocate a list  that is  to be able to address  size  elements of the list instead of gradually forming the list by appending   This operation is very fast  even on big lists  Allocating new objects that will be later assigned to list elements will take much longer and will be the bottleneck in your program  performance-wise  Long version  I think that initialization time should be taken into account  Since in Python everything is a reference  it doesn t matter whether you set each element into None or some string - either way it s only a reference  Though it will take longer if you want to create a new object for each element to reference  For Python 3 2  import time import copy  def print timing  func     def wrapper   arg       t1   time time       res   func   arg      t2   time time        print   quot    took    ms quot  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   quot content quot   True    c   prealloc array n   quot content quot   False   quot some object    quot  format    quot blah quot    False    d   prealloc array n   quot content quot   False   quot some object    quot  format  None  True    e   prealloc array n   quot content quot   False  copy deepcopy   quot a quot   False    f   prealloc array n   quot content quot   False  copy deepcopy      False    g   prealloc array n   quot content quot   False  copy deepcopy      False     print   quot x 5       quot  format  x 5      print   quot y 5       quot  format  y 5      print   quot a 5       quot  format  a 5      print   quot b 5       quot  format  b 5      print   quot c 5       quot  format  c 5      print   quot d 5       quot  format  d 5      print   quot e 5       quot  format  e 5      print   quot f 5       quot  format  f 5      print   quot g 5       quot  format  g 5     if   name         main       main    Evaluation  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        As you can see  just making a big list of references to the same None object takes very little time  Prepending or extending takes longer  I didn t average anything  but after running this a few times I can tell you that extending and appending take roughly the same time   Allocating new object for each element - that is what takes the most time  And S Lott s answer does that - formats a new string every time  Which is not strictly required - if you want to preallocate some space  just make a list of None  then assign data to list elements at will  Either way it takes more time to generate data than to append extend a list  whether you generate it while creating the list  or after that  But if you want a sparsely-populated list  then starting with a list of None is definitely faster

User · Answer

From what I understand  Python lists are already quite similar to ArrayLists  But if you want to tweak those parameters I found this post on the Internet that may be interesting  basically  just create your own ScalableList extension   http   mail python org pipermail python-list 2000-May 035082 html

User · Answer

For some applications  a dictionary may be what you are looking for   For example  in the find totient method  I found it more convenient to use a dictionary since I didn t have a zero index   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     This problem could also be solved with a preallocated list   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     I feel that this is not as elegant and prone to bugs because I m storing None which could throw an exception if I accidentally use them wrong  and because I need to think about edge cases that the map lets me avoid   It s true the dictionary won t be as efficient  but as others have commented  small differences in speed are not always worth significant maintenance hazards

User · Answer

Concerns about preallocation in Python arise if you re working with NumPy  which has more C-like arrays  In this instance  preallocation concerns are about the shape of the data and the default value  Consider NumPy if you re doing numerical computation on massive lists and want performance

User · Answer

As others have mentioned  the simplest way to preseed a list is with NoneType objects  That being said  you should understand the way Python lists actually work before deciding this is necessary  In the CPython implementation of a list  the underlying array is always created with overhead room  in progressively larger sizes   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   so that resizing the list does not happen nearly so often  Because of this behavior  most list append   functions are O 1  complexity for appends  only having increased complexity when crossing one of these boundaries  at which point the complexity will be O n   This behavior is what leads to the minimal increase in execution time in S Lott s answer  Source  Python list implementation

User · Answer

Python lists have no built-in pre-allocation. If you really need to make a list, and need to avoid the overhead of appending (and you should verify that you do), you can do this:

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

Perhaps you could avoid the list by using a generator instead:

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

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

This way, the list isn't every stored all in memory at all, merely generated as needed.

User · Answer

For some applications  a dictionary may be what you are looking for   For example  in the find totient method  I found it more convenient to use a dictionary since I didn t have a zero index   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     This problem could also be solved with a preallocated list   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     I feel that this is not as elegant and prone to bugs because I m storing None which could throw an exception if I accidentally use them wrong  and because I need to think about edge cases that the map lets me avoid   It s true the dictionary won t be as efficient  but as others have commented  small differences in speed are not always worth significant maintenance hazards

User · Answer

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   Results   evaluate each function 144 times and average the duration   simple append 0 0102 pre-allocate  0 0098   Conclusion   It barely matters     Premature optimization is the root of all evil

User · Answer

The Pythonic way for this is  x    None    numElements  Or whatever default value you wish to prepopulate with  e g  bottles    Beer      99 sea    Fish      many vegetarianPizzas    None    peopleOrderingPizzaNotQuiche   Caveat Emptor  The  Beer      99 syntax creates one Beer and then populates an array with 99 references to the same single instance  Python s default approach can be pretty efficient  although that efficiency decays as you increase the number of elements  Compare 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  lt  Elements          result append i          i    1  def doAllocate        result    None    Elements     i   0     while i  lt  Elements          result i    i         i    1  def doGenerator        return list i for i in range Elements     def test name  fn       print  quot  s   quot    name  end  quot  quot       with Timer   as t          x   0         while x  lt  Iterations              fn               x    1   test  doAppend   doAppend  test  doAllocate   doAllocate  test  doGenerator   doGenerator   with  include  lt vector gt  typedef std  vector lt unsigned int gt  Vec   static const unsigned int Elements   100000  static const unsigned int Iterations   144   void doAppend         Vec v      for  unsigned int i   0  i  lt  Elements    i            v push back i            void doReserve         Vec v      v reserve Elements       for  unsigned int i   0  i  lt  Elements    i            v push back i            void doAllocate         Vec v      v resize Elements       for  unsigned int i   0  i  lt  Elements    i            v i    i            include  lt iostream gt   include  lt chrono gt  using namespace std   void test const char  name  void  fn  void         cout  lt  lt  name  lt  lt   quot    quot        auto start   chrono  high resolution clock  now        for  unsigned int i   0  i  lt  Iterations    i            fn              auto end   chrono  high resolution clock  now         auto elapsed   end - start      cout  lt  lt  chrono  duration lt double  milli gt  elapsed  count    lt  lt   quot ms n quot      int main         cout  lt  lt   quot Elements   quot   lt  lt  Elements  lt  lt   quot   Iterations   quot   lt  lt  Iterations  lt  lt    n        test  quot doAppend quot   doAppend       test  quot doReserve quot   doReserve       test  quot doAllocate quot   doAllocate      On my Windows 7 Core  i7  64-bit Python gives Elements  100000  Iterations  144 doAppend  3587 204933ms doAllocate  2701 154947ms doGenerator  1721 098185ms  While C   gives  built with Microsoft Visual C    64-bit  optimizations enabled  Elements  100000  Iterations  144 doAppend  74 0042ms doReserve  27 0015ms doAllocate  5 0003ms  C   debug build produces  Elements  100000  Iterations  144 doAppend  2166 12ms doReserve  2082 12ms doAllocate  273 016ms  The point here is that with Python you can achieve a 7-8  performance improvement  and if you think you re writing a high-performance application  or if you re writing something that is used in a web service or something  then that isn t to be sniffed at  but you may need to rethink your choice of language  Also  the Python code here isn t really Python code  Switching to truly Pythonesque code here gives better performance  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  quot  s   quot    name  end  quot  quot       with Timer   as t          fn     test  doAppend   doAppend  test  doAllocate   doAllocate  test  doGenerator   doGenerator   Which gives Elements  100000  Iterations  144 doAppend  2153 122902ms doAllocate  1346 076965ms doGenerator  1614 092112ms   in 32-bit  doGenerator does better than doAllocate   Here the gap between doAppend and doAllocate is significantly larger  Obviously  the differences here really only apply if you are doing this more than a handful of times or if you are doing this on a heavily loaded system where those numbers are going to get scaled out by orders of magnitude  or if you are dealing with considerably larger lists  The point here  Do it the Pythonic way for the best performance  But if you are worrying about general  high-level performance  Python is the wrong language  The most fundamental problem being that Python function calls has traditionally been up to 300x slower than other languages due to Python features like decorators  etc   PythonSpeed PerformanceTips  Data Aggregation

User · Answer

From what I understand  Python lists are already quite similar to ArrayLists  But if you want to tweak those parameters I found this post on the Internet that may be interesting  basically  just create your own ScalableList extension   http   mail python org pipermail python-list 2000-May 035082 html

User · Answer

As others have mentioned  the simplest way to preseed a list is with NoneType objects  That being said  you should understand the way Python lists actually work before deciding this is necessary  In the CPython implementation of a list  the underlying array is always created with overhead room  in progressively larger sizes   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   so that resizing the list does not happen nearly so often  Because of this behavior  most list append   functions are O 1  complexity for appends  only having increased complexity when crossing one of these boundaries  at which point the complexity will be O n   This behavior is what leads to the minimal increase in execution time in S Lott s answer  Source  Python list implementation

User · Answer

From what I understand  Python lists are already quite similar to ArrayLists  But if you want to tweak those parameters I found this post on the Internet that may be interesting  basically  just create your own ScalableList extension   http   mail python org pipermail python-list 2000-May 035082 html

User · Answer

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   Results   evaluate each function 144 times and average the duration   simple append 0 0102 pre-allocate  0 0098   Conclusion   It barely matters     Premature optimization is the root of all evil

User · Answer

From what I understand  Python lists are already quite similar to ArrayLists  But if you want to tweak those parameters I found this post on the Internet that may be interesting  basically  just create your own ScalableList extension   http   mail python org pipermail python-list 2000-May 035082 html

[python] Create a list with initial capacity in Python

Examples related to python

Examples related to list

Examples related to dictionary

Examples related to initialization