Como concatenar duas listas no Python?

Exemplo:

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

Resultado esperado:

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

Você pode usar o +operador para combiná-los:

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

joinedlist = listone + listtwo

Resultado:

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

Também é possível criar um gerador que simplesmente itere sobre os itens nas duas listas usando itertools.chain(). Isso permite que você encadeie listas (ou qualquer iterável) juntas para processamento sem copiar os itens para uma nova lista:

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

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

Outra alternativa foi introduzida através da aceitação da PEP 448qual merece menção.

O PEP, intitulado Generalizações adicionais de desempacotamento , geralmente reduzia algumas restrições sintáticas ao usar a *expressão estrelada em Python; Agora, a junção de duas listas (aplicável a qualquer iterável) agora também pode ser feita 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]

Essa funcionalidade foi definida para o Python3.5 e não foi suportada para versões anteriores da 3.xfamília. Nas versões não suportadas, um SyntaxErrorserá gerado.

Como nas outras abordagens, isso também cria uma cópia superficial dos elementos nas listas correspondentes.

A vantagem dessa abordagem é que você realmente não precisa de listas para executá-la, qualquer coisa iterável fará. Como afirmado no PEP:

Isso também é útil como uma maneira mais legível de resumir iteráveis ​​em uma lista, como a my_list + list(my_tuple) + list(my_range)que agora é equivalente a apenas [*my_list, *my_tuple, *my_range].

Portanto, enquanto a adição com +aumentaria uma TypeErrorincompatibilidade de tipo:

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

O seguinte não:

res = [*l, *r]

porque primeiro descompactará o conteúdo dos iterables e, em seguida, simplesmente criará um a listpartir do conteúdo.

Você pode usar conjuntos para obter uma lista mesclada de valores exclusivos

mergedlist = list(set(listone + listtwo))

Você também pode usar o list.extend()método para adicionar um listao final de outro:

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

listone.extend(listtwo)

Se você deseja manter intacta a lista original, é possível criar um novo listobjeto e as extendduas listas:

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

Como concatenar duas listas no Python?

A partir da versão 3.7, esses são os métodos stdlib mais populares para concatenar duas (ou mais) listas em python.

Notas de rodapé

1. Esta é uma solução esperta devido à sua sucessão. Mas sumexecuta a concatenação de maneira pareada, o que significa que esta é uma operação quadrática, pois a memória deve ser alocada para cada etapa. NÃO USE se suas listas forem grandes.

2. Veja chain e chain.from_iterable nos documentos. Você precisará import itertoolsprimeiro. A concatenação é linear na memória, portanto é o melhor em termos de desempenho e compatibilidade de versão. chain.from_iterablefoi introduzido no 2.6.

3. Este método usa Generalizações de Descompactação Adicional (PEP 448) , mas não pode generalizar para N listas, a menos que você descompacte manualmente cada uma delas.

4. a += be a.extend(b)são mais ou menos equivalentes para todos os fins práticos. +=quando chamado em uma lista chama internamente list.__iadd__, o que estende a primeira lista por segundo.

atuação

Concatenação de 2 listas ¹

Não há muita diferença entre esses métodos, mas isso faz sentido, pois todos eles têm a mesma ordem de complexidade (linear). Não há nenhuma razão específica para preferir uma à outra, exceto por uma questão de estilo.

Concatenação da lista N

Gráficos foram gerados usando o módulo perfplot . Código, para sua referência.

_{1. Os métodos iadd( +=) e extendoperam no local; portanto, uma cópia deve ser gerada todas as vezes antes do teste. Para manter as coisas justas, todos os métodos têm uma etapa de pré-cópia para a lista da esquerda que pode ser ignorada.}

Comentários sobre Outras Soluções

• NÃO UTILIZE O MÉTODO DUNDER list.__add__diretamente de forma alguma. De fato, evite métodos obscuros e use os operadores e operatorfunções para os quais foram projetados. O Python possui semântica cuidadosa incorporada a elas, que são mais complicadas do que apenas chamar o dunder diretamente. Aqui está um exemplo . Então, para resumir, a.__add__(b)=> MAU; a + b=> BOM.

• Algumas respostas aqui oferecem reduce(operator.add, [a, b])concatenação aos pares - isso é o mesmo que sum([a, b], [])apenas mais prolixo.

• Qualquer método que utiliza setdescarta duplicatas e perde pedidos. Use com cuidado.

• for i in b: a.append(i)é mais prolixo e mais lento que a.extend(b), que é chamada de função única e mais idiomático. appendé mais lento devido à semântica com a qual a memória é alocada e aumentada para listas. Veja aqui para uma discussão semelhante.

