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

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

O PEP, intitulado generalizações adicionais de desempacotamento, geralmente reduziu algumas restrições sintáticas ao usar a expressão "starred" * em Python; com ela, juntar duas listas (aplica-se a qualquer iterável) também pode ser feito com:

>>> 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 funcionalidade foi definido para Python 3.5 não foi desviado para versões anteriores na família 3.x. Nas versões não suportadas a SyntaxError vai ser levantada.

Tal como acontece com as outras abordagens, isto também cria como cópia rasa dos elementos nas listas correspondentes.

O lado positivo desta abordagem é que você realmente não precisa de listas para executá-lo, qualquer coisa que seja iterável fará. Como indicado no PEP:

Isto também é útil como uma forma mais legível de somar iterables em um lista, como my_list + list(my_tuple) + list(my_range) que é agora equivalente a apenas [*my_list, *my_tuple, *my_range].

Então, enquanto a adição com {[12] } aumentaria um TypeError devido ao tipo de desfasamento:

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

O seguinte não vai:

res = [*l, *r]

Porque primeiro vai desfazer o conteúdo dos iterables e, em seguida, simplesmente criar um list a partir do conteúdo.

Pode usar conjuntos para obter uma lista de valores únicos reunidos

mergedlist = list(set(listone + listtwo))

Também podes usar o list.extend() método para adicionar um list ao fim de outro:

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

listone.extend(listtwo)

Se quiser manter a lista original intacta, poderá criar um novo objecto list, e extend ambas as listas para ele:

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

Como concatenar duas listas em Python?

A partir de 3.9, estes são os métodos stdlib mais populares para concatenar duas (ou mais) listas em python.

Notas de rodapé

1. Esta é uma solução escorregadia por causa da sua succincness. Mas {[[0]} realiza a concatenação de uma forma emparelhada, o que significa que isto é um operação quadrática como memória tem que ser alocada para cada passo. FAZER NAO USE se suas listas são grandes.

2. Ver chain e chain.from_iterable dos médicos. Você vai precisar de import itertools primeiro. A concatenação é linear na memória, de modo que este é o melhor em termos de performance e compatibilidade de versão. chain.from_iterable foi introduzido em 2.6.

3. Este método utiliza generalizações adicionais de descompressão (PEP 448) , mas não pode generalizar para n listas, a menos que você mesmo desempacote cada uma delas.

4. a += b e {[6] } são mais ou menos equivalentes para todos os fins práticos. += quando for chamada para uma lista irá ligar internamente list.__iadd__, que estende a primeira lista pela segunda.

Desempenho

2-Lista De Concatenação¹

Não há muita diferença entre estes métodos, mas isso faz sentido dado que todos eles têm a mesma ordem de complexidade (linear). Não há nenhuma razão especial para preferir um em vez do outro. outros, excepto por uma questão de estilo.

N-List Concatenation

As parcelas foram geradas usando o móduloperfplot . código, para a sua referência.

_{1. O iadd (+=) e os métodos extend funcionam no local, por isso uma cópia tem de ser gerada sempre antes do ensaio. Para manter as coisas justas, todos os métodos têm um passo pré-cópia para a lista da esquerda que pode ser ignorado.}

• Não utilize o método DUNDER list.__add__ directamente de qualquer forma, forma ou forma. Na verdade, fique longe dos métodos dunder, e use os operadores e as funções operator como eles foram projetados para. Python tem uma semântica cuidadosa cozida nestes que são mais complicados do que apenas chamar o dunder diretamente. Aqui está um exemplo. Assim, resumindo, a.__add__(b) = > mau; a + b = > bom.

• Algumas respostas aqui oferecem para parwise. concatenação -- isto é o mesmo que sum([a, b], []) só que mais wordy.

• Qualquer método que use set irá eliminar duplicados e perder a encomenda. Use com cuidado.

• for i in b: a.append(i) é mais wordy, e mais lento do que a.extend(b), que é chamada de função única e mais idiomática. append é mais lento por causa da semântica com a qual a memória é alocada e cultivada para listas. Veja aqui para uma discussão semelhante.

• heapq.merge vai funcionar, mas o seu caso de uso é para a junção de listas ordenadas em tempo linear. Usá-lo em qualquer outra situação é um anti-padrão.

• yielding list elements from a function is an acceptable method, but chain does this faster and better (it has a code path in C, so it is fast).

• operator.add(a, b) é um funcional aceitável equivalente a a + b. Os casos de uso são principalmente para envio de método dinâmico. Caso contrário, Prefiro {[15] } que é mais curto e legível, na minha opinião . MMMV.

Isto é muito simples, e acho que Até foi mostrado no tutorial :

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

Acho que a melhor opção é usar as compreensões da lista:

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

Você pode criar geradores também:

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

Resposta Antiga

Considere esta abordagem mais genérica:

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

Irá sair:

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

Nota, Isto também funciona correctamente quando a é [] ou [[1,2,3]].

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

Se não precisas de um list, mas apenas de um iterável, omite list().

Actualizar

sum(a, [])

Pode simplesmente utilizar o operador + ou += do seguinte modo:

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

c = a + b

Ou:

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

c += (a + b)

Também, se quiser que os valores da lista reunida sejam únicos, pode fazer:

c = list(set(a + b))

Vale a pena notar que a função itertools.chain aceita um número variável 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']

Se for iterável (tupla, lista, Gerador, etc.) is the input, the from_iterable class method may be used:

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

Com o Python 3. 3+ pode usar o rendimento 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]

