Transpose Unzip Function inverse of zip

Question

I have a list of 2-item tuples and I d like to convert them to 2 lists where the first contains the first item in each tuple and the second list holds the second item   For example   original      a   1     b   2     c   3     d   4     and I want to become    result      a    b    c    d     1  2  3  4     Is there a builtin function that does that

User · Answer

If you have lists that are not the same length, you may not want to use zip as per Patricks answer. This works:

>>> zip(*[('a', 1), ('b', 2), ('c', 3), ('d', 4)])
[('a', 'b', 'c', 'd'), (1, 2, 3, 4)]

But with different length lists, zip truncates each item to the length of the shortest list:

>>> zip(*[('a', 1), ('b', 2), ('c', 3), ('d', 4), ('e', )])
[('a', 'b', 'c', 'd', 'e')]

You can use map with no function to fill empty results with None:

>>> map(None, *[('a', 1), ('b', 2), ('c', 3), ('d', 4), ('e', )])
[('a', 'b', 'c', 'd', 'e'), (1, 2, 3, 4, None)]

zip() is marginally faster though.

User · Answer

While zip  seq  is very useful  it may be unsuitable for very long sequences as it will create a tuple of values to be passed in  For example  I ve been working with a coordinate system with over a million entries and find it signifcantly faster to create the sequences directly    A generic approach would be something like this   from collections import deque seq     a1  b1         a2  b2             width   len seq 0   output    deque len seq      width   preallocate memory for element in seq      for s  item in zip output  element           s append item    But  depending on what you want to do with the result  the choice of collection can make a big difference  In my actual use case  using sets and no internal loop  is noticeably faster than all other approaches   And  as others have noted  if you are doing this with datasets  it might make sense to use Numpy or Pandas collections instead

User · Answer

zip is its own inverse  Provided you use the special   operator    gt  gt  gt  zip     a   1     b   2     c   3     d   4       a    b    c    d     1  2  3  4     The way this works is by calling zip with the arguments   zip   a   1     b   2     c   3     d   4         except the arguments are passed to zip directly  after being converted to a tuple   so there s no need to worry about the number of arguments getting too big

User · Answer

Naive approach  def transpose finite iterable iterable       return zip  iterable      itertools izip  for Python 2 users   works fine for finite iterable  e g  sequences like list tuple str  of  potentially infinite  iterables which can be illustrated like     a 00   a 10       a n0       a 01   a 11       a n1                                    a 0i   a 1i       a ni                                   where   n in N  a ij corresponds to j-th element of i-th iterable    and after applying transpose finite iterable we get     a 00   a 01       a 0i           a 10   a 11       a 1i                                            a n0   a n1       a ni          Python example of such case where a ij    j  n    2   gt  gt  gt  from itertools import count  gt  gt  gt  iterable    count    count     gt  gt  gt  result   transpose finite iterable iterable   gt  gt  gt  next result   0  0   gt  gt  gt  next result   1  1    But we can t use transpose finite iterable again to return to  structure of original iterable because result is an infinite iterable of finite iterables  tuples in our case     gt  gt  gt  transpose finite iterable result      hangs     Traceback  most recent call last     File        line 1  in       File        line 2  in transpose finite iterable MemoryError   So how can we deal with this case       and here comes the deque  After we take a look at docs of itertools tee function  there is Python recipe that with some modification can help in our case  def transpose finite iterables iterable       iterator   iter iterable      try          first elements   next iterator      except StopIteration          return        queues    deque  element                 for element in first elements       def coordinate queue           while True              if not queue                  try                      elements   next iterator                  except StopIteration                      return                 for sub queue  element in zip queues  elements                       sub queue append element              yield queue popleft        return tuple map coordinate  queues     let s check   gt  gt  gt  from itertools import count  gt  gt  gt  iterable    count    count     gt  gt  gt  result   transpose finite iterables transpose finite iterable iterable    gt  gt  gt  result   lt generator object transpose finite iterables  lt locals gt  coordinate at     gt    lt generator object transpose finite iterables  lt locals gt  coordinate at     gt    gt  gt  gt  next result 0   0  gt  gt  gt  next result 0   1   Synthesis  Now we can define general function for working with iterables of iterables ones of which are finite and another ones are potentially infinite using functools singledispatch decorator like  from collections import  abc                           deque  from functools import singledispatch    singledispatch def transpose object                Transposes given object              raise TypeError  Unsupported object type   type                         format type type      transpose register abc Iterable  def transpose finite iterables object                Transposes given iterable of finite iterables              iterator   iter object       try          first elements   next iterator      except StopIteration          return        queues    deque  element                 for element in first elements       def coordinate queue           while True              if not queue                  try                      elements   next iterator                  except StopIteration                      return                 for sub queue  element in zip queues  elements                       sub queue append element              yield queue popleft        return tuple map coordinate  queues     def transpose finite iterable object                Transposes given finite iterable of iterables              yield from zip  object    try      transpose register abc Collection  transpose finite iterable  except AttributeError        Python3 5-     transpose register abc Mapping  transpose finite iterable      transpose register abc Sequence  transpose finite iterable      transpose register abc Set  transpose finite iterable    which can be considered as its own inverse  mathematicians call this kind of functions  involutions   in class of binary operators over finite non-empty iterables     As a bonus of singledispatching we can handle numpy arrays like  import numpy as np     transpose register np ndarray  np transpose    and then use it like   gt  gt  gt  array   np arange 4  reshape  2 2    gt  gt  gt  array array   0  1           2  3     gt  gt  gt  transpose array  array   0  2           1  3      Note  Since transpose returns iterators and if someone wants to have a tuple of lists like in OP -- this can be made additionally with map built-in function like   gt  gt  gt  original      a   1     b   2     c   3     d   4    gt  gt  gt  tuple map list  transpose original       a    b    c    d     1  2  3  4       Advertisement  I ve added generalized solution to lz package from 0 5 0 version which can be used like   gt  gt  gt  from lz transposition import transpose  gt  gt  gt  list map tuple  transpose zip range 10   range 10  20        0  1  2  3  4  5  6  7  8  9    10  11  12  13  14  15  16  17  18  19       P S   There is no solution  at least obvious  for handling potentially infinite iterable of potentially infinite iterables  but this case is less common though

