424

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?

edited Mar 27 at 12:23

TrebledJ

3,48611228

asked Aug 21 '08 at 4:29

Cristian

23k247695

5

Great answers below, but also look at numpy's transpose

– opyate
Mar 3 '15 at 13:17

3

See this nice answer to do the same with generators instead of list : how-to-unzip-an-iterator

– YvesgereY
Jan 5 '16 at 20:31

is there somewhere detailing the actual implementation?

– Charlie Parker
Feb 8 at 3:25

add a comment |

424

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?

edited Mar 27 at 12:23

TrebledJ

3,48611228

asked Aug 21 '08 at 4:29

Cristian

23k247695

5

Great answers below, but also look at numpy's transpose

– opyate
Mar 3 '15 at 13:17

3

See this nice answer to do the same with generators instead of list : how-to-unzip-an-iterator

– YvesgereY
Jan 5 '16 at 20:31

is there somewhere detailing the actual implementation?

– Charlie Parker
Feb 8 at 3:25

add a comment |

424

112

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?

edited Mar 27 at 12:23

TrebledJ

3,48611228

asked Aug 21 '08 at 4:29

Cristian

23k247695

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?

python list matrix transpose

edited Mar 27 at 12:23

TrebledJ

3,48611228

asked Aug 21 '08 at 4:29

Cristian

23k247695

edited Mar 27 at 12:23

TrebledJ

3,48611228

asked Aug 21 '08 at 4:29

Cristian

23k247695

edited Mar 27 at 12:23

TrebledJ

3,48611228

edited Mar 27 at 12:23

TrebledJ

3,48611228

edited Mar 27 at 12:23

TrebledJ

3,48611228

asked Aug 21 '08 at 4:29

Cristian

23k247695

asked Aug 21 '08 at 4:29

Cristian

23k247695

asked Aug 21 '08 at 4:29

Cristian

23k247695

5

Great answers below, but also look at numpy's transpose

– opyate
Mar 3 '15 at 13:17

3

See this nice answer to do the same with generators instead of list : how-to-unzip-an-iterator

– YvesgereY
Jan 5 '16 at 20:31

is there somewhere detailing the actual implementation?

– Charlie Parker
Feb 8 at 3:25

add a comment |

5

Great answers below, but also look at numpy's transpose

– opyate
Mar 3 '15 at 13:17

3

See this nice answer to do the same with generators instead of list : how-to-unzip-an-iterator

– YvesgereY
Jan 5 '16 at 20:31

is there somewhere detailing the actual implementation?

– Charlie Parker
Feb 8 at 3:25

Great answers below, but also look at numpy's transpose

– opyate
Mar 3 '15 at 13:17

See this nice answer to do the same with generators instead of list : how-to-unzip-an-iterator

– YvesgereY
Jan 5 '16 at 20:31

is there somewhere detailing the actual implementation?

– Charlie Parker
Feb 8 at 3:25

add a comment |

12 Answers
12

active

oldest

votes

677

zip is its own inverse! Provided you use the special * operator.

>>> 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.

edited Jun 13 '17 at 0:09

answered Aug 21 '08 at 4:36

Patrick

60.7k104561

15

Oh, if only it were so simple. Unzipping zip(, ) this way does not get you , . It gets you . If only...

– user2357112
Feb 24 '14 at 12:06

1

@cdhagmann: Now try that with list1=; list2=.

– user2357112
Feb 26 '14 at 2:53

3

This does not work in Python3. See: stackoverflow.com/questions/24590614/…

– Tommy
Jul 5 '14 at 21:35

12

@Tommy This is incorrect. zip works exactly the same in Python 3 except that it returns an iterator instead of a list. In order to get the same output as above you just need to wrap the zip call in a list: list(zip(*[('a', 1), ('b', 2), ('c', 3), ('d', 4)])) will output [('a', 'b', 'c', 'd'), (1, 2, 3, 4)]

– MJeffryes
Mar 11 '15 at 14:11

4

notice: you can meet memory and performance issues with very long lists.

– Laurent LAPORTE
Oct 14 '16 at 12:44

|
show 8 more comments

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.

edited Aug 24 '08 at 17:14

answered Aug 24 '08 at 17:07

Anders Eurenius

3,89721920

7

"Especially if Python makes good on not expanding the list comprehensions unless needed." mmm... normally, list comprehensions are expanded immediately - or do I get something wrong?

– glglgl
Aug 15 '11 at 19:52

@glglgl: No,you're probably right. I was just hoping some future version might start doing the right thing. (It's not impossible to change, the side-effect semantics that need changes are probably already discouraged.)

– Anders Eurenius
Oct 15 '12 at 12:54

8

What you hope to get is a generator expresion - which exists already.

– glglgl
Oct 15 '12 at 13:12

11

This does not 'scale better' than the zip(*x) version. zip(*x) only requires one pass through the loop, and does not use up stack elements.

– habnabit
Nov 17 '13 at 16:38

1

Whether it "scales better" or not depends of the lifecycle of the original data compared to the transposed data. This answer is only better than using zip if the use-case is that the transposed data is used and discarded immediately, while the original lists stay in memory for much longer.

