¿Cuál es la forma más rápida y elegante de hacer listas de listas de dos listas?

yo tengo

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

Y me gustaría tener

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

Estaba pensando en usar map en lugar de zip, pero no sé si hay algún método de biblioteca estándar para poner como primer argumento.

Puedo definir mi propia función para esto y usar el mapa, mi pregunta es si ya hay algo implementado. No también es una respuesta.

Si está comprimiendo más de 2 listas (o incluso solo 2, para el caso), una forma legible sería:

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

Esto utiliza listas por comprensión y convierte cada elemento de la lista (tuplas) en listas.

Casi tienes la respuesta tú mismo. No use en maplugar de zip. Utilice map AND zip .

Puede usar mapa junto con zip para un enfoque elegante y funcional:

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

zipdevuelve una lista de tuplas. map(list, [...])llama lista cada tupla de la lista. list(map([...])convierte el objeto del mapa en una lista legible.

Me encanta la elegancia de la función zip, pero el uso de la función itemgetter () en el módulo del operador parece ser mucho más rápido. Escribí un script simple para probar esto:

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

Esperaba que zip fuera más rápido, pero el método itemgetter gana por mucho:

Using zip
6.1550450325
Using itemgetter
0.768098831177

Generalmente no me gusta usar lambda, pero ...

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

Si necesita la velocidad adicional, el mapa es un poco más rápido:

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

Sin embargo, el mapa se considera no pitónico y solo debe usarse para ajustar el rendimiento.

¿Qué tal esto?

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

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

O mejor:

>>> def zip_(*args): return map(list_, *args)
>>> zip_(range(5), range(9,4,-1))
[[0, 9], [1, 8], [2, 7], [3, 6], [4, 5]]

Usando numpy

La definición de elegancia puede ser bastante cuestionable, pero si está trabajando con numpyla creación de una matriz y su conversión a lista (si es necesario ...) podría ser muy práctica aunque no sea tan eficiente en comparación con la mapfunción o la comprensión de listas.

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

De lo contrario, puede omitir la zipfunción que puede usar directamente np.dstack:

np.dstack((a,b))[0].tolist()

La comprensión de listas sería una solución muy simple, supongo.

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