User · Answer

Consider using more itertools unzip    gt  gt  gt  from more itertools import unzip  gt  gt  gt  original      a   1     b   2     c   3     d   4    gt  gt  gt   list x  for x in unzip original      a    b    c    d     1  2  3  4

User · Answer

While numpy arrays and pandas may be preferrable  this function imitates the behavior of zip  args  when called as unzip args    Allows for generators  like the result from zip in Python 3  to be passed as args as it iterates through values   def unzip items  cls list  ocls tuple          Zip function in reverse        param items  Zipped-like iterable       type  items  iterable       param cls  Container factory  Callable that returns iterable containers          with a callable append attribute  to store the unzipped items  Defaults         to   list         type  cls  callable  optional       param ocls  Outer container factory  Callable that returns iterable         containers  with a callable append attribute  to store the inner         containers  see   cls     Defaults to   tuple         type  ocls  callable  optional       returns  Unzipped items in instances returned from   cls    in an instance         returned from   ocls                  iter   will return the same iterator passed to it whenever possible      items   iter items       try          i   next items      except StopIteration          return ocls        unzipped   ocls cls  v   for v in i       for i in items          for c  v in zip unzipped  i               c append v       return unzipped   To use list cointainers  simply run unzip zipped   as  unzip zip   a   b   c    1 2 3          a   b   c    1 2 3     To use deques  or other any container sporting append  pass a factory function   from collections import deque  unzip    a  1    b  2    deque  list      deque   a   b    deque  1 2       Decorate cls and or main cls to micro manage container initialization  as briefly shown in the final assert statement above

User · Answer

You could also do  result      a for a b in original      b for a b in original      It should scale better  Especially if Python makes good on not expanding the list comprehensions unless needed    Incidentally  it makes a 2-tuple  pair  of lists  rather than a list of tuples  like zip does    If generators instead of actual lists are ok  this would do that   result      a for a b in original      b for a b in original      The generators don t munch through the list until you ask for each element  but on the other hand  they do keep references to the original list

User · Answer

I like to use zip  iterable   which is the piece of code you re looking for  in my programs as so   def unzip iterable       return zip  iterable    I find unzip more readable

User · Answer

gt  gt  gt  original      a   1     b   2     c   3     d   4    gt  gt  gt  tuple  list tup  for tup in zip  original       a    b    c    d     1  2  3  4     Gives a tuple of lists as in the question   list1  list2    list tup  for tup in zip  original     Unpacks the two lists

User · Answer

It s only another way to do it but it helped me a lot so I write it here   Having this data structure   X  1 2 3 4  Y   a   b   c   d   XY zip X Y    Resulting in   In  XY Out    1   a     2   b     3   c     4   d      The more pythonic way to unzip it and go back to the original is this one in my opinion   x y zip  XY    But this return a tuple so if you need a list you can use   x y  list x  list y

User · Answer

None of the previous answers efficiently provide the required output  which is a tuple of lists  rather than a list of tuples  For the former  you can use tuple with map  Here s the difference   res1   list zip  original                     a    b    c    d     1  2  3  4   res2   tuple map list  zip  original          a    b    c    d     1  2  3  4     In addition  most of the previous solutions assume Python 2 7  where zip returns a list rather than an iterator   For Python 3 x  you will need to pass the result to a function such as list or tuple to exhaust the iterator  For memory-efficient iterators  you can omit the outer list and tuple calls for the respective solutions

User · Answer

Since it returns tuples  and can use tons of memory   the zip  zipped  trick seems more clever than useful  to me   Here s a function that will actually give you the inverse of zip   def unzip zipped          Inverse of built-in zip function      Args          zipped  a list of tuples      Returns          a tuple of lists      Example          a    1  2  3          b    4  5  6          zipped   list zip a  b            assert zipped      1  4    2  5    3  6            unzipped   unzip zipped           assert unzipped      1  2  3    4  5  6                 unzipped          if len zipped     0          return unzipped      dim   len zipped 0        for i in range dim           unzipped   unzipped     tup i  for tup in zipped          return unzipped

[python] Transpose/Unzip Function (inverse of zip)?

Examples related to python

Examples related to list

Examples related to matrix

Examples related to transpose