– Ekevoo
Nov 15 '15 at 6:55

|
show 2 more comments

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.

answered Jan 2 '11 at 12:14

Chris

67776

3

interesting, can you explain how map works so?

– Grijesh Chauhan
Sep 26 '13 at 15:53

4

You could also use izip_longest

– Marcin
Sep 26 '13 at 16:52

3

Known as zip_longest for python3 users.

– zezollo
Mar 8 '16 at 9:02

1

@GrijeshChauhan I know this is really old, but it's a weird built in feature: docs.python.org/2/library/functions.html#map "If function is None, the identity function is assumed; if there are multiple arguments, map() returns a list consisting of tuples containing the corresponding items from all iterables (a kind of transpose operation). The iterable arguments may be a sequence or any iterable object; the result is always a list."

– cactus1
Jul 14 '17 at 19:26

add a comment |

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.

answered Mar 1 '14 at 15:00

wassimans

3,32693856

add a comment |

>>> original = [('a', 1), ('b', 2), ('c', 3), ('d', 4)]

>>> 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.

answered Mar 5 '16 at 11:08

Noyer282

512512

add a comment |

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))

edited Nov 16 '18 at 11:24

answered Jan 26 '16 at 10:45

G M

6,25354145

add a comment |

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 ℕ,

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

>>> from itertools import count

>>> iterable = [count(), count()]

>>> result = transpose_finite_iterable(iterable)

>>> next(result)

(0, 0)

>>> 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):

>>> 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

>>> from itertools import count

>>> iterable = [count(), count()]

>>> result = transpose_finite_iterables(transpose_finite_iterable(iterable))

>>> result

(<generator object transpose_finite_iterables.<locals>.coordinate at ...>, <generator object transpose_finite_iterables.<locals>.coordinate at ...>)

>>> next(result[0])

0

>>> 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

>>> array = np.arange(4).reshape((2,2))

>>> array

array([[0, 1],

       [2, 3]])

>>> 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

>>> original = [('a', 1), ('b', 2), ('c', 3), ('d', 4)]

>>> tuple(map(list, transpose(original)))

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

I've added generalized solution to lz package from 0.5.0 version which can be used like

>>> from lz.transposition import transpose

>>> 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.

edited Mar 1 at 19:13

answered Dec 21 '18 at 12:46

Azat Ibrakov

4,29371731

add a comment |

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

answered Jun 11 '18 at 13:35

Waylon Flinn

15.2k95567

Continually recreating tuples doesn't seem that efficient to me but you could extend this approach using deques which could preallocate memory.

– Charlie Clark
Sep 26 '18 at 11:17

add a comment |

Consider using more_itertools.unzip.

edited Mar 1 at 19:14

Azat Ibrakov

4,29371731

answered Jan 2 at 21:30

Neil G

14.9k28116209

add a comment |

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.

answered Aug 23 '18 at 17:36

jpp

102k2165116

add a comment |

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.

answered Sep 26 '18 at 14:08

Charlie Clark

10.2k22334

add a comment |

-1

This is how you can transpose a 2x4 tuple into a 4x2 tuple.

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

result

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

edited Aug 25 '18 at 18:50

answered Jun 30 '18 at 3:23

helcode

721524

add a comment |

StackExchange.ifUsing("editor", function () {
StackExchange.using("externalEditor", function () {
StackExchange.using("snippets", function () {
StackExchange.snippets.init();
});
});
}, "code-snippets");

StackExchange.ready(function() {
var channelOptions = {
tags: "".split(" "),
id: "1"
};
initTagRenderer("".split(" "), "".split(" "), channelOptions);

StackExchange.using("externalEditor", function() {
// Have to fire editor after snippets, if snippets enabled
if (StackExchange.settings.snippets.snippetsEnabled) {
StackExchange.using("snippets", function() {
createEditor();
});
}
else {
createEditor();
}
});

function createEditor() {
StackExchange.prepareEditor({
heartbeatType: 'answer',
autoActivateHeartbeat: false,
convertImagesToLinks: true,
noModals: true,
showLowRepImageUploadWarning: true,
reputationToPostImages: 10,
bindNavPrevention: true,
postfix: "",
imageUploader: {
brandingHtml: "Powered by u003ca class="icon-imgur-white" href="https://imgur.com/"u003eu003c/au003e",
contentPolicyHtml: "User contributions licensed under u003ca href="https://creativecommons.org/licenses/by-sa/3.0/"u003ecc by-sa 3.0 with attribution requiredu003c/au003e u003ca href="https://stackoverflow.com/legal/content-policy"u003e(content policy)u003c/au003e",
allowUrls: true
},
onDemand: true,
discardSelector: ".discard-answer"
,immediatelyShowMarkdownHelp:true
});

}
});

draft saved

draft discarded

Sign up or log in

StackExchange.ready(function () {
StackExchange.helpers.onClickDraftSave('#login-link');
});

Post as a guest

Name

Required, but never shown

