Puede utilizar el + operador para combinarlos:

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

joinedlist = listone + listtwo

Salida:

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

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

Se ha introducido otra alternativa mediante la aceptación de PEP 448 que merece ser mencionado.

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

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

Esta funcionalidad fue definido para Python 3.5 no se ha actualizado a versiones anteriores en el 3.x familia. En versiones no compatibles un SyntaxError se va a levantar.

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

EL al revés a este enfoque es que realmente no necesita listas para realizarlo, cualquier cosa que sea iterable servirá. 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 suma con + levantaría un TypeError debido a la falta de coincidencia de tipos:

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

Lo siguiente no lo hará:

res = [*l, *r]

porque primero descomprimirá el contenido de los iterables y luego simplemente creará un list del contenido.

También es posible crear un generador que simplemente itera sobre los elementos en ambas listas usando itertools.chain(). 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

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

mergedlist = list(set(listone + listtwo))

También podrías usar el list.extend() método para agregar un list hasta el final de otro:

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

listone.extend(listtwo)

Si desea mantener intacta la lista original, puede crear una nueva list objeto, y extend ambas listas a él:

mergedlist = []
mergedlist.extend(listone)
mergedlist.extend(listtwo)

¿Cómo concateno dos listas en Python?

A partir de 3.9, estos son los métodos stdlib más populares para concatenar dos (o más) listas en Python.

Notas a pie de página

1. Esta es una solución ingeniosa debido a su brevedad. Pero sum realiza la concatenación por pares, lo que significa que se trata de una operación cuadrática ya que se debe asignar memoria para cada paso. NO USE si sus listas son grandes.

2. Ver chain y chain.from_iterable de los docs. Necesitaras import itertools primero. La concatenación es lineal en la memoria, por lo que es la mejor en términos de rendimiento y compatibilidad de versiones. chain.from_iterable fue introducido en 2.6.

3. Este método usa Generalizaciones adicionales de desembalaje (PEP 448), pero no se puede generalizar a N listas a menos que desempaquete manualmente cada una usted mismo.

4. a += b y a.extend(b) son más o menos equivalentes a todos los efectos prácticos. += cuando sea llamado en una lista, llamará internamente list.__iadd__, que amplía la primera lista por la segunda.

Rendimiento

Concatenación de 2 listas¹

No hay mucha diferencia entre estos métodos, pero tiene sentido dado que todos tienen el mismo orden de complejidad (lineal). No hay ninguna razón en particular para preferir uno sobre el otro, excepto por una cuestión de estilo.

Concatenación de N-List

Las parcelas se han generado utilizando el diagrama de rendimiento módulo. Código, para su referencia.

_{1. los iadd (+=) y extend Los métodos operan en el lugar, por lo que se debe generar una copia cada vez antes de la prueba. Para mantener las cosas justas, todos los métodos tienen un paso de copia previa para la lista de la izquierda que se puede ignorar.}

Comentarios sobre otras soluciones

• NO USE EL MÉTODO DUNDER list.__add__ directamente de cualquier manera, forma o forma. De hecho, manténgase alejado de los métodos dunder y utilice los operadores y operator funciones para las que fueron diseñadas. Python tiene una semántica cuidadosa incorporada en estos que son más complicados que simplemente llamar al dunder directamente. Aquí está un ejemplo. Entonces, para resumir, a.__add__(b) => MALO; a + b => BUENO.

• Algunas respuestas aquí ofrecen reduce(operator.add, [a, b]) para la concatenación por pares: esto es lo mismo que sum([a, b], []) sólo que más prolijo.

• Cualquier método que utilice set dejará duplicados y perderá el pedido. Úselo con precaución.

• for i in b: a.append(i) es más prolijo y más lento que a.extend(b), que es una llamada de función única y más idiomática. append es más lento debido a la semántica con la que se asigna y se hace crecer la memoria para las listas. Ver aquí para una discusión similar.

• heapq.merge funcionará, pero su caso de uso es para fusionar listas ordenadas en tiempo lineal. Usarlo en cualquier otra situación es un anti-patrón.

• yieldLa lista de elementos de una función es un método aceptable, pero chain hace esto más rápido y mejor (tiene una ruta de código en C, por lo que es rápido).

• operator.add(a, b) es un equivalente funcional aceptable a a + b. Sus casos de uso son principalmente para el envío de métodos dinámicos. De lo contrario, prefiera a + b que es más corto y más legible, en mi opinión. YMMV.

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

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