Ou, se quiser apoiar um número arbitrário 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]

Se quiser juntar as duas listas de forma ordenada, poderá usar a função merge da Biblioteca heapq.

from heapq import merge

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

print list(merge(a, b))

Para os casos com um número reduzido de listas, poderá simplesmente adicionar as listas em conjunto ou usar a descompressão no local (disponível em 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 uma forma mais geral para casos com mais número de listas, como uma abordagem pythonic, você pode usar chain.from_iterable()¹ função do Módulo itertoold Além disso, com base Esta resposta {[13] } Esta função é a melhor; ou pelo menos uma maneira muito alimentar para aplanar uma lista aninhada também.

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

Se não puder usar o operador plus (+), pode usar o operator importar:

import operator

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

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

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

Em alternativa, também pode utilizar o __add__ dunder Função:

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

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

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

Se precisar de juntar duas listas ordenadas com regras de ordenação complicadas, poderá ter de a rolar por si próprio, como no seguinte código (usando uma regra de ordenação simples para a legibilidade: -).

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

Pode utilizar o método append() definido em list objectos:

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

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

O código acima, não preserva a ordem, remove duplicado de cada lista (mas não da lista concatenada)

Como já foi assinalado por muitos, itertools.chain()é o caminho a seguir se for necessário aplicar o mesmo tratamento a ambas as listas. No meu caso, eu tinha uma etiqueta e uma bandeira que eram diferentes de uma lista para a outra, então eu precisava de algo um pouco mais complexo. Ao que parece, nos bastidores {[2] } simplesmente faz o seguinte:

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

(Ver https://docs.python.org/2/library/itertools.html por isso, inspirei-me aqui e escrevi algo ao longo destes linhas:

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

Os pontos principais para entender aqui são que as listas são apenas um caso especial de iterable, que são objetos como qualquer outro; e que for ... in loops em python pode trabalhar com variáveis de tupla, então, é simples para repetir em várias variáveis ao mesmo tempo.

Usar uma simples compreensão de Lista:

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

Ele tem todas as vantagens da abordagem mais recente de usar generalizações adicionais de descompressão - isto é, você pode concatenar um número arbitrário de iterables diferentes (por exemplo, listas, tuplas, gamas e geradores) dessa forma - e não está limitado ao Python 3.5 ou mais tarde.

Se estiver a usar o NumPy, pode concatenar duas matrizes de dimensões compatíveis com este comando:

numpy.concatenate([a,b])

Uma forma realmente concisa de combinar uma lista de listas é

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

O que nos dá

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

1. Utilizar +: cria uma nova lista a partir das listas fornecidas

Exemplo:

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

1. Usando o extend : Ele adiciona uma nova lista à lista existente. Isso significa que não cria uma lista separada.

Exemplo:

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

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

 c=a+b
 print(c)

Resultado:

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

No código"+", o operador é utilizado para concatenar as 2 listas numa única lista.

OUTRA SOLUÇÃO:

 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)

Resultado:

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

Resultado:

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]

Manter os elementos duplicados

É muito fácil, apenas concatenate como string:

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

A seguir, se quiser 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

Pode usar a função union () em python.

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

Essencialmente o que isto está a fazer é remover uma de cada duplicado nas duas listas. Uma vez que suas listas não têm nenhum duplicado, ele apenas retorna a versão concatenada das duas listas.