StackExchange.ready(
function () {
StackExchange.openid.initPostLogin('.new-post-login', 'https%3a%2f%2fstackoverflow.com%2fquestions%2f19339%2ftranspose-unzip-function-inverse-of-zip%23new-answer', 'question_page');
}
);

Post as a guest

Name

Required, but never shown

12 Answers
12

active

oldest

votes

12 Answers
12

active

oldest

votes

677

zip is its own inverse! Provided you use the special * operator.

>>> 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.

edited Jun 13 '17 at 0:09

answered Aug 21 '08 at 4:36

Patrick

60.7k104561

15

Oh, if only it were so simple. Unzipping zip(, ) this way does not get you , . It gets you . If only...

– user2357112
Feb 24 '14 at 12:06

1

@cdhagmann: Now try that with list1=; list2=.

– user2357112
Feb 26 '14 at 2:53

3

This does not work in Python3. See: stackoverflow.com/questions/24590614/…

– Tommy
Jul 5 '14 at 21:35

12

@Tommy This is incorrect. zip works exactly the same in Python 3 except that it returns an iterator instead of a list. In order to get the same output as above you just need to wrap the zip call in a list: list(zip(*[('a', 1), ('b', 2), ('c', 3), ('d', 4)])) will output [('a', 'b', 'c', 'd'), (1, 2, 3, 4)]

– MJeffryes
Mar 11 '15 at 14:11

4

notice: you can meet memory and performance issues with very long lists.

– Laurent LAPORTE
Oct 14 '16 at 12:44

|
show 8 more comments

677

zip is its own inverse! Provided you use the special * operator.

>>> 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.

edited Jun 13 '17 at 0:09

answered Aug 21 '08 at 4:36

Patrick

60.7k104561

15

Oh, if only it were so simple. Unzipping zip(, ) this way does not get you , . It gets you . If only...

– user2357112
Feb 24 '14 at 12:06

1

@cdhagmann: Now try that with list1=; list2=.

– user2357112
Feb 26 '14 at 2:53

3

This does not work in Python3. See: stackoverflow.com/questions/24590614/…

– Tommy
Jul 5 '14 at 21:35

12

@Tommy This is incorrect. zip works exactly the same in Python 3 except that it returns an iterator instead of a list. In order to get the same output as above you just need to wrap the zip call in a list: list(zip(*[('a', 1), ('b', 2), ('c', 3), ('d', 4)])) will output [('a', 'b', 'c', 'd'), (1, 2, 3, 4)]

– MJeffryes
Mar 11 '15 at 14:11

4

notice: you can meet memory and performance issues with very long lists.

– Laurent LAPORTE
Oct 14 '16 at 12:44

|
show 8 more comments

677

zip is its own inverse! Provided you use the special * operator.

>>> 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.

edited Jun 13 '17 at 0:09

answered Aug 21 '08 at 4:36

Patrick

60.7k104561

zip is its own inverse! Provided you use the special * operator.

>>> 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.

edited Jun 13 '17 at 0:09

answered Aug 21 '08 at 4:36

Patrick

60.7k104561

edited Jun 13 '17 at 0:09

answered Aug 21 '08 at 4:36

Patrick

60.7k104561

answered Aug 21 '08 at 4:36

Patrick

60.7k104561

answered Aug 21 '08 at 4:36

Patrick

60.7k104561

15

Oh, if only it were so simple. Unzipping zip(, ) this way does not get you , . It gets you . If only...

– user2357112
Feb 24 '14 at 12:06

1

@cdhagmann: Now try that with list1=; list2=.

– user2357112
Feb 26 '14 at 2:53

3

This does not work in Python3. See: stackoverflow.com/questions/24590614/…

– Tommy
Jul 5 '14 at 21:35

12

@Tommy This is incorrect. zip works exactly the same in Python 3 except that it returns an iterator instead of a list. In order to get the same output as above you just need to wrap the zip call in a list: list(zip(*[('a', 1), ('b', 2), ('c', 3), ('d', 4)])) will output [('a', 'b', 'c', 'd'), (1, 2, 3, 4)]

– MJeffryes
Mar 11 '15 at 14:11

4

notice: you can meet memory and performance issues with very long lists.

– Laurent LAPORTE
Oct 14 '16 at 12:44

|
show 8 more comments

15

Oh, if only it were so simple. Unzipping zip(, ) this way does not get you , . It gets you . If only...

– user2357112
Feb 24 '14 at 12:06

1

@cdhagmann: Now try that with list1=; list2=.

– user2357112
Feb 26 '14 at 2:53

3

This does not work in Python3. See: stackoverflow.com/questions/24590614/…

– Tommy
Jul 5 '14 at 21:35

12

@Tommy This is incorrect. zip works exactly the same in Python 3 except that it returns an iterator instead of a list. In order to get the same output as above you just need to wrap the zip call in a list: list(zip(*[('a', 1), ('b', 2), ('c', 3), ('d', 4)])) will output [('a', 'b', 'c', 'd'), (1, 2, 3, 4)]

– MJeffryes
Mar 11 '15 at 14:11

4

