una - ¿Cómo concatenar dos listas en Python?

recorrer lista python

Question

¿Cómo concatenar dos listas en Python?

Ejemplo:

listone = [1, 2, 3]
listtwo = [4, 5, 6]

Gastos esperados:

>>> joinedlist
[1, 2, 3, 4, 5, 6]

Answer 1

Así que hay dos formas fáciles.

1. Usando + : Crea una nueva lista a partir de listas proporcionadas

Ejemplo:

In [1]: a = [1, 2, 3]
In [2]: b = [4, 5, 6]
In [3]: a + b
Out[3]: [1, 2, 3, 4, 5, 6]
In [4]: %timeit a + b
10000000 loops, best of 3: 126 ns per loop

2. Usando extend : Agrega una nueva lista a la lista existente. Eso significa que no crea una lista separada.

Ejemplo:

In [1]: a = [1, 2, 3]
In [2]: b = [4, 5, 6]
In [3]: %timeit a.extend(b)
10000000 loops, best of 3: 91.1 ns per loop

Así vemos que de los dos métodos más populares, extend es eficiente.

Answer 2

Como una forma más general para más listas, puede colocarlas dentro de una lista y usar la función itertools.chain.from_iterable() ¹ que, según THIS respuesta, es la mejor manera de acoplar una lista anidada:

>>> l=[[1, 2, 3], [4, 5, 6], [7, 8, 9]]
>>> import itertools
>>> list(itertools.chain.from_iterable(l))
[1, 2, 3, 4, 5, 6, 7, 8, 9]

_{1. Tenga en cuenta que chain.from_iterable() está disponible en python => 2.6.En otras versiones use chain(*l)}

Answer 3

Como ya lo señalaron muchos, itertools.chain() es el camino a seguir si se necesita aplicar exactamente el mismo tratamiento a ambas listas. En mi caso, tenía una etiqueta y una bandera que eran diferentes de una lista a la otra, por lo que necesitaba algo un poco más complejo. Resulta que, detrás de las escenas, itertools.chain() simplemente hace lo siguiente:

for it in iterables:
for element in it:
yield element

