119

What is the fastest and most elegant way of doing list of lists from two lists?

I have

In [1]: a=[1,2,3,4,5,6]

In [2]: b=[7,8,9,10,11,12]

In [3]: zip(a,b)
Out[3]: [(1, 7), (2, 8), (3, 9), (4, 10), (5, 11), (6, 12)]

And I'd like to have

In [3]: some_method(a,b)
Out[3]: [[1, 7], [2, 8], [3, 9], [4, 10], [5, 11], [6, 12]]

I was thinking about using map instead of zip, but I don't know if there is some standard library method to put as a first argument.

I can def my own function for this, and use map, my question is if there is already implemented something. No is also an answer.

Ravindra S
  • 5,906
  • 12
  • 67
  • 103
Jan Vorcak
  • 18,421
  • 14
  • 49
  • 86

7 Answers7

125

If you are zipping more than 2 lists (or even only 2, for that matter), a readable way would be:

[list(a) for a in zip([1,2,3], [4,5,6], [7,8,9])]

This uses list comprehensions and converts each element in the list (tuples) into lists.

D K
  • 5,324
  • 6
  • 28
  • 43
73

You almost had the answer yourself. Don't use map instead of zip. Use map AND zip.

You can use map along with zip for an elegant, functional approach:

list(map(list, zip(a, b)))

zip returns a list of tuples. map(list, [...]) calls list on each tuple in the list. list(map([...]) turns the map object into a readable list.

Levy Srugo
  • 55
  • 1
  • 7
Eldamir
  • 9,120
  • 6
  • 42
  • 66
15

I love the elegance of the zip function, but using the itemgetter() function in the operator module appears to be much faster. I wrote a simple script to test this:

import time
from operator import itemgetter

list1 = list()
list2 = list()
origlist = list()
for i in range (1,5000000):
        t = (i, 2*i)
        origlist.append(t)

print "Using zip"
starttime = time.time()
list1, list2 = map(list, zip(*origlist))
elapsed = time.time()-starttime
print elapsed

print "Using itemgetter"
starttime = time.time()
list1 = map(itemgetter(0),origlist)
list2 = map(itemgetter(1),origlist)
elapsed = time.time()-starttime
print elapsed

I expected zip to be faster, but the itemgetter method wins by a long shot:

Using zip
6.1550450325
Using itemgetter
0.768098831177
kslnet
  • 524
  • 8
  • 19
  • 2
    This is a transpose of what the OP is trying to do. Could you update your post to reflect that? I.e., OP is converting two lists to list or arbitrary number of pairs. You are converting an arbitrary number of pairs to a pair of lists. – Mad Physicist Jul 20 '16 at 15:46
  • Which python version is this measured with? – Moberg Sep 15 '16 at 09:27
  • I don't remember, it was over two years ago, but most likely 2.6 or 2.7. I imagine you can copy the code and try it on your own version/platform. – kslnet Sep 15 '16 at 18:52
  • 2
    python 2 `zip` creates a real list. That slows things down. Try replacing `zip` with `itertools.izip` then. – Jean-François Fabre Nov 18 '17 at 19:23
  • In Python 3.5, zip takes 3.5 seconds and itemgetter takes 0.10 seconds. For those fond of list comprehensions, `list1 = [x[0] for x in origlist]` works just as well as `list1 = map(itemgetter(0), origlist)`. – Elias Strehle Nov 09 '18 at 14:47
4

I generally don't like using lambda, but...

>>> a = [1, 2, 3, 4, 5]
>>> b = [6, 7, 8, 9, 10]
>>> c = lambda a, b: [list(c) for c in zip(a, b)]
>>> c(a, b)
[[1, 6], [2, 7], [3, 8], [4, 9], [5, 10]]

If you need the extra speed, map is slightly faster:

>>> d = lambda a, b: map(list, zip(a, b))
>>> d(a, b)
[[1, 6], [2, 7], [3, 8], [4, 9], [5, 10]]

However, map is considered unpythonic and should only be used for performance tuning.

Ceasar Bautista
  • 19,941
  • 14
  • 59
  • 78
  • 4
    What does `lambda` add here? One can just write the expression instead of calling a function (it's really not complicated), and even if one wants a function for it, it can be defined painlessly in two lines (one if your return key is broken or you're insane). `map` on the other hand is perfectly fine if the first argument would be a plain function (as opposed to a `lambda`). –  Dec 04 '11 at 01:03
  • 1
    Well he asked for a function. But I agree-- probably better just to pay the extra line. As for map, I believe list comprehensions are almost always clearer. – Ceasar Bautista Dec 04 '11 at 01:08
  • 1
    I would recommend `map` over `lambda`. so `map(list, zip(a,b))`. List comprehensions may be a little clearer, but map should be faster (untested) – inspectorG4dget Dec 04 '11 at 01:15
  • I mean, again, if the OP needs speed, map is the way to go. But in general, and in Python especially, emphasize readability over speed (else you dip into premature optimization). – Ceasar Bautista Dec 04 '11 at 01:18
3

How about this?

>>> def list_(*args): return list(args)

>>> map(list_, range(5), range(9,4,-1))
[[0, 9], [1, 8], [2, 7], [3, 6], [4, 5]]

Or even better:

>>> def zip_(*args): return map(list_, *args)
>>> zip_(range(5), range(9,4,-1))
[[0, 9], [1, 8], [2, 7], [3, 6], [4, 5]]
Broseph
  • 1,558
  • 14
  • 37
  • That seems to me a better answer than the rest as here we are reducing one step by not doing a zip and directly creating a list. Awesome – Akshay Hazari Nov 02 '15 at 05:53
3

List comprehension would be very simple solution I guess.

a=[1,2,3,4,5,6]

b=[7,8,9,10,11,12]

x = [[i, j] for i, j in zip(a,b)]

print(x)

output : [[1, 7], [2, 8], [3, 9], [4, 10], [5, 11], [6, 12]]
axai_m
  • 39
  • 2
3

Using numpy

The definition of elegance can be quite questionable but if you are working with numpy the creation of an array and its conversion to list (if needed...) could be very practical even though not so efficient compared to using the map function or the list comprehension.

import numpy as np 
a = b = range(10)
zipped = zip(a,b)
# result = np.array(zipped).tolist() Python 2.7
result = np.array(list(zipped)).tolist()
Out: [[0, 0],
 [1, 1],
 [2, 2],
 [3, 3],
 [4, 4],
 [5, 5],
 [6, 6],
 [7, 7],
 [8, 8],
 [9, 9]]

Otherwise skipping the zip function you can use directly np.dstack:

np.dstack((a,b))[0].tolist()
G M
  • 17,694
  • 10
  • 75
  • 78