notice: you can meet memory and performance issues with very long lists.

– Laurent LAPORTE
Oct 14 '16 at 12:44

Oh, if only it were so simple. Unzipping zip(, ) this way does not get you , . It gets you . If only...

– user2357112
Feb 24 '14 at 12:06

@cdhagmann: Now try that with list1=; list2=.

– user2357112
Feb 26 '14 at 2:53

This does not work in Python3. See: stackoverflow.com/questions/24590614/…

– Tommy
Jul 5 '14 at 21:35

@Tommy This is incorrect. zip works exactly the same in Python 3 except that it returns an iterator instead of a list. In order to get the same output as above you just need to wrap the zip call in a list: list(zip(*[('a', 1), ('b', 2), ('c', 3), ('d', 4)])) will output [('a', 'b', 'c', 'd'), (1, 2, 3, 4)]

– MJeffryes
Mar 11 '15 at 14:11

notice: you can meet memory and performance issues with very long lists.

– Laurent LAPORTE
Oct 14 '16 at 12:44

|
show 8 more comments

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.

edited Aug 24 '08 at 17:14

answered Aug 24 '08 at 17:07

Anders Eurenius

3,89721920

7

"Especially if Python makes good on not expanding the list comprehensions unless needed." mmm... normally, list comprehensions are expanded immediately - or do I get something wrong?

– glglgl
Aug 15 '11 at 19:52

@glglgl: No,you're probably right. I was just hoping some future version might start doing the right thing. (It's not impossible to change, the side-effect semantics that need changes are probably already discouraged.)

– Anders Eurenius
Oct 15 '12 at 12:54

8

What you hope to get is a generator expresion - which exists already.

– glglgl
Oct 15 '12 at 13:12

11

This does not 'scale better' than the zip(*x) version. zip(*x) only requires one pass through the loop, and does not use up stack elements.

– habnabit
Nov 17 '13 at 16:38

1

Whether it "scales better" or not depends of the lifecycle of the original data compared to the transposed data. This answer is only better than using zip if the use-case is that the transposed data is used and discarded immediately, while the original lists stay in memory for much longer.

– Ekevoo
Nov 15 '15 at 6:55

|
show 2 more comments

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.

edited Aug 24 '08 at 17:14

answered Aug 24 '08 at 17:07

Anders Eurenius

3,89721920

7

"Especially if Python makes good on not expanding the list comprehensions unless needed." mmm... normally, list comprehensions are expanded immediately - or do I get something wrong?

– glglgl
Aug 15 '11 at 19:52

@glglgl: No,you're probably right. I was just hoping some future version might start doing the right thing. (It's not impossible to change, the side-effect semantics that need changes are probably already discouraged.)

– Anders Eurenius
Oct 15 '12 at 12:54

8

What you hope to get is a generator expresion - which exists already.

– glglgl
Oct 15 '12 at 13:12

11

This does not 'scale better' than the zip(*x) version. zip(*x) only requires one pass through the loop, and does not use up stack elements.

– habnabit
Nov 17 '13 at 16:38

1

Whether it "scales better" or not depends of the lifecycle of the original data compared to the transposed data. This answer is only better than using zip if the use-case is that the transposed data is used and discarded immediately, while the original lists stay in memory for much longer.

– Ekevoo
Nov 15 '15 at 6:55

|
show 2 more comments

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.

edited Aug 24 '08 at 17:14

answered Aug 24 '08 at 17:07

Anders Eurenius

3,89721920

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.

edited Aug 24 '08 at 17:14

answered Aug 24 '08 at 17:07

Anders Eurenius

3,89721920

edited Aug 24 '08 at 17:14

answered Aug 24 '08 at 17:07

Anders Eurenius

3,89721920

answered Aug 24 '08 at 17:07

Anders Eurenius

3,89721920

answered Aug 24 '08 at 17:07

Anders Eurenius

3,89721920

7

"Especially if Python makes good on not expanding the list comprehensions unless needed." mmm... normally, list comprehensions are expanded immediately - or do I get something wrong?

– glglgl
Aug 15 '11 at 19:52

@glglgl: No,you're probably right. I was just hoping some future version might start doing the right thing. (It's not impossible to change, the side-effect semantics that need changes are probably already discouraged.)

– Anders Eurenius
Oct 15 '12 at 12:54

8

What you hope to get is a generator expresion - which exists already.

– glglgl
Oct 15 '12 at 13:12

11

This does not 'scale better' than the zip(*x) version. zip(*x) only requires one pass through the loop, and does not use up stack elements.

– habnabit
Nov 17 '13 at 16:38

1

Whether it "scales better" or not depends of the lifecycle of the original data compared to the transposed data. This answer is only better than using zip if the use-case is that the transposed data is used and discarded immediately, while the original lists stay in memory for much longer.

– Ekevoo
Nov 15 '15 at 6:55

|
show 2 more comments

7

"Especially if Python makes good on not expanding the list comprehensions unless needed." mmm... normally, list comprehensions are expanded immediately - or do I get something wrong?

– glglgl
Aug 15 '11 at 19:52

