Splitting a list into N parts of approximately equal length

Question

What is the best way to divide a list into roughly equal parts  For example  if the list has 7 elements and is split it into 2 parts  we want to get 3 elements in one part  and the other should have 4 elements   I m looking for something like even split L  n  that breaks L into n parts   def chunks L  n           Yield successive n-sized chunks from L              for i in range 0  len L   n           yield L i i n    The code above gives chunks of 3  rather than 3 chunks   I could simply transpose  iterate over this and take the first element of each column  call that part one  then take the second and put it in part two  etc   but that destroys the ordering of the items

User · Answer

This one provides chunks of length  lt   n     0  def   chunkify lst  n       num chunks   int math ceil len lst    float n    if n  lt  len lst  else 1     return  lst n i n  i 1   for i in range num chunks     for example   gt  gt  gt  chunkify range 11   3    0  1  2    3  4  5    6  7  8    9  10    gt  gt  gt  chunkify range 11   8    0  1  2  3  4  5  6  7    8  9  10

User · Answer

Changing the code to yield n chunks rather than chunks of n   def chunks l  n           Yield n successive chunks from l              newn   int len l    n      for i in xrange 0  n-1           yield l i newn i newn newn      yield l n newn-newn    l   range 56  three chunks   chunks  l  3  print three chunks next   print three chunks next   print three chunks next     which gives    0  1  2  3  4  5  6  7  8  9  10  11  12  13  14  15  16  17   18  19  20  21  22  23  24  25  26  27  28  29  30  31  32  33  34  35   36  37  38  39  40  41  42  43  44  45  46  47  48  49  50  51  52  53  54  55    This will assign the extra elements to the final group which is not perfect but well within your specification of  roughly N equal parts   -  By that  I mean 56 elements would be better as  19 19 18  whereas this gives  18 18 20    You can get the more balanced output with the following code      usr bin python def chunks l  n           Yield n successive chunks from l              newn   int 1 0   len l    n   0 5      for i in xrange 0  n-1           yield l i newn i newn newn      yield l n newn-newn    l   range 56  three chunks   chunks  l  3  print three chunks next   print three chunks next   print three chunks next     which outputs    0  1  2  3  4  5  6  7  8  9  10  11  12  13  14  15  16  17  18   19  20  21  22  23  24  25  26  27  28  29  30  31  32  33  34  35  36  37   38  39  40  41  42  43  44  45  46  47  48  49  50  51  52  53  54  55

User · Answer

this code works for me  Python3-compatible    def chunkify tab  num       return  tab i num  i num num  for i in range len tab   num  1 if len tab  num else 0      example  for bytearray type  but it works for lists as well    b   bytearray b  x01 x02 x03 x04 x05 x06 x07 x08    gt  gt  gt  chunkify b 3   bytearray b  x01 x02 x03    bytearray b  x04 x05 x06    bytearray b  x07 x08     gt  gt  gt  chunkify b 4   bytearray b  x01 x02 x03 x04    bytearray b  x05 x06 x07 x08

User · Answer

The same as job s answer  but takes into account lists with size smaller than the number of chuncks   def chunkify lst n         lst i  n  for i in xrange n if n  lt  len lst  else len lst       if n  number of chunks  is 7 and lst  the list to divide  is  1  2  3  the chunks are   0    1    2   instead of   0    1    2

User · Answer

Using list comprehension   def divide list to chunks list   n       return  list  start  n  for start in range n

User · Answer

I ve written code in this case myself   def chunk ports port start  port end  portions       if port end  lt  port start          return None      total   port end - port start   1      fractions   int math floor float total    portions        results             No enough to chuck      if fractions  lt  1          return None        Reverse  so any additional items would be in the first range       e   port end     for i in range portions  0  -1           print  i   i          if i    1               s   port start         else               s    e - fractions   1          results append   s   e             e    s - 1      results reverse        return results   divide ports 1  10  9  would return    1  2    3  3    4  4    5  5    6  6    7  7    8  8    9  9    10  10

User · Answer

This code is broken due to rounding errors  Do not use it     assert len chunkIt  1 2 3   10      10    fails     Here s one that could work   def chunkIt seq  num       avg   len seq    float num      out          last   0 0      while last  lt  len seq           out append seq int last  int last   avg            last    avg      return out   Testing    gt  gt  gt  chunkIt range 10   3    0  1  2    3  4  5    6  7  8  9    gt  gt  gt  chunkIt range 11   3    0  1  2    3  4  5  6    7  8  9  10    gt  gt  gt  chunkIt range 12   3    0  1  2  3    4  5  6  7    8  9  10  11

User · Answer

