Python split a list based on a condition

Question

What s the best way  both aesthetically and from a performance perspective  to split a list of items into multiple lists based on a conditional  The equivalent of   good    x for x in mylist if x in goodvals  bad     x for x in mylist if x not in goodvals    is there a more elegant way to do this   Update  here s the actual use case  to better explain what I m trying to do     files looks like      file1 jpg   33L    jpg      file2 avi   999L    avi          IMAGE TYPES      jpg    jpeg    gif    bmp    png   images    f for f in files if f 2  lower   in IMAGE TYPES  anims     f for f in files if f 2  lower   not in IMAGE TYPES

User · Answer

itertools groupby almost does what you want  except it requires the items to be sorted to ensure that you get a single contiguous range  so you need to sort by your key first  otherwise you ll get multiple interleaved groups for each type    eg   def is good f       return f 2  lower   in IMAGE TYPES  files       file1 jpg   33L    jpg      file2 avi   999L    avi      file3 gif   123L    gif     for key  group in itertools groupby sorted files  key is good   key is good       print key  list group    gives   False    file2 avi   999L    avi    True    file1 jpg   33L    jpg      file3 gif   123L    gif      Similar to the other solutions  the key func can be defined to divide into any number of groups you want

User · Answer

For perfomance  try itertools   The itertools module standardizes a core set of fast  memory efficient tools that are useful by themselves or in combination  Together  they form an    iterator algebra    making it possible to construct specialized tools succinctly and efficiently in pure Python   See itertools ifilter or imap   itertools ifilter predicate  iterable  Make an iterator that filters elements from iterable returning only those for which the predicate is True

User · Answer

My take on it  I propose a lazy  single-pass  partition function  which preserves relative order in the output subsequences   1  Requirements  I assume that the requirements are    maintain elements  relative order  hence  no sets and dictionaries  evaluate condition only once for every element  hence not using  i filter or groupby  allow for lazy consumption of either sequence  if we can afford to precompute them  then the na  ve implementation is likely to be acceptable too    2  split library  My partition function  introduced below  and other similar functions have made it into a small library    python-split   It s installable normally via PyPI   pip install --user split   To split a list base on condition  use partition function    gt  gt  gt  from split import partition  gt  gt  gt  files       file1 jpg   33L    jpg      file2 avi   999L    avi      gt  gt  gt  image types      jpg    jpeg    gif    bmp    png    gt  gt  gt  images  other   partition lambda f  f -1  in image types  files   gt  gt  gt  list images     file1 jpg   33L    jpg     gt  gt  gt  list other     file2 avi   999L    avi      3  partition function explained  Internally we need to build two subsequences at once  so consuming only one output sequence will force the other one to be computed too  And we need to keep state between user requests  store processed but not yet requested elements   To keep state  I use two double-ended queues  deques    from collections import deque   SplitSeq class takes care of the housekeeping   class SplitSeq      def   init   self  condition  sequence           self cond   condition         self goods   deque             self bads   deque             self seq   iter sequence    Magic happens in its  getNext   method  It is almost like  next   of the iterators  but allows to specify which kind of element we want this time  Behind the scene it doesn t discard the rejected elements  but instead puts them in one of the two queues       def getNext self  getGood True           if getGood              these  those  cond   self goods  self bads  self cond         else              these  those  cond   self bads  self goods  lambda x  not self cond x          if these              return these popleft           else              while 1    exit on StopIteration                 n   self seq next                   if cond n                       return n                 else                      those append n    The end user is supposed to use partition function  It takes a condition function and a sequence  just like map or filter   and returns two generators  The first generator builds a subsequence of elements for which the condition holds  the second one builds the complementary subsequence  Iterators and generators allow for lazy splitting of even long or infinite sequences   def partition condition  sequence       cond   condition if condition else bool    evaluate as bool if condition    None     ss   SplitSeq cond  sequence      def goods            while 1              yield ss getNext getGood True      def bads            while 1              yield ss getNext getGood False      return goods    bads     I chose the test function to be the first argument to facilitate partial application in the future  similar to how map and filter have the test function as the first argument