(vea https://docs.python.org/2/library/itertools.html ), así que me inspiré aquí y escribí algo en este sentido:

for iterable, header, flag in ( (newList, ''New'', ''''), (modList, ''Modified'', ''-f'')):
print header + '':''
for path in iterable:
[...]
command = ''cp -r'' if os.path.isdir(srcPath) else ''cp''
print >> SCRIPT , command, flag, srcPath, mergedDirPath
[...]

Los puntos principales a entender aquí son que las listas son solo un caso especial de iterable, que son objetos como cualquier otro; y eso for ... in loops en python puede trabajar con las variables de tupla, por lo que es simple hacer loop en múltiples variables al mismo tiempo.

Answer 4

Con Python 3.3+ puedes usar el rendimiento de :

listone = [1,2,3]
listtwo = [4,5,6]
def merge(l1, l2):
yield from l1
yield from l2
>>> list(merge(listone, listtwo))
[1, 2, 3, 4, 5, 6]

O, si desea admitir un número arbitrario de iteradores:

def merge(*iters):
for it in iters:
yield from it
>>> list(merge(listone, listtwo, ''abcd'', [20, 21, 22]))
[1, 2, 3, 4, 5, 6, ''a'', ''b'', ''c'', ''d'', 20, 21, 22]

Answer 5

En Python puedes concatenar dos matrices de dimensiones compatibles con este comando

numpy.concatenate([a,b])

Answer 6

Esta pregunta pregunta directamente acerca de unirse a dos listas. Sin embargo, es bastante alto en la búsqueda, incluso cuando está buscando una forma de unirse a muchas listas (incluido el caso cuando se une a cero listas).

Creo que la mejor opción es usar listas de comprensión:

>>> a = [[1,2,3], [4,5,6], [7,8,9]]
>>> [x for xs in a for x in xs]
[1, 2, 3, 4, 5, 6, 7, 8, 9]

También puedes crear generadores:

>>> map(str, (x for xs in a for x in xs))
[''1'', ''2'', ''3'', ''4'', ''5'', ''6'', ''7'', ''8'', ''9'']

Respuesta antigua

Considere este enfoque más genérico:

a = [[1,2,3], [4,5,6], [7,8,9]]
reduce(lambda c, x: c + x, a, [])

Saldrá:

[1, 2, 3, 4, 5, 6, 7, 8, 9]

Tenga en cuenta que esto también funciona correctamente cuando a es [] o [[1,2,3]] .

Sin embargo, esto se puede hacer de manera más eficiente con itertools :

a = [[1,2,3], [4,5,6], [7,8,9]]
list(itertools.chain(*a))

Si no necesita una list , sino solo una iterable, omita la list() .

Actualizar

La alternativa sugerida por Patrick Collins en los comentarios también podría funcionar para usted:

sum(a, [])

Answer 7

Esto es bastante simple, creo que incluso se mostró en el tutorial :

>>> listone = [1,2,3]
>>> listtwo = [4,5,6]
>>>
>>> listone + listtwo
[1, 2, 3, 4, 5, 6]

Answer 8

Me sorprende que parece que nadie propuso usar una lista de comprensión simple :

joined_list = [y for x in [list_one, list_two] for y in x]

Tiene todas las ventajas del enfoque más nuevo de usar generalizaciones de desempaquetado adicionales , es decir, puede concatenar un número arbitrario de diferentes iterables (por ejemplo, listas, tuplas, rangos, generadores) de esa manera, y no se limita a Python >= 3.5 .

Answer 9

Podría usar el método append() definido en los objetos de list :

mergedlist =[]
for elem in listone:
mergedlist.append(elem)
for elem in listtwo:
mergedlist.append(elem)

Answer 10

Puede usar conjuntos para obtener una lista combinada de valores únicos

mergedlist = list(set(listone + listtwo))

Answer 11

Puede utilizar la función de extends

listone.extends(listtwo)

Answer 12

Puedes usar el operador + para combinarlos:

listone = [1,2,3]
listtwo = [4,5,6]
mergedlist = listone + listtwo

Salida:

>>> mergedlist
[1,2,3,4,5,6]

Answer 13

Si desea combinar las dos listas en forma ordenada, puede usar la función de combinación de la biblioteca heapq.

from heapq import merge
a = [1,2,4]
b = [2,4,6,7]
print list(merge(a,b))

Answer 14

Si desea una nueva lista manteniendo las dos listas antiguas:

def concatenate_list(listOne, listTwo):
joinedList = []
for i in listOne:
joinedList.append(i)
for j in listTwo:
joinedList.append(j)
sorted(joinedList)
return joinedList

Answer 15

Si necesita combinar dos listas ordenadas con reglas de clasificación complicadas, es posible que deba rodarlas usted mismo como en el siguiente código (utilizando una regla de clasificación simple para facilitar la lectura :-)).

list1 = [1,2,5]
list2 = [2,3,4]
newlist = []
while list1 and list2:
if list1[0] == list2[0]:
newlist.append(list1.pop(0))
list2.pop(0)
elif list1[0] < list2[0]:
newlist.append(list1.pop(0))
else:
newlist.append(list2.pop(0))
if list1:
newlist.extend(list1)
if list2:
newlist.extend(list2)
assert(newlist == [1, 2, 3, 4, 5])

Answer 16

Si no puede usar el operador más ( + ), puede usar la función __add__ :

listone = [1,2,3]
listtwo = [4,5,6]
result = list.__add__(listone, listtwo)
print(result)
>>> [1, 2, 3, 4, 5, 6]

Alternativamente, si no le gusta el uso de dunders puede usar la importación del operator :

import operator
listone = [1,2,3]
listtwo = [4,5,6]
result = operator.add(listone, listtwo)
print(result)
>>> [1, 2, 3, 4, 5, 6]

Se podría argumentar que esto es un poco más legible.

Answer 17

Simplemente puede utilizar el operador + o += siguiente manera:

a = [1, 2, 3]
b = [4, 5, 6]
c = a + b

O:

c = []
a = [1, 2, 3]
b = [4, 5, 6]
c += (a + b)

Además, si desea que los valores de la lista fusionada sean únicos, puede hacerlo:

c = list(set(a + b))

Answer 18

También es posible crear un generador que simplemente itere sobre los elementos en ambas listas. Esto le permite encadenar listas (o cualquier iterable) para procesarlas sin copiar los elementos a una nueva lista:

import itertools
for item in itertools.chain(listone, listtwo):
# do something with each list item

Answer 19

También puede usar extend para agregar una list agregar el final de otra:

listone = [1,2,3]
listtwo = [4,5,6]
mergedlist = []
mergedlist.extend(listone)
mergedlist.extend(listtwo)

Answer 20

Una forma realmente concisa de combinar una lista de listas es

list_of_lists = [[1,2,3], [4,5,6], [7,8,9]]
reduce(list.__add__, list_of_lists)

lo que nos da

[1, 2, 3, 4, 5, 6, 7, 8, 9]

Answer 21

Uniendo dos listas en Python:

>>> a = [1, 2, 3, 4]
>>> b = [1, 4, 6, 7]
>>> c = a + b
>>> c
[1, 2, 3, 4, 1, 4, 6, 7]

Si no quieres ninguna duplicación:

>>> a = [1, 2, 3, 4, 5, 6]
>>> b = [5, 6, 7, 8]
>>> c = list(set(a + b))
>>> c
[1, 2, 3, 4, 5, 6, 7, 8]

Answer 22

Usted puede ir para la función list.extend .

l1 = [1,2,3]
l2 = [4,5,6]
l1.extend(l2)
print l1

Salida:

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

Answer 23

Vale la pena señalar que la función itertools.chain acepta un número variable de argumentos:

>>> l1 = [''a'']; l2 = [''b'', ''c'']; l3 = [''d'', ''e'', ''f'']
>>> [i for i in itertools.chain(l1, l2)]
[''a'', ''b'', ''c'']
>>> [i for i in itertools.chain(l1, l2, l3)]
[''a'', ''b'', ''c'', ''d'', ''e'', ''f'']

Si se ingresa un iterable (tupla, lista, generador, etc.), se puede usar el método de clase from_iterable :

>>> il = [[''a''], [''b'', ''c''], [''d'', ''e'', ''f'']]
>>> [i for i in itertools.chain.from_iterable(il)]
[''a'', ''b'', ''c'', ''d'', ''e'', ''f'']

Answer 24

Python >= 3.5 alternativa: [*l1, *l2]

Aunque esta es una respuesta antigua, se ha introducido otra alternativa a través de la aceptación de PEP 448 que merece ser mencionada.

El PEP, titulado Generalizaciones de desempaquetado adicionales , generalmente redujo algunas restricciones sintácticas al usar la expresión * destacada en Python; Con él, unirse a dos listas (se aplica a cualquier iterable) ahora también se puede hacer con:

>>> l1 = [1, 2, 3]
>>> l2 = [4, 5, 6]
#unpack both iterables in a list literal
>>> joinedList = [*l1, *l2]
>>> print(joinedList)
[1, 2, 3, 4, 5, 6]

Esta funcionalidad se definió para Python 3.5 y no se ha realizado una copia de seguridad de versiones anteriores en la familia 3.x En versiones no compatibles, se SyntaxError un SyntaxError .

Al igual que con los otros enfoques, esto también crea una copia superficial de los elementos en las listas correspondientes.

La ventaja de este enfoque es que realmente no necesitas listas para realizarlo, cualquier cosa que sea iterable hará. Como se indica en el PEP:

Esto también es útil como una forma más legible de sumar iterables en una lista, como my_list + list(my_tuple) + list(my_range) que ahora es equivalente a solo [*my_list, *my_tuple, *my_range] .

Entonces, mientras que la adición con + elevaría un TypeError debido a la falta de coincidencia de tipo:

l = [1, 2, 3]
r = range(4, 7)
res = l + r

Lo siguiente no:

res = [*l, *r]

porque primero desempaquetará los contenidos de los iterables y luego simplemente creará una list partir de los contenidos.

Answer 25

a = [1,2,3,4,5,6]
b = [7,8,9,10]
c = a.extend(b)

imprimir (c) da

[1,2,3,4,5,6,7,8,9,10]

Answer 26

import itertools
A = list(zip([1,3,5,7,9],[2,4,6,8,10]))
B = [1,3,5,7,9]+[2,4,6,8,10]
C = list(set([1,3,5,7,9] + [2,4,6,8,10]))
D = [1,3,5,7,9]
D.append([2,4,6,8,10])
E = [1,3,5,7,9]
E.extend([2,4,6,8,10])
F = []
for a in itertools.chain([1,3,5,7,9], [2,4,6,8,10]):
F.append(a)
print ("A: " + str(A))
print ("B: " + str(B))
print ("C: " + str(C))
print ("D: " + str(D))
print ("E: " + str(E))
print ("F: " + str(F))

Salida:

A: [(1, 2), (3, 4), (5, 6), (7, 8), (9, 10)]
B: [1, 3, 5, 7, 9, 2, 4, 6, 8, 10]
C: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
D: [1, 3, 5, 7, 9, [2, 4, 6, 8, 10]]
E: [1, 3, 5, 7, 9, 2, 4, 6, 8, 10]
F: [1, 3, 5, 7, 9, 2, 4, 6, 8, 10]

Answer 27

list(set(listone) | set(listtwo))

El código anterior, no conserva el orden, elimina el duplicado de cada lista (pero no de la lista concatenada)

Answer 28

lst1 = [1,2]
lst2 = [3,4]
def list_combinationer(Bushisms, are_funny):
for item in lst1:
lst2.append(item)
lst1n2 = sorted(lst2)
print lst1n2
list_combinationer(lst1, lst2)
[1,2,3,4]