@glglgl: No,you're probably right. I was just hoping some future version might start doing the right thing. (It's not impossible to change, the side-effect semantics that need changes are probably already discouraged.)

– Anders Eurenius
Oct 15 '12 at 12:54

8

What you hope to get is a generator expresion - which exists already.

– glglgl
Oct 15 '12 at 13:12

11

This does not 'scale better' than the zip(*x) version. zip(*x) only requires one pass through the loop, and does not use up stack elements.

– habnabit
Nov 17 '13 at 16:38

1

Whether it "scales better" or not depends of the lifecycle of the original data compared to the transposed data. This answer is only better than using zip if the use-case is that the transposed data is used and discarded immediately, while the original lists stay in memory for much longer.

– Ekevoo
Nov 15 '15 at 6:55

"Especially if Python makes good on not expanding the list comprehensions unless needed." mmm... normally, list comprehensions are expanded immediately - or do I get something wrong?

– glglgl
Aug 15 '11 at 19:52

@glglgl: No,you're probably right. I was just hoping some future version might start doing the right thing. (It's not impossible to change, the side-effect semantics that need changes are probably already discouraged.)

– Anders Eurenius
Oct 15 '12 at 12:54

What you hope to get is a generator expresion - which exists already.

– glglgl
Oct 15 '12 at 13:12

This does not 'scale better' than the zip(*x) version. zip(*x) only requires one pass through the loop, and does not use up stack elements.

– habnabit
Nov 17 '13 at 16:38

Whether it "scales better" or not depends of the lifecycle of the original data compared to the transposed data. This answer is only better than using zip if the use-case is that the transposed data is used and discarded immediately, while the original lists stay in memory for much longer.

– Ekevoo
Nov 15 '15 at 6:55

|
show 2 more comments

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.

answered Jan 2 '11 at 12:14

Chris

67776

3

interesting, can you explain how map works so?

– Grijesh Chauhan
Sep 26 '13 at 15:53

4

You could also use izip_longest

– Marcin
Sep 26 '13 at 16:52

3

Known as zip_longest for python3 users.

– zezollo
Mar 8 '16 at 9:02

1

@GrijeshChauhan I know this is really old, but it's a weird built in feature: docs.python.org/2/library/functions.html#map "If function is None, the identity function is assumed; if there are multiple arguments, map() returns a list consisting of tuples containing the corresponding items from all iterables (a kind of transpose operation). The iterable arguments may be a sequence or any iterable object; the result is always a list."

– cactus1
Jul 14 '17 at 19:26

add a comment |

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.

answered Jan 2 '11 at 12:14

Chris

67776

3

interesting, can you explain how map works so?

– Grijesh Chauhan
Sep 26 '13 at 15:53

4

You could also use izip_longest

– Marcin
Sep 26 '13 at 16:52

3

Known as zip_longest for python3 users.

– zezollo
Mar 8 '16 at 9:02

1

@GrijeshChauhan I know this is really old, but it's a weird built in feature: docs.python.org/2/library/functions.html#map "If function is None, the identity function is assumed; if there are multiple arguments, map() returns a list consisting of tuples containing the corresponding items from all iterables (a kind of transpose operation). The iterable arguments may be a sequence or any iterable object; the result is always a list."

– cactus1
Jul 14 '17 at 19:26

add a comment |

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.

answered Jan 2 '11 at 12:14

Chris

67776

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.

answered Jan 2 '11 at 12:14

Chris

67776

answered Jan 2 '11 at 12:14

Chris

67776

answered Jan 2 '11 at 12:14

Chris

67776

answered Jan 2 '11 at 12:14

Chris

67776

3

interesting, can you explain how map works so?

– Grijesh Chauhan
Sep 26 '13 at 15:53

4

You could also use izip_longest

– Marcin
Sep 26 '13 at 16:52

3

Known as zip_longest for python3 users.

– zezollo
Mar 8 '16 at 9:02

1

@GrijeshChauhan I know this is really old, but it's a weird built in feature: docs.python.org/2/library/functions.html#map "If function is None, the identity function is assumed; if there are multiple arguments, map() returns a list consisting of tuples containing the corresponding items from all iterables (a kind of transpose operation). The iterable arguments may be a sequence or any iterable object; the result is always a list."

– cactus1
Jul 14 '17 at 19:26

add a comment |

3

interesting, can you explain how map works so?

– Grijesh Chauhan
Sep 26 '13 at 15:53

4

You could also use izip_longest

– Marcin
Sep 26 '13 at 16:52

3

Known as zip_longest for python3 users.

– zezollo
Mar 8 '16 at 9:02

1

@GrijeshChauhan I know this is really old, but it's a weird built in feature: docs.python.org/2/library/functions.html#map "If function is None, the identity function is assumed; if there are multiple arguments, map() returns a list consisting of tuples containing the corresponding items from all iterables (a kind of transpose operation). The iterable arguments may be a sequence or any iterable object; the result is always a list."

– cactus1
Jul 14 '17 at 19:26

interesting, can you explain how map works so?