def evenly l  n       len    len l      split size   len     n     split size   n if not split size else split size     offsets    i for i in range 0  len   split size       return  l offset offset   split size  for offset in offsets    Example   l    a for a in range 97   should be consist of 10 parts  each have 9 elements except the last one   Output     0  1  2  3  4  5  6  7  8     9  10  11  12  13  14  15  16  17     18  19  20  21  22  23  24  25  26     27  28  29  30  31  32  33  34  35     36  37  38  39  40  41  42  43  44     45  46  47  48  49  50  51  52  53     54  55  56  57  58  59  60  61  62     63  64  65  66  67  68  69  70  71     72  73  74  75  76  77  78  79  80     81  82  83  84  85  86  87  88  89     90  91  92  93  94  95  96

User · Answer

Here is one that adds None to make the lists equal length   gt  gt  gt  from itertools import izip longest  gt  gt  gt  def chunks l  n           Yield n successive chunks from l  Pads extra spaces with None             return list zip  izip longest   iter l   n      gt  gt  gt  l range 54    gt  gt  gt  chunks l 3    0  3  6  9  12  15  18  21  24  27  30  33  36  39  42  45  48  51    1  4  7  10  13  16  19  22  25  28  31  34  37  40  43  46  49  52    2  5  8  11  14  17  20  23  26  29  32  35  38  41  44  47  50  53     gt  gt  gt  chunks l 4    0  4  8  12  16  20  24  28  32  36  40  44  48  52    1  5  9  13  17  21  25  29  33  37  41  45  49  53    2  6  10  14  18  22  26  30  34  38  42  46  50  None    3  7  11  15  19  23  27  31  35  39  43  47  51  None     gt  gt  gt  chunks l 5    0  5  10  15  20  25  30  35  40  45  50    1  6  11  16  21  26  31  36  41  46  51    2  7  12  17  22  27  32  37  42  47  52    3  8  13  18  23  28  33  38  43  48  53    4  9  14  19  24  29  34  39  44  49  None

User · Answer

Rounding the linspace and using it as an index is an easier solution than what amit12690 proposes   function chunks chunkit array num   index   round linspace 0 size array 2  num 1     chunks   cell 1 num    for x   1 num chunks x    array   index x  1 index x 1    end end

User · Answer

If you divide n elements into roughly k chunks you can make n   k chunks 1 element bigger than the other chunks to distribute the extra elements    The following code will give you the length for the chunks     n    k     1 if i  lt   n   k  else 0  for i in range k     Example  n 11  k 3 results in  4  4  3   You can then easily calculate the start indizes for the chunks    i    n    k    min i  n   k  for i in range k     Example  n 11  k 3 results in  0  4  8   Using the i 1th chunk as the boundary we get that the ith chunk of list l with len n is  l i    n    k    min i  n   k   i 1     n    k    min i 1  n   k     As a final step create a list from all the chunks using list comprehension    l i    n    k    min i  n   k   i 1     n    k    min i 1  n   k   for i in range k     Example  n 11  k 3  l range n  results in  range 0  4   range 4  8   range 8  11

User · Answer

You could also use    split lambda x n  x if not x else  x  n    split    if not - len x -n  else x - len x -n    n   0   split  1 2 3 4 5 6 7 8 9  2     1  2    3  4    5  6    7  8    9

User · Answer

Here s a generator that can handle any positive  integer  number of chunks  If the number of chunks is greater than the input list length some chunks will be empty  This algorithm alternates between short and long chunks rather than segregating them   I ve also included some code for testing the ragged chunks function       Split a list into  ragged  chunks      The size of each chunk is either the floor or ceiling of len seq    chunks      chunks can be  gt  len seq   in which case there will be empty chunks      Written by PM 2Ring 2017 03 30      def ragged chunks seq  chunks       size   len seq      start   0     for i in range 1  chunks   1           stop   i   size    chunks         yield seq start stop          start   stop    test  def test ragged chunks maxsize       for size in range 0  maxsize           seq   list range size           for chunks in range 1  size   1               minwidth   size    chunks              ceiling division             maxwidth   - -size    chunks              a   list ragged chunks seq  chunks               sizes    len u  for u in a              deltas   all minwidth  lt   u  lt   maxwidth for u in sizes              assert all  sum a         seq  sum sizes     size  deltas       return True  if test ragged chunks 100       print  ok       We can make this slightly more efficient by exporting the multiplication into the range call  but I think the previous version is more readable  and DRYer    def ragged chunks seq  chunks       size   len seq      start   0     for i in range size  size   chunks   1  size           stop   i    chunks         yield seq start stop          start   stop