• heapq.mergefuncionará, mas seu caso de uso é para mesclar listas classificadas em tempo linear. Usá-lo em qualquer outra situação é um anti-padrão.

• yieldA entrada de elementos de lista de uma função é um método aceitável, mas chainé mais rápido e melhor (ele possui um caminho de código em C, portanto é rápido).

• operator.add(a, b)é um equivalente funcional aceitável para a + b. Seus casos de uso são principalmente para envio de método dinâmico. Caso contrário, prefiro o a + bque é mais curto e mais legível, na minha opinião . YMMV.

Isso é bem simples e acho que foi mostrado no tutorial :

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

Esta pergunta pergunta diretamente sobre a junção de duas listas. No entanto, é bastante alto na pesquisa, mesmo quando você está procurando uma maneira de ingressar em muitas listas (incluindo o caso ao ingressar em zero listas).

Eu acho que a melhor opção é usar a compreensão 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ê também pode criar geradores:

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

Saída:

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

Observe que isso também funciona corretamente quando aé []ou [[1,2,3]].

No entanto, isso pode ser feito de forma mais eficiente com itertools:

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

Se você não precisa de um list, mas apenas de um iterável, omita list().

Atualizar

A alternativa sugerida por Patrick Collins nos comentários também pode funcionar para você:

sum(a, [])

Você pode simplesmente usar o operador +ou da +=seguinte maneira:

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

c = a + b

Ou:

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

c += (a + b)

Além disso, se você deseja que os valores na lista mesclada sejam exclusivos, você pode:

c = list(set(a + b))

Vale ressaltar que a itertools.chainfunção aceita 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 uma iterável (tupla, lista, gerador, etc.) for a entrada, o from_iterablemétodo da classe pode ser usado:

>>> 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+, você 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 você deseja oferecer suporte a 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 você deseja mesclar as duas listas na forma classificada, você pode usar a mergefunção da heapqbiblioteca.

from heapq import merge

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

print list(merge(a, b))

Se você não pode usar o operador mais ( +), pode usar a operatorimportação:

import operator

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

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

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

Como alternativa, você também pode usar a função __add__ dunder :

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

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

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

Como uma maneira mais geral de obter mais listas, você pode colocá-las em uma lista e usar a função itertools.chain.from_iterable()¹ que, com base nesta resposta, é a melhor maneira de nivelar uma lista aninhada:

>>> 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. Observe que chain.from_iterable()está disponível no Python 2.6 e posterior. Em outras versões, use chain(*l).}

Se você precisar mesclar duas listas ordenadas com regras de classificação complicadas, talvez seja necessário rolar como no código a seguir (usando uma regra de classificação simples para facilitar a leitura :-)).

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

Você pode usar o append()método definido nos listobjetos:

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 duplicados de cada lista (mas não da lista concatenada)

Como já foi indicado por muitos, itertools.chain()é o caminho a percorrer se for necessário aplicar exatamente o mesmo tratamento às duas listas. No meu caso, eu tinha um rótulo e uma bandeira que eram diferentes de uma lista para outra, então eu precisava de algo um pouco mais complexo. Como se vê, nos bastidores itertools.chain()simplesmente faz o seguinte:

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

(consulte https://docs.python.org/2/library/itertools.html ), então me inspirei aqui e escrevi algo nesse 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
        [...]

Os principais pontos a serem entendidos aqui são que as listas são apenas um caso especial de iterável, que são objetos como qualquer outro; e que os for ... inloops em python podem funcionar com variáveis ​​de tupla, portanto, é simples fazer loop em várias variáveis ​​ao mesmo tempo.

Use uma compreensão simples da lista:

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

Ele tem todas as vantagens da abordagem mais recente do uso de Generalizações de Descompactação Adicionais - ou seja, você pode concatenar um número arbitrário de iteráveis ​​diferentes (por exemplo, listas, tuplas, intervalos e geradores) dessa maneira - e não se limita ao Python 3.5 ou posterior .

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

No Python, você pode concatenar duas matrizes de dimensões compatíveis com este comando

numpy.concatenate([a,b])

Portanto, existem duas maneiras fáceis.

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

2. Usando a extensão : anexa uma nova lista à lista existente. Isso significa que ele 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

Assim, vemos que, dentre os dois métodos mais populares, extendé eficiente.

Existem várias maneiras de concatenar listas em python.

l1 = [1,2,3,4]
l2 = [3,4,5,6]

 1. new_list = l1.copy()
    new_list = new_list.extend(l2)
 2. new_list = l1 + l2
 3. new_list = [*l1, *l2]

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]

Se você queria uma nova lista, mantendo as duas listas antigas:

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

    sorted(joinedList)

    return joinedList

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]

Você pode seguir o código

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

for i in listone:
    listtwo.append(i)
print(listtwo)

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