– Grijesh Chauhan
Sep 26 '13 at 15:53

You could also use izip_longest

– Marcin
Sep 26 '13 at 16:52

Known as zip_longest for python3 users.

– zezollo
Mar 8 '16 at 9:02

@GrijeshChauhan I know this is really old, but it's a weird built in feature: docs.python.org/2/library/functions.html#map "If function is None, the identity function is assumed; if there are multiple arguments, map() returns a list consisting of tuples containing the corresponding items from all iterables (a kind of transpose operation). The iterable arguments may be a sequence or any iterable object; the result is always a list."

– cactus1
Jul 14 '17 at 19:26

add a comment |

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.

answered Mar 1 '14 at 15:00

wassimans

3,32693856

add a comment |

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.

answered Mar 1 '14 at 15:00

wassimans

3,32693856

add a comment |

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.

answered Mar 1 '14 at 15:00

wassimans

3,32693856

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.

answered Mar 1 '14 at 15:00

wassimans

3,32693856

answered Mar 1 '14 at 15:00

wassimans

3,32693856

answered Mar 1 '14 at 15:00

wassimans

3,32693856

answered Mar 1 '14 at 15:00

wassimans

3,32693856

add a comment |

>>> original = [('a', 1), ('b', 2), ('c', 3), ('d', 4)]

>>> 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.

answered Mar 5 '16 at 11:08

Noyer282

512512

add a comment |

>>> original = [('a', 1), ('b', 2), ('c', 3), ('d', 4)]

>>> 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.

answered Mar 5 '16 at 11:08

Noyer282

512512

add a comment |

>>> original = [('a', 1), ('b', 2), ('c', 3), ('d', 4)]

>>> 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.

answered Mar 5 '16 at 11:08

Noyer282

512512

>>> original = [('a', 1), ('b', 2), ('c', 3), ('d', 4)]

>>> 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.

answered Mar 5 '16 at 11:08

Noyer282

512512

answered Mar 5 '16 at 11:08

Noyer282

512512

answered Mar 5 '16 at 11:08

Noyer282

512512

answered Mar 5 '16 at 11:08

Noyer282

512512

add a comment |

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))

edited Nov 16 '18 at 11:24

answered Jan 26 '16 at 10:45

G M

6,25354145

add a comment |

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))

edited Nov 16 '18 at 11:24

answered Jan 26 '16 at 10:45

G M

6,25354145

add a comment |

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))

edited Nov 16 '18 at 11:24

answered Jan 26 '16 at 10:45

G M

6,25354145

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))

edited Nov 16 '18 at 11:24

answered Jan 26 '16 at 10:45

G M

6,25354145

edited Nov 16 '18 at 11:24

answered Jan 26 '16 at 10:45

G M

6,25354145

answered Jan 26 '16 at 10:45

G M

6,25354145

answered Jan 26 '16 at 10:45

G M

6,25354145

add a comment |

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 ℕ,

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

>>> from itertools import count

>>> iterable = [count(), count()]

>>> result = transpose_finite_iterable(iterable)

>>> next(result)

(0, 0)

>>> 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):

>>> 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

>>> from itertools import count

>>> iterable = [count(), count()]

>>> result = transpose_finite_iterables(transpose_finite_iterable(iterable))

>>> result

(<generator object transpose_finite_iterables.<locals>.coordinate at ...>, <generator object transpose_finite_iterables.<locals>.coordinate at ...>)

>>> next(result[0])

0

>>> 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

>>> array = np.arange(4).reshape((2,2))

>>> array

array([[0, 1],

       [2, 3]])

>>> 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

>>> original = [('a', 1), ('b', 2), ('c', 3), ('d', 4)]

>>> tuple(map(list, transpose(original)))

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

I've added generalized solution to lz package from 0.5.0 version which can be used like

>>> from lz.transposition import transpose

>>> 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.

edited Mar 1 at 19:13

answered Dec 21 '18 at 12:46

Azat Ibrakov

4,29371731

add a comment |

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 ℕ,

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

>>> from itertools import count

>>> iterable = [count(), count()]

>>> result = transpose_finite_iterable(iterable)

>>> next(result)

(0, 0)

>>> 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):

>>> 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

>>> from itertools import count

>>> iterable = [count(), count()]

>>> result = transpose_finite_iterables(transpose_finite_iterable(iterable))

>>> result

(<generator object transpose_finite_iterables.<locals>.coordinate at ...>, <generator object transpose_finite_iterables.<locals>.coordinate at ...>)

>>> next(result[0])

0

>>> 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

>>> array = np.arange(4).reshape((2,2))

>>> array

array([[0, 1],

       [2, 3]])

>>> 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

>>> original = [('a', 1), ('b', 2), ('c', 3), ('d', 4)]

>>> tuple(map(list, transpose(original)))

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

I've added generalized solution to lz package from 0.5.0 version which can be used like

>>> from lz.transposition import transpose

>>> 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.

edited Mar 1 at 19:13

answered Dec 21 '18 at 12:46

Azat Ibrakov

4,29371731

add a comment |

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 ℕ,

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