User · Answer

Have a look at numpy split    gt  gt  gt  a   numpy array  1 2 3 4    gt  gt  gt  numpy split a  2   array  1  2    array  3  4

User · Answer

If you don t mind that the order will be changed  I recommend you to use  job solution  otherwise  you can use this   def chunkIt seq  num       steps   int len seq    float num       out          last   0 0      while last  lt  len seq           if len seq  -  last   steps   lt  steps              until   len seq              steps   len seq  - last         else              until   int last   steps          out append seq int last   until           last    steps return out

User · Answer

Another way would be something like this  the idea here is to use grouper  but get rid of None  In this case we ll have all  small parts  formed from elements at the first part of the list  and  larger parts  from the later part of the list  Length of  larger parts  is len small parts    1  We need to consider x as two different sub-parts   from itertools import izip longest  import numpy as np  def grouper n  iterable  fillvalue None     This is grouper from itertools      grouper 3   ABCDEFG    x   -- gt  ABC DEF Gxx      args    iter iterable     n     return izip longest fillvalue fillvalue   args   def another chunk x num       extra ele   len x  num  gives number of parts that will have an extra element      small part   int np floor len x  num    gives number of elements in a small part      new x   list grouper small part x  small part  num-extra ele         new x extend list grouper small part 1 x small part  num-extra ele            return new x   The way I have it set up returns a list of tuples    gt  gt  gt  x   range 14   gt  gt  gt  another chunk x 3    0  1  2  3    4  5  6  7  8    9  10  11  12  13    gt  gt  gt  another chunk x 4    0  1  2    3  4  5    6  7  8  9    10  11  12  13    gt  gt  gt  another chunk x 5    0  1    2  3  4    5  6  7    8  9  10    11  12  13    gt  gt  gt

User · Answer

usr bin python   first names     Steve    Jane    Sara    Mary   Jack   Bob    Bily    Boni    Chris   Sori    Will    Won   Li    def chunks l  n   for i in range 0  len l   n         Create an index range for l of n items      yield l i i n   result   list chunks first names  5   print result   Picked from this link  and this was what helped me  I had a pre-defined list

User · Answer

Another attempt at simple readable chunker that works  def chunk iterable  count     returns a  generator  that divides  iterable  into  count  of contiguous chunks of similar size     assert count  gt   1     return  iterable int   len iterable  count 0 5  int    1  len iterable  count 0 5   for   in range count    print  quot Chunk count    quot   len list          chunk range 105  10     print  quot Chunks         quot       list          chunk range 105  10    print  quot Chunks         quot       list map list chunk range 105  10     print  quot Chunk lengths  quot       list map len  chunk range 105  10      print  quot Testing    quot   for iterable length in range 100       for chunk count in range 1 100           chunks   list chunk range iterable length  chunk count           assert chunk count    len chunks          assert iterable length    sum map len chunks           assert all map lambda   abs len   -iterable length chunk count  lt  1 chunks   print  quot Okay quot    Outputs  Chunk count    10 Chunks          range 0  11   range 11  21   range 21  32   range 32  42   range 42  53   range 53  63   range 63  74   range 74  84   range 84  95   range 95  105   Chunks           0  1  2  3  4  5  6  7  8  9  10    11  12  13  14  15  16  17  18  19  20    21  22  23  24  25  26  27  28  29  30  31    32  33  34  35  36  37  38  39  40  41    42  43  44  45  46  47  48  49  50  51  52    53  54  55  56  57  58  59  60  61  62    63  64  65  66  67  68  69  70  71  72  73    74  75  76  77  78  79  80  81  82  83    84  85  86  87  88  89  90  91  92  93  94    95  96  97  98  99  100  101  102  103  104   Chunk lengths   11  10  11  10  11  10  11  10  11  10  Testing    Okay

User · Answer

This is the raison d   tre for numpy array split    gt  gt  gt  import numpy as np  gt  gt  gt  print  np array split range 10   3    0 1 2 3   4 5 6   7 8 9   gt  gt  gt  print  np array split range 10   4    0 1 2   3 4 5   6 7   8 9   gt  gt  gt  print  np array split range 10   5    0 1   2 3   4 5   6 7   8 9    credit to Zero Piraeus in room 6

User · Answer

def chunk array array   List  n  int  - gt  List List       chunk size   len array     n      chunks          i   0     while i  lt  len array             if less than chunk size left add the remainder to last element         if len array  -  i   chunk size   1   lt  0              chunks -1  append  array i i   chunk size               break         else              chunks append array i i   chunk size               i    chunk size     return chunks  here s my version  inspired from Max s

User · Answer

1 gt  import numpy as np  data   your array  total length   len data  separate   10 sub array size   total length    separate safe separate   sub array size   separate  splited lists   np split np array data  safe separate    separate  splited lists separate - 1    np concatenate splited lists separate - 1    np array data safe separate total length     splited lists   your output  2 gt  splited lists   np array split np array data   separate

User · Answer

Let s say you want to split a list  1  2  3  4  5  6  7  8  into 3 element lists  like   1 2 3    4  5  6    7  8    where if the last remaining elements left are less than 3  they are grouped together   my list    1  2  3  4  5  6  7  8  my list2    my list i i 3  for i in range 0  len my list   3   print my list2    Output    1 2 3    4  5  6    7  8    Where length of one part is 3  Replace 3 with your own chunk size

User · Answer

As long as you don t want anything silly like continuous chunks    gt  gt  gt  def chunkify lst n           return  lst i  n  for i in xrange n         gt  gt  gt  chunkify range 13   3    0  3  6  9  12    1  4  7  10    2  5  8  11

User · Answer

This will do the split by a single expression    gt  gt  gt  myList   range 18   gt  gt  gt  parts   5  gt  gt  gt   myList  i len myList    parts   i 1  len myList    parts  for i in range parts     0  1  2    3  4  5  6    7  8  9    10  11  12  13    14  15  16  17     The list in this example has the size 18 and is divided into 5 parts  The size of the parts differs in no more than one element

User · Answer

Here s another variant that spreads the  remaining  elements evenly among all the chunks  one at a time until there are none left  In this implementation  the larger chunks occur at the beginning the process   def chunks l  k         Yield k successive chunks from l       if k  lt  1      yield        raise StopIteration   n   len l    avg   n k   remainders   n   k   start  end   0  avg   while start  lt  n      if remainders  gt  0        end   end   1       remainders   remainders - 1     yield l start end      start  end   end  end avg   For example  generate 4 chunks from a list of 14 elements    gt  gt  gt  list chunks range 14   4     0  1  2  3    4  5  6  7    8  9  10    11  12  13    gt  gt  gt  map len  list chunks range 14   4     4  4  3  3

User · Answer

See more itertools divide   n   2   list x  for x in mit divide n  range 5  11        5  6  7    8  9  10     list x  for x in mit divide n  range 5  12        5  6  7  8    9  10  11     Install via  gt  pip install more itertools

User · Answer

Implementation using numpy linspace method    Just specify the number of parts you want the array to be divided in to The divisions will be of nearly equal size   Example         import numpy as np    a np arange 10  print  Input array   a  parts 3 i np linspace np min a  np max a  1 parts 1  i np array i dtype  uint16     Indices should be floats split arr    for ind in range i size-1       split arr append a i ind  i ind 1   print  Array split in to  d parts      parts  split arr   Gives    Input array   0 1 2 3 4 5 6 7 8 9  Array split in to 3 parts     array  0  1  2    array  3  4  5    array  6  7  8  9

User · Answer

My solution  easy to understand  def split list lst  n       splitted          for i in reversed range 1  n   1            split point   len lst   i         splitted append lst  split point           lst   lst split point       return splitted   And shortest one-liner on this page written by my girl   def split l  n       return  l int i len l  n  int  i 1  len l  n-1   for i in range n

User · Answer

You can write it fairly simply as a list generator   def split a  n       k  m   divmod len a   n      return  a i   k   min i  m   i   1    k   min i   1  m   for i in range n     Example    gt  gt  gt  list split range 11   3     0  1  2  3    4  5  6  7    8  9  10

User · Answer

Here is my solution   def chunks l  amount       if amount  lt  1          raise ValueError  amount must be positive integer       chunk len   len l     amount     leap parts   len l    amount     remainder   amount    2    make it symmetrical     i   0     while i  lt  len l           remainder    leap parts         end index   i   chunk len         if remainder  gt   amount              remainder -  amount             end index    1         yield l i end index          i   end index   Produces       gt  gt  gt  list chunks  1  2  3  4  5  6  7   3         1  2    3  4  5    6  7

User · Answer

say you want to split into 5 parts   p1  p2  p3  p4  p5   np split df  5

User · Answer

I tried most part of solutions  but they didn t work for my case  so I make a new function that work for most of cases and for any type of array   import math  def chunkIt seq  num       seqLen   len seq      total chunks   math ceil seqLen   num      items per chunk   num     out          last   0      while last  lt  seqLen          out append seq last  last   items per chunk            last    items per chunk      return out

[python] Splitting a list into N parts of approximately equal length

Examples related to python

Examples related to list

Examples related to chunks