Esta pregunta se refiere directamente a 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 listas cero).

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 puede 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 is [] or [[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 necesitas un list, pero solo iterable, omite list().

Actualizar

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

sum(a, [])

Podrías simplemente usar el + or += operador de la 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 combinada sean únicos, puede hacer lo siguiente:

c = list(set(a + b))

Vale la pena señalar que el itertools.chain La función 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 un iterable (tupla, lista, generador, etc.) es la entrada, el from_iterable se puede utilizar el método de clase:

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

Con Python 3.3+ puedes usar 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]

Si desea fusionar las dos listas en forma ordenada, puede utilizar el merge funcionar desde el heapq biblioteca.

from heapq import merge

a = [1, 2, 4]
b = [2, 4, 6, 7]

print list(merge(a, b))

Para los casos con un número bajo de listas, simplemente puede agregar las listas juntas o usar el desempaquetado en el lugar (disponible en Python-3.5 +):

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

In [2]: listone + listtwo                                                                                                                                                                                   
Out[2]: [1, 2, 3, 4, 5, 6]
                                                                                                                                                                                     
In [3]: [*listone, *listtwo]                                                                                                                                                                                
Out[3]: [1, 2, 3, 4, 5, 6]

Como forma más general para casos con más listas, como enfoque pitónico, puede usar chain.from_iterable()¹ funcionar desde itertoold módulo. Además, basado en este https://www.youtube.com/watch?v=xB-eutXNUMXJtA&feature=youtu.be esta función es la mejor; o al menos una forma muy gastronómica de aplanar una lista anidada también.

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

Si no puede usar el operador más (+), puede utilizar el operator importe:

import operator

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

result = operator.add(listone, listtwo)
print(result)

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

Alternativamente, también puede utilizar el __add__ dunder función:

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

result = list.__add__(listone, listtwo)
print(result)

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

Si necesita fusionar dos listas ordenadas con reglas de ordenación complicadas, es posible que tenga que enrollarlas usted mismo como en el siguiente código (usando una regla de ordenación simple para legibilidad :-)).

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

Podrías usar el append() método definido en list objetos:

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

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)

Como ya han señalado muchos, itertools.chain() es el camino a seguir si uno necesita postularse exactamente el mismo trato a ambas listas. En mi caso, tenía una etiqueta y una bandera que eran diferentes de una lista a otra, así que necesitaba algo un poco más complejo. Como resultado, detrás de escena itertools.chain() simplemente hace lo siguiente:

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

(consulta: https://docs.python.org/2/library/itertools.html), así que me inspiré aquí y escribí algo como esto:

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 iterables, que son objetos como cualquier otro; y eso for ... in Los bucles en Python pueden funcionar con variables de tupla, por lo que es sencillo realizar un bucle en varias variables al mismo tiempo.

Utilice una simple lista de comprensión:

joined_list = [item for list_ in [list_one, list_two] for item in list_]

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

Si está utilizando NumPy, puede concatenar dos matrices de dimensiones compatibles con este comando:

numpy.concatenate([a,b])

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]

Así que hay dos formas sencillas.

1. Usar +: 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 extender: 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

Por lo tanto, vemos que de dos de los métodos más populares, extend es eficiente.

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

 c=a+b
 print(c)

SALIDA:

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

En el código anterior, el operador "+" se usa para concatenar las 2 listas en una sola lista.

OTRA SOLUCIÓN:

 a=[1,2,3]
 b=[4,5,6]
 c=[] #Empty list in which we are going to append the values of list (a) and (b)

 for i in a:
     c.append(i)
 for j in b:
     c.append(j)

 print(c)

SALIDA:

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

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]

Supongo que desea uno de los dos métodos:

Mantener elementos duplicados

Es muy fácil, simplemente concatenar como una cadena:

def concat_list(l1,l2):
    l3 = l1+l2
    return l3

Siguiente si desea eliminar elementos duplicados

def concat_list(l1,l2):
   l3 = []
   for i in [l1,l2]:
     for j in i:   
       if j not in l3:   
         #Check if element exists in final list, if no then add element to list
         l3.append(j)
   return l3

Puede usar la función union () en Python.

joinedlist = union(listone, listtwo)
print(joinedlist)

Básicamente, lo que está haciendo es eliminar uno de cada duplicado en las dos listas. Dado que sus listas no tienen ningún duplicado, solo devuelve la versión concatenada de las dos listas.