>>> from itertools import count

>>> iterable = [count(), count()]

>>> result = transpose_finite_iterable(iterable)

>>> next(result)

(0, 0)

>>> 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):

>>> 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

>>> from itertools import count

>>> iterable = [count(), count()]

>>> result = transpose_finite_iterables(transpose_finite_iterable(iterable))

>>> result

(<generator object transpose_finite_iterables.<locals>.coordinate at ...>, <generator object transpose_finite_iterables.<locals>.coordinate at ...>)

>>> next(result[0])

0

>>> 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

>>> array = np.arange(4).reshape((2,2))

>>> array

array([[0, 1],

       [2, 3]])

>>> 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

>>> original = [('a', 1), ('b', 2), ('c', 3), ('d', 4)]

>>> tuple(map(list, transpose(original)))

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

I've added generalized solution to lz package from 0.5.0 version which can be used like

>>> from lz.transposition import transpose

>>> 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.

edited Mar 1 at 19:13

answered Dec 21 '18 at 12:46

Azat Ibrakov

4,29371731

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 ℕ,

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

>>> from itertools import count

>>> iterable = [count(), count()]

>>> result = transpose_finite_iterable(iterable)

>>> next(result)

(0, 0)

>>> 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):

>>> 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

>>> from itertools import count

>>> iterable = [count(), count()]

>>> result = transpose_finite_iterables(transpose_finite_iterable(iterable))

>>> result

(<generator object transpose_finite_iterables.<locals>.coordinate at ...>, <generator object transpose_finite_iterables.<locals>.coordinate at ...>)

>>> next(result[0])

0

>>> 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

>>> array = np.arange(4).reshape((2,2))

>>> array

array([[0, 1],

       [2, 3]])

>>> 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

>>> original = [('a', 1), ('b', 2), ('c', 3), ('d', 4)]

>>> tuple(map(list, transpose(original)))

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

I've added generalized solution to lz package from 0.5.0 version which can be used like

>>> from lz.transposition import transpose

>>> 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.

edited Mar 1 at 19:13

answered Dec 21 '18 at 12:46

Azat Ibrakov

4,29371731

edited Mar 1 at 19:13

answered Dec 21 '18 at 12:46

Azat Ibrakov

4,29371731

answered Dec 21 '18 at 12:46

Azat Ibrakov

4,29371731

answered Dec 21 '18 at 12:46

Azat Ibrakov

4,29371731

add a comment |

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

answered Jun 11 '18 at 13:35

Waylon Flinn

15.2k95567

Continually recreating tuples doesn't seem that efficient to me but you could extend this approach using deques which could preallocate memory.

– Charlie Clark
Sep 26 '18 at 11:17

add a comment |

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

answered Jun 11 '18 at 13:35

Waylon Flinn

15.2k95567

Continually recreating tuples doesn't seem that efficient to me but you could extend this approach using deques which could preallocate memory.

– Charlie Clark
Sep 26 '18 at 11:17

add a comment |

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

answered Jun 11 '18 at 13:35

Waylon Flinn

15.2k95567

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

answered Jun 11 '18 at 13:35

Waylon Flinn

15.2k95567

answered Jun 11 '18 at 13:35

Waylon Flinn

15.2k95567

answered Jun 11 '18 at 13:35

Waylon Flinn

15.2k95567

answered Jun 11 '18 at 13:35

Waylon Flinn

15.2k95567

Continually recreating tuples doesn't seem that efficient to me but you could extend this approach using deques which could preallocate memory.

– Charlie Clark
Sep 26 '18 at 11:17

add a comment |

Continually recreating tuples doesn't seem that efficient to me but you could extend this approach using deques which could preallocate memory.

– Charlie Clark
Sep 26 '18 at 11:17

Continually recreating tuples doesn't seem that efficient to me but you could extend this approach using deques which could preallocate memory.

– Charlie Clark
Sep 26 '18 at 11:17

add a comment |

Consider using more_itertools.unzip.

edited Mar 1 at 19:14

Azat Ibrakov

4,29371731

answered Jan 2 at 21:30

Neil G

14.9k28116209

add a comment |

Consider using more_itertools.unzip.

edited Mar 1 at 19:14

Azat Ibrakov

4,29371731

answered Jan 2 at 21:30

Neil G

14.9k28116209

add a comment |

Consider using more_itertools.unzip.

edited Mar 1 at 19:14

Azat Ibrakov

4,29371731

answered Jan 2 at 21:30

Neil G

14.9k28116209

Consider using more_itertools.unzip.

edited Mar 1 at 19:14

Azat Ibrakov

4,29371731

answered Jan 2 at 21:30

Neil G

14.9k28116209

edited Mar 1 at 19:14

Azat Ibrakov

4,29371731

edited Mar 1 at 19:14

Azat Ibrakov

4,29371731

edited Mar 1 at 19:14

Azat Ibrakov

4,29371731

answered Jan 2 at 21:30

Neil G

14.9k28116209

answered Jan 2 at 21:30

Neil G

14.9k28116209

answered Jan 2 at 21:30

