Como concatenar duas listas no Python?

2531

Como concatenar duas listas no Python?

Exemplo:

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

Resultado esperado:

>>> joinedlist
[1, 2, 3, 4, 5, 6]
y2k
fonte
6
Deseja simplesmente acrescentar ou deseja mesclar as duas listas em ordem de classificação ? Que resultado você espera para [1,3,6] e [2,4,5]? Podemos assumir que as duas sublistas já estão classificadas (como no seu exemplo)?
smci 12/09/15
1
... e se as listas tiverem duplicatas, por exemplo [1,2,5] and [2,4,5,6]? Deseja que as duplicatas sejam incluídas, excluídas ou não se importam?
smci 12/01

Respostas:

3905

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]
Daniel G
fonte
110
isso cria uma cópia profunda do listone e anexa listtwo?
Daniel F
152
@ Daniel criará uma nova lista com uma cópia superficial dos itens da primeira lista, seguida de uma cópia superficial dos itens da segunda lista. Use copy.deepcopy para obter cópias profundas das listas.
Daniel G
219
outro detalhe útil aqui: listone += listtworesulta emlistone == [1, 2, 3, 4, 5, 6]
rickcnagy
16
@ br1ckb0t isso mudará o que o listone está apontando? Então: a list3 = listone listone+=listtwo lista3 também mudou?
mikeh
11
ele muda list3. No entanto, se isso não for um problema, é mais fácil ler as duas listas em vez de criar uma nova.
Rickcnagy
319

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
Robert Rossney
fonte
4
chainestá no lado mais lento (mas não muito) para duas listas, mas é a solução mais rápida para encadear várias listas (n >> 2).
cs95
@ CS95 lento em comparação com o que?
Moberg
@Moberg Comparado a outras maneiras de concatenar listas, para referência, consulte meus benchmarks aqui .
cs95
265

>= 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.

Dimitris Fasarakis Hilliard
fonte
1
Um bom exemplo da abordagem de descompactação trabalhando em tipos iteráveis ​​são as funções que retornam um iterador sobre uma das listas que você está concatenando. Por exemplo, você poderia reverter uma das listas estiver concatenando: res = [*l1, *reversed(l2)]. Desde reversedretorna um iterador, res = l1 + reversed(l2)lançaria um erro.
alan
2
Vale a pena notar que isso é análogo à combinação de dicionário em python. dict3 = {** dict1, ** dict2}. Observe que usamos ** para descompactar os dicionários, enquanto que nas listas usamos * para descompactar.
Kevin S
213

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

mergedlist = list(set(listone + listtwo))
Radagast
fonte
45
É verdade, no entanto, ele também removerá duplicatas, se é disso que você está interessado. A adição de listas não faria isso.
metasoarous 21/08/2012
1
Qual é a maneira de fazer isso e manter as informações sobre pedidos?
Natim
11
Melhor quelistone + [x for x in listtwo if x not in listone]
Natim
8
+1 IMHO esta é a maneira correta de "merge" (união) listas, enquanto a resposta "aprovado" descreve como combinar / adicionar listas (multiset)
alfasin
2
Se você se preocupa em manter a ordem de entrada, import collections; mergedlist = list(collections.OrderedDict.fromkeys(listone + listtwo))fará o truque.
SethMMorton
186

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)
Gourneau
fonte
82

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.

insira a descrição da imagem aqui

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 1

insira a descrição da imagem aqui

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

insira a descrição da imagem aqui

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.

cs95
fonte
as respostas para stackoverflow.com/q/36863404/125507 poderia usar um enredo perfplot (incluindo a solução numba)
endolith
O @ endolith se encheu de trabalho, mas vou dar uma olhada e ver se consigo entrar. Ty.
cs95
qual é o melhor método para o desempenho, mais rápido? por favor diga.
ganeshdeshmukh
@ganeshdeshmukh O TL; DR é tudo de bom e o que você escolhe é principalmente uma questão de estilo. "There's not much difference between these methods but that makes sense given they all have the same order of complexity (linear). There's no particular reason to prefer one over the other except as a matter of style."Soluções não listadas na minha resposta ou criticadas em" Comentários "eu recomendo não usar.
cs95
78

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]
Tuure Laurinolli
fonte
51

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, [])
wonder.mice
fonte
3
Nota do Python 3: reduceagora está no functoolsmodo , então você precisará importá-lo primeiro.
Dimitris Fasarakis Hilliard
41

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))
Um mito
fonte
A última parte pode reordenar arbitrariamente os itens. Se você quiser preservar a ordem, em CPython 3.6+ você pode fazerlist(dict.fromkeys(a + b))
Boris
27

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']
Dariusz Walczak
fonte
22

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]

fonte
Você pode usar itertools.chain(que é equivalente) em vez de definir sua própria função.
224 de Boris
18

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))
lavee_singh
fonte
15

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]
jpihl
fonte
3
agarrar dunders geralmente não é a melhor abordagem. Se +estiver fora da mesa, use operator.add.
Dimitris Fasarakis Hilliard
2
Por que o operador positivo não está disponível?
CS01
2
Normalmente não seria :) mas se você estiver fazendo uma concatenação de lista com a função map ou quiser armazenar a função add em uma variável, não poderá usar +.
jpihl
13

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()1 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).

Kasramvd
fonte
10

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])
Mr Shark
fonte
Ou apenas use heapq.merge.
cs95
7

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)
mingxiao
fonte
9
só para você saber, se é isso que você está fazendo na prática, isso é muito, muito mais lento que os outros métodos propostos. veja stackoverflow.com/questions/17479361/...
Ryan Haining
7
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)

Super Nova
fonte
6

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.

Francesco Marchetti-Stasi
fonte
5

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 .

z33k
fonte
4

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]
Akash Singh
fonte
Por favor, não use list.__add__, use em operator.addvez disso. Este é o equivalente mais prolixo do sum(list_of_lists, [])que é tão ruim. NÃO USE!
cs95
@ cs95 você pode explicar o que é o problema usando lista .__ add__
Akash Singh
Os métodos dunder são "métodos privados" e normalmente não devem ser usados ​​diretamente (são chamados por outras funções). Exceções são obj.__class__e obj.__dict__.
cs95
3

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

numpy.concatenate([a,b])
Michael Grossmann
fonte
4
A pergunta não pede dormência.
cs95
2

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
  1. 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.

Vishvajit Pathak
fonte
2
E se eu precisar adicionar várias listas, como a + b + c + d + e?
Tweakimp 11/03/19
2
@ Tweakimp Veja esta resposta que tem algumas opções (eu recomendo chain.from_iterable).
cs95
2

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]
chatrapathi
fonte
1
Você poderia explicar que novas informações esta resposta fornece sobre as outras?
cs95
Existem várias maneiras de concatenar listas em python - todas abordadas extensivamente em outras respostas muito mais antigas. Que novas informações isso fornece ??
Tomerikoo
-1
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]
JamesVeug
fonte
-1

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
Ukendar Vadivel
fonte
Qual é a diferença dessa resposta por mingxiao?
Tomerikoo
-2
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]
James Miller
fonte
4
Bem, por favor, faça algumas explicações
U10-Forward
Qual é o sentido dos argumentos da função se você estiver usando os nomes globais dentro dela?
Tomerikoo
-2

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