User · Answer

If you want to make it in FP style   good  bad     sum x      for x in zip     y       if y in goodvals else       y                                           for y in mylist       Not the most readable solution  but at least iterates through mylist only once

User · Answer

Here s the lazy iterator approach   from itertools import tee  def split on condition seq  condition       l1  l2   tee  condition item   item  for item in seq      return  i for p  i in l1 if p    i for p  i in l2 if not p    It evaluates the condition once per item and returns two generators  first yielding values from the sequence where the condition is true  the other where it s false   Because it s lazy you can use it on any iterator  even an infinite one   from itertools import count  islice  def is prime n       return n  gt  1 and all n   i for i in xrange 2  n    primes  not primes   split on condition count    is prime  print  First 10 primes   list islice primes  10    print  First 10 non-primes   list islice not primes  10      Usually though the non-lazy list returning approach is better   def split on condition seq  condition       a  b              for item in seq           a if condition item  else b  append item      return a  b   Edit  For your more specific usecase of splitting items into different lists by some key  heres a generic function that does that   DROP VALUE   lambda     def split by key seq  resultmapping  keyfunc  default DROP VALUE          Split a sequence into lists based on a key function           seq - input sequence         resultmapping - a dictionary that maps from target lists to keys that go to that list         keyfunc - function to calculate the key of an input value         default - the target where items that don t have a corresponding key go  by default they are dropped             result lists   dict  key      for key in resultmapping      appenders   dict  key  result lists target  append  for target  keys in resultmapping items   for key in keys       if default is not DROP VALUE          result lists setdefault default              default action   result lists default  append     else          default action   DROP VALUE      for item in seq          appenders get keyfunc item   default action  item       return result lists   Usage   def file extension f       return f 2  lower    split files   split by key files    images   IMAGE TYPES   keyfunc file extension  default  anims   print split files  images   print split files  anims

User · Answer

Yet another solution to this problem  I needed a solution that is as fast as possible  That means only one iteration over the list and preferably O 1  for adding data to one of the resulting lists  This is very similar to the solution provided by sastanin  except much shorter   from collections import deque  def split iterable  function       dq true   deque       dq false   deque          deque - the fastest way to consume an iterator and append items     deque          dq true if function item  else dq false  append item  for item in iterable        maxlen 0       return dq true  dq false   Then  you can use the function in the following way   lower  higher   split  0 1 2 3 4 5 6 7 8 9   lambda x  x  lt  5   selected  other   split  0 1 2 3 4 5 6 7 8 9   lambda x  x in  0 4 9     If you re not fine with the resulting deque object  you can easily convert it to list  set  whatever you like  for example list lower    The conversion is much faster  that construction of the lists directly   This methods keeps order of the items  as well as any duplicates

User · Answer

If you don t mind using an external library there two I know that nativly implement this operation    gt  gt  gt  files       file1 jpg   33    jpg      file2 avi   999    avi     gt  gt  gt  IMAGE TYPES      jpg    jpeg    gif    bmp    png      iteration utilities partition    gt  gt  gt  from iteration utilities import partition  gt  gt  gt  notimages  images   partition files  lambda x  x 2  lower   in IMAGE TYPES   gt  gt  gt  notimages    file2 avi   999    avi     gt  gt  gt  images    file1 jpg   33    jpg     more itertools partition   gt  gt  gt  from more itertools import partition  gt  gt  gt  notimages  images   partition lambda x  x 2  lower   in IMAGE TYPES  files   gt  gt  gt  list notimages     returns a generator so you need to explicitly convert to list     file2 avi   999    avi     gt  gt  gt  list images     file1 jpg   33    jpg

User · Answer

solution  from itertools import tee  def unpack args fn       return lambda t  fn  t   def separate fn  lx       return map          unpack args              lambda i  ly  filter                  lambda el  bool i     fn el                   ly            enumerate tee lx  2      test   even  odd    separate      lambda x  bool x   2        1  2  3  4  5   print list even      2  4   print list odd      1  3  5

User · Answer

Sometimes  it looks like list comprehension is not the best thing to use    I made a little test based on the answer people gave to this topic  tested on a random generated list  Here is the generation of the list  there s probably a better way to do  but it s not the point     good list      jpg    jpeg    gif    bmp    png    import random import string my origin list      for i in xrange 10000       fname      join random choice string lowercase  for i in range random randrange 10        if random getrandbits 1           fext   random choice good list      else          fext            join random choice string lowercase  for i in range 3        my origin list append  fname   fext  random randrange 1000   fext     And here we go    Parand def f1        return  e for e in my origin list if e 2  in good list    e for e in my origin list if not e 2  in good list     dbr def f2        a  b   list    list       for e in my origin list          if e 2  in good list              a append e          else              b append e      return a  b    John La Rooy def f3        a  b   list    list       for e in my origin list           b  a  e 2  in good list  append e      return a  b    Ants Aasma def f4        l1  l2   tee  e 2  in good list  e  for e in my origin list      return  i for p  i in l1 if p    i for p  i in l2 if not p     My personal way to do def f5        a  b   zip    e  None  if e 2  in good list else  None  e  for e in my origin list       return list filter None  a    list filter None  b      BJ Homer def f6        return filter lambda e  e 2  in good list  my origin list   filter lambda e  not e 2  in good list  my origin list    Using the cmpthese function  the best result is the dbr answer    f1     204 s  --    -5    -14    -15    -20    -26  f6     215 s     6   --    -9    -11    -16    -22  f3     237 s    16     10   --    -2     -7    -14  f4     240 s    18     12      2   --    -6    -13  f5     255 s    25     18      8      6   --    -8  f2     277 s    36     29     17     15      9   --

User · Answer

If you insist on clever  you could take Winden s solution and just a bit spurious cleverness   def splay l  f  d None     d   d or      for x in l  d setdefault f x       append x    return d

User · Answer

For example  splitting list by even and odd  arr   range 20  even  odd   reduce lambda res  next  res next   2  append next  or res  arr              Or in general   def split predicate  iterable       return reduce lambda res  e  res predicate e   append e  or res  iterable              Advantages    Shortest posible way Predicate applies only once for each element   Disadvantages   Requires knowledge of functional programing paradigm

User · Answer

Inspired by  gnibbler s great  but terse   answer  we can apply that approach to map to multiple partitions   from collections import defaultdict  def splitter l  mapper          Split an iterable into multiple partitions generated by a callable mapper          results   defaultdict list       for x in l          results mapper x       x       return results   Then splitter can then be used as follows    gt  gt  gt  l    1  2  3  4  2  3  4  5  6  4  3  2  3   gt  gt  gt  split   splitter l  lambda x  x   2    0     partition l into odds and evens  gt  gt  gt  split items    gt  gt  gt    False   1  3  3  5  3  3     True   2  4  2  4  6  4  2      This works for more than two partitions with a more complicated mapping  and on iterators  too     gt  gt  gt  import math  gt  gt  gt  l   xrange 1  23   gt  gt  gt  split   splitter l  lambda x  int math log10 x    5    gt  gt  gt  split items     0   1      1   2      2   3      3   4  5  6      4   7  8  9      5   10  11  12  13  14  15      6   16  17  18  19  20  21  22      Or using a dictionary to map    gt  gt  gt  map     A   1   X   2   B   3   Y   1   C   2   Z   3   gt  gt  gt  l     A    B    C    C    X    Y    Z    A    Z    gt  gt  gt  split   splitter l  map get   gt  gt  gt  split items    1    A    Y    A      2    C    C    X      3    B    Z    Z

User · Answer

I d take a 2-pass approach  separating evaluation of the predicate from filtering the list   def partition pred  iterable       xs   list zip map pred  iterable   iterable       return  x 1  for x in xs if x 0     x 1  for x in xs if not x 0     What s nice about this  performance-wise  in addition to evaluating pred only once on each member of iterable   is that it moves a lot of logic out of the interpreter and into highly-optimized iteration and mapping code  This can speed up iteration over long iterables  as described in this answer   Expressivity-wise  it takes advantage of expressive idioms like comprehensions and mapping

User · Answer

If the list is made of groups and intermittent separators  you can use   def split items  p       groups            for i in items          if p i               groups append             groups -1  append i      return groups   Usage   split range 1 11   lambda x  x   3    0    gives   1  2    3  4  5    6  7  8    9  10

User · Answer

good  bad          for x in mylist       bad  good  x in goodvals  append x

User · Answer

I think a generalization of splitting a an iterable based on N conditions is handy  from collections import OrderedDict def partition iterable  conditions          Returns a list with the elements that satisfy each of condition         Conditions are assumed to be exclusive        d  OrderedDict  i list   for i in range len conditions                for e in iterable          for i condition in enumerate conditions               if condition e                   d i  append e                  break                         return d values     For instance    ints floats other   partition  2  3 14  1  1 69      None                                 lambda x  isinstance x  int                                  lambda x  isinstance x  float                                 lambda x  True   print   ints     n floats    n other     format ints floats other    ints   2  1   floats  3 14  1 69   other      None    If the element may satisfy multiple conditions  remove the break

User · Answer

images    f for f in files if f 2  lower   in IMAGE TYPES  anims     f for f in files if f not in images   Nice when the condition is longer  such as in your example  The reader doesn t have to figure out the negative condition and whether it captures all other cases

User · Answer

bad      good    x for x in mylist if x in goodvals or bad append x     append returns None  so it works

User · Answer

Concise and Elegant Inspired by DanSalmo s comment  here is a solution that is concise  elegant  and at the same time is one of the fastest solutions  good  bad          for item in my list      good append item  if item in set goodvals  else bad append item   Tip  Turning goodval into a set gives us an easy 40  speed boost  Fastest If you have the need for maximum speed  we take the fastest answer and turbocharge it by turning good list into a set  That gives us a 45  speed boost  and we end up with a solution that is more than 5 5x as fast as the slowest solution  even while it remains readable  good list set   set good list     45  faster than a tuple   good  bad          for item in my origin list      if item in good list set          good append item      else          bad append item   A little shorter  good list set   set good list     45  faster than a tuple   good  bad          for item in my origin list      out   good if item in good list set else bad     out append item   Elegance can be somewhat subjective  but some of the Rube Goldberg style solutions that are cute and ingenious are quite concerning and should not be used in production code in any language  let alone python which is elegant at heart  Benchmark results  filter BJHomer                  80 s       --   -3265    -5312    -5900    -6262    -7273    -7363    -8051    -8162    -8244  zip Funky                       118 s    4848        --   -3040    -3913    -4450    -5951    -6085    -7106    -7271    -7393  two lst tuple JohnLaRoy         170 s   11332     4367        --   -1254    -2026    -4182    -4375    -5842    -6079    -6254  if else DBR                     195 s   14392     6428     1434        --    -882    -3348    -3568    -5246    -5516    -5717  two lst compr Parand            213 s   16750     8016     2540      967        --   -2705    -2946    -4786    -5083    -5303  if else 1 line DanSalmo         292 s   26668    14696     7189     5033     3707        --    -331    -2853    -3260    -3562  tuple if else                   302 s   27923    15542     7778     5548     4177      343        --   -2609    -3029    -3341  set 1 line                      409 s   41308    24556    14053    11035     9181     3993     3529        --    -569     -991  set shorter                     434 s   44401    26640    15503    12303    10337     4836     4345      603        --    -448  set if else                     454 s   46952    28358    16699    13349    11290     5532     5018     1100      469        --  The full benchmark code for Python 3 7  modified from FunkySayu   good list      jpg    jpeg    gif    bmp    png    import random import string my origin list      for i in range 10000       fname      join random choice string ascii lowercase  for i in range random randrange 10        if random getrandbits 1           fext   random choice list good list       else          fext    quot   quot       join random choice string ascii lowercase  for i in range 3        my origin list append  fname   fext  random randrange 1000   fext      Parand def two lst compr Parand          return  e for e in my origin list if e 2  in good list    e for e in my origin list if not e 2  in good list     dbr def if else DBR          a  b   list    list       for e in my origin list          if e 2  in good list              a append e          else              b append e      return a  b    John La Rooy def two lst tuple JohnLaRoy          a  b   list    list       for e in my origin list           b  a  e 2  in good list  append e      return a  b      Ants Aasma   def f4          l1  l2   tee  e 2  in good list  e  for e in my origin list        return  i for p  i in l1 if p    i for p  i in l2 if not p     My personal way to do def zip Funky          a  b   zip    e  None  if e 2  in good list else  None  e  for e in my origin list       return list filter None  a    list filter None  b      BJ Homer def filter BJHomer          return list filter lambda e  e 2  in good list  my origin list    list filter lambda e  not e 2  in good list                                                                              my origin list      ChaimG s answer  as a list  def if else 1 line DanSalmo          good  bad              for e in my origin list              good append e  if e 2  in good list else bad append e      return good  bad    ChaimG s answer  as a set  def set 1 line          good list set   set good list      good  bad              for e in my origin list              good append e  if e 2  in good list set else bad append e      return good  bad    ChaimG set and if else list  def set shorter          good list set   set good list      good  bad              for e in my origin list          out   good if e 2  in good list set else bad         out append e      return good  bad    ChaimG s best answer  if else as a set  def set if else          good list set   set good list      good  bad              for e in my origin list          if e 2  in good list set              good append e          else              bad append e      return good  bad    ChaimG s best answer  if else as a set  def tuple if else          good list tuple   tuple good list      good  bad              for e in my origin list          if e 2  in good list tuple              good append e          else              bad append e      return good  bad  def cmpthese n 0  functions None       results          for func name in functions          args      s range 256      func name   from   main   import  s    func name          t   Timer  args          results func name    1    t timeit number n    n    passes sec      functions sorted   sorted functions  key results   getitem        for f in functions sorted          diff              for func in functions sorted              if func    f                  diff append  quot -- quot               else                  diff append f quot  results f  results func  100 - 100 5 0   quot           diffs    quot   quot  join f  x  gt 8s   for x in diff           print f quot  f 27s   t results f    0f  s  diffs  quot     if   name       main         from timeit import Timer cmpthese 1000   two lst compr Parand if else DBR two lst tuple JohnLaRoy zip Funky filter BJHomer if else 1 line DanSalmo set 1 line set if else tuple if else set shorter  split  quot   quot

User · Answer

First go  pre-OP-edit   Use sets   mylist    1 2 3 4 5 6 7  goodvals    1 3 7 8 9   myset   set mylist  goodset   set goodvals   print list myset intersection goodset       1  3  7  print list myset difference goodset         2  4  5  6    That s good for both readability  IMHO  and performance   Second go  post-OP-edit    Create your list of good extensions as a set   IMAGE TYPES   set    jpg    jpeg    gif    bmp    png      and that will increase performance   Otherwise  what you have looks fine to me

User · Answer

Sometimes you won t need that other half of the list  For example   import sys from itertools import ifilter  trustedPeople   sys argv 1  split      newName   sys argv 2   myFriends   ifilter lambda x  x startswith  Shi    trustedPeople   print   s is  smy friend      newName  newName not in myFriends  not   or

User · Answer

good append x  if x in goodvals else bad append x    This elegant and concise answer by  dansalmo showed up buried in the comments  so I m just reposting it here as an answer so it can get the prominence it deserves  especially for new readers   Complete example   good  bad          for x in my list      good append x  if x in goodvals else bad append x

User · Answer

You can do lazy functional programming in Python  like this  partition   lambda l  c  map    lambda iii   i for ii in iii for i in ii     zip         e   if c e  else   e       for e in l     Functional programming is elegant  but not in Python  See also this example in case you know there are not None values in your list  partition   lambda l  c  map    filter lambda x  x is not None  l     zip    None  e  if c e  else  e  None  for e in l

User · Answer

A generator based version  if you can put up with one or maybe two reversals of the original list  A setup    random seed 1234  a   list range 10   random shuffle a  a  2  8  3  5  6  4  9  0  1  7   And the split     list  a pop j  for j  y in   len a -i-1  x  for i x in enumerate a   -1    if y 2    0     -1   a    2  8  6  4  0    3  5  9  1  7     Another list of tuples of locations and each element is built in reverse order  In a generator wrapped round that each element is tested against the predicate  here test for even  and if True then the element is poped using previously computed locations   We are working backwards along the list so poping elements out does not change positions closer to the beginning of the list  A wrapping list   evaluates the generator and a final revers    -1  puts the elements back in the right order  The original list  quot a quot  now only contains elements that for which the predicate is False

User · Answer

If your concern is not to use two lines of code for an operation whose semantics only need once you just wrap some of the approaches above  even your own  in a single function   def part with predicate l  pred       return  i for i in l if pred i     i for i in l if not pred i     It is not a lazy-eval approach and it does iterate twice through the list  but it allows you to partition the list in one line of code

User · Answer

Use Boolean logic to assign data to two arrays  gt  gt  gt  images  anims     i for i in files if t    i 2  lower   in IMAGE TYPES    for t in  0  1    gt  gt  gt  images    file1 jpg   33    jpg     gt  gt  gt  anims    file2 avi   999    avi

User · Answer

The previous answers don t seem to satisfy all four of my obsessive compulsive ticks   Be as lazy as possible  Evaluate the original Iterable only once Evaluate the predicate only once per item Provide nice type annotations  for python 3 7   My solution isn t pretty  and I don t think I can recommend using it  but here it is  def iter split on predicate predicate  Callable  T   bool   iterable  Iterable T   - gt  Tuple Iterator T   Iterator T        deque predicate true   deque       deque predicate false   deque              define a generator function to consume the input iterable       the Predicate is evaluated once per item  added to the appropriate deque  and the predicate result it yielded      def shared generator definitely an iterator           for item in definitely an iterator              print  quot Evaluate predicate  quot               if predicate item                   deque predicate true appendleft item                  yield True             else                  deque predicate false appendleft item                  yield False            consume input iterable only once        converting to an iterator with the iter   function if necessary  Probably this conversion is unnecessary     shared gen   shared generator          iterable if isinstance iterable  collections abc Iterator  else iter iterable                   define a generator function for each predicate outcome and queue     def iter for predicate value  hold queue           def consume shared generator until hold queue contains something                if not hold queue                  try                      while next shared gen     predicate value                          pass                 except                      pass                  consume shared generator until hold queue contains something           while hold queue              print  quot Yield where predicate is  quot  str predicate value               yield hold queue pop               consume shared generator until hold queue contains something              return a tuple of two generators       return iter for predicate value True  hold queue deque predicate true   iter for predicate value False  hold queue deque predicate false   Testing with the following we get the output below from the print statements  t f   iter split on predicate lambda item item gt  10  1 2 3 10 11 12 4 5 6 13 14 15   print list zip t f      Evaluate predicate    Evaluate predicate    Evaluate predicate    Evaluate predicate    Yield where predicate is True   Yield where predicate is False   Evaluate predicate    Yield where predicate is True   Yield where predicate is False   Evaluate predicate    Yield where predicate is True   Yield where predicate is False   Evaluate predicate    Evaluate predicate    Evaluate predicate    Evaluate predicate    Yield where predicate is True   Yield where predicate is False   Evaluate predicate    Yield where predicate is True   Yield where predicate is False   Evaluate predicate    Yield where predicate is True   Yield where predicate is False     10  1    11  2    12  3    13  4    14  5    15  6

User · Answer

Personally  I like the version you cited  assuming you already have a list of goodvals hanging around   If not  something like   good   filter lambda x  is good x   mylist  bad   filter lambda x  not is good x   mylist    Of course  that s really very similar to using a list comprehension like you originally did  but with a function instead of a lookup   good    x for x in mylist if is good x   bad     x for x in mylist if not is good x     In general  I find the aesthetics of list comprehensions to be very pleasing   Of course  if you don t actually need to preserve ordering and don t need duplicates  using the intersection and difference methods on sets would work well too

User · Answer

Not sure if this is a good approach but it can be done in this way as well  IMAGE TYPES      jpg    jpeg    gif    bmp    png   files       file1 jpg   33L    jpg      file2 avi   999L    avi    images  anims   reduce lambda  i  a   f   i    f   a  if f 2  in IMAGE TYPES else  i  a    f    files

User · Answer

Already quite a few solutions here  but yet another way of doing that would be -  anims      images    f for f in files if  lambda t  True if f 2  lower   in IMAGE TYPES else anims append t  and False  f     Iterates over the list only once  and looks a bit more pythonic and hence readable to me     gt  gt  gt  files       file1 jpg   33L    jpg      file2 avi   999L    avi      file1 bmp   33L    bmp     gt  gt  gt  IMAGE TYPES      jpg    jpeg    gif    bmp    png    gt  gt  gt  anims       gt  gt  gt  images    f for f in files if  lambda t  True if f 2  lower   in IMAGE TYPES else anims append t  and False  f    gt  gt  gt  print   n  join  str anims   str images       file2 avi   999L    avi       file1 jpg   33L    jpg      file1 bmp   33L    bmp     gt  gt  gt

User · Answer

good    x for x in mylist if x in goodvals  bad     x for x in mylist if x not in goodvals        is there a more elegant way to do this    That code is perfectly readable  and extremely clear     files looks like      file1 jpg   33L    jpg      file2 avi   999L    avi          IMAGE TYPES      jpg    jpeg    gif    bmp    png   images    f for f in files if f 2  lower   in IMAGE TYPES  anims     f for f in files if f 2  lower   not in IMAGE TYPES    Again  this is fine   There might be slight performance improvements using sets  but it s a trivial difference  and I find the list comprehension far easier to read  and you don t have to worry about the order being messed up  duplicates being removed as so on   In fact  I may go another step  backward   and just use a simple for loop   images  anims           for f in files      if f lower   in IMAGE TYPES          images append f      else          anims append f    The a list-comprehension or using set   is fine until you need to add some other check or another bit of logic - say you want to remove all 0-byte jpeg s  you just add something like    if f 1     0      continue

User · Answer

I basically like Anders  approach as it is very general   Here s a version that puts the categorizer first  to match filter syntax  and uses a defaultdict  assumed imported    def categorize func  seq          Return mapping from categories to lists     of categorized items              d   defaultdict list      for item in seq          d func item   append item      return d

User · Answer

def partition pred  seq     return reduce  lambda  yes  no   x   yes  x   no  if pred x  else  yes  no  x    seq

User · Answer

Problem with all proposed solutions is that it will scan and apply the filtering function twice  I d make a simple small function like this  def split into two lists lst  f       a          b          for elem in lst          if f elem               a append elem          else              b append elem      return a  b  That way you are not processing anything twice and also are not repeating code

User · Answer

def partition pred  iterable        Use a predicate to partition entries into false entries and true entries        partition is odd  range 10   -- gt  0 2 4 6 8   and  1 3 5 7 9     t1  t2   tee iterable      return filterfalse pred  t1   filter pred  t2    Check this

User · Answer

Yet another answer  short but  evil   for list-comprehension side effects    digits   list range 10   odd    x pop i  for i  x in enumerate digits  if x   2    gt  gt  gt  odd  1  3  5  7  9    gt  gt  gt  digits  0  2  4  6  8

[python] Python: split a list based on a condition?

Examples related to python