Neil G

14.9k28116209

add a comment |

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.

answered Aug 23 '18 at 17:36

jpp

102k2165116

add a comment |

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.

answered Aug 23 '18 at 17:36

jpp

102k2165116

add a comment |

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.

answered Aug 23 '18 at 17:36

jpp

102k2165116

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.

answered Aug 23 '18 at 17:36

jpp

102k2165116

answered Aug 23 '18 at 17:36

jpp

102k2165116

answered Aug 23 '18 at 17:36

jpp

102k2165116

answered Aug 23 '18 at 17:36

jpp

102k2165116

add a comment |

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)

And, as others have noted, if you are doing this with datasets, it might make sense to use Numpy or Pandas collections instead.

answered Sep 26 '18 at 14:08

Charlie Clark

10.2k22334

add a comment |

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)

And, as others have noted, if you are doing this with datasets, it might make sense to use Numpy or Pandas collections instead.

answered Sep 26 '18 at 14:08

Charlie Clark

10.2k22334

add a comment |

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)

And, as others have noted, if you are doing this with datasets, it might make sense to use Numpy or Pandas collections instead.

answered Sep 26 '18 at 14:08

Charlie Clark

10.2k22334

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)

And, as others have noted, if you are doing this with datasets, it might make sense to use Numpy or Pandas collections instead.

answered Sep 26 '18 at 14:08

Charlie Clark

10.2k22334

answered Sep 26 '18 at 14:08

Charlie Clark

10.2k22334

answered Sep 26 '18 at 14:08

Charlie Clark

10.2k22334

answered Sep 26 '18 at 14:08

Charlie Clark

10.2k22334

add a comment |

-1

This is how you can transpose a 2x4 tuple into a 4x2 tuple.

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

result

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

edited Aug 25 '18 at 18:50

answered Jun 30 '18 at 3:23

helcode

721524

add a comment |

-1

This is how you can transpose a 2x4 tuple into a 4x2 tuple.

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

result

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

edited Aug 25 '18 at 18:50

answered Jun 30 '18 at 3:23

helcode

721524

add a comment |

-1

This is how you can transpose a 2x4 tuple into a 4x2 tuple.

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

result

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

edited Aug 25 '18 at 18:50

answered Jun 30 '18 at 3:23

helcode

721524

This is how you can transpose a 2x4 tuple into a 4x2 tuple.

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

result

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

edited Aug 25 '18 at 18:50

answered Jun 30 '18 at 3:23

helcode

721524

edited Aug 25 '18 at 18:50

answered Jun 30 '18 at 3:23

helcode

721524

answered Jun 30 '18 at 3:23

helcode

721524

answered Jun 30 '18 at 3:23

helcode

721524

add a comment |

draft saved

draft discarded

Thanks for contributing an answer to Stack Overflow!

Please be sure to answer the question. Provide details and share your research!

But avoid …

Asking for help, clarification, or responding to other answers.

Making statements based on opinion; back them up with references or personal experience.

To learn more, see our tips on writing great answers.

draft saved

draft discarded

Sign up or log in

StackExchange.ready(function () {
StackExchange.helpers.onClickDraftSave('#login-link');
});

Post as a guest

Name

Required, but never shown

Post as a guest

Name

Required, but never shown

Sign up or log in

StackExchange.ready(function () {
StackExchange.helpers.onClickDraftSave('#login-link');
});

Post as a guest

Name

Required, but never shown

Sign up or log in

StackExchange.ready(function () {
StackExchange.helpers.onClickDraftSave('#login-link');
});

Post as a guest

Name

Required, but never shown

Sign up or log in

StackExchange.ready(function () {
StackExchange.helpers.onClickDraftSave('#login-link');
});

Post as a guest

Name

Required, but never shown

Name

Required, but never shown

Name

Required, but never shown

This page is only for reference, If you need detailed information, please check here

Category

Random preview

Transpose/Unzip Function (inverse of zip)?

12 Answers 12

Naive approach

... and here comes the deque

Synthesis

Note

Advertisement

P.S.

Sign up or log in

Post as a guest

Post as a guest

12 Answers 12

12 Answers 12

Naive approach

... and here comes the deque

Synthesis

Note

Advertisement

P.S.

Naive approach

... and here comes the deque

Synthesis

Note

Advertisement

P.S.

Naive approach

... and here comes the deque

Synthesis

Note

Advertisement

P.S.

Naive approach

... and here comes the deque

Synthesis

Note

Advertisement

P.S.

Sign up or log in

Post as a guest

Post as a guest

Sign up or log in

Post as a guest

Sign up or log in

Post as a guest

Sign up or log in

Post as a guest

Popular posts from this blog

MongoDB - Not Authorized To Execute Command

in spring boot 2.1 many test slices are not allowed anymore due to multiple @BootstrapWith

How to fix TextFormField cause rebuild widget in Flutter

12 Answers
12

... and here comes the `deque`

12 Answers
12

12 Answers
12

... and here comes the `deque`

... and here comes the `deque`

... and here comes the `deque`

... and here comes the `deque`