ver Como concatenar duas listas em Python?




substituir valores numa lista python (23)

Como faço para concatenar duas listas em Python?

Exemplo:

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

Resultado esperado:

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

Estou surpreso, parece que ninguém propôs usar uma simples compreensão de lista :

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

Ele tem todas as vantagens da mais nova abordagem de usar Generalizações Adicionais de Desempacotamento - ou seja, você pode concatenar um número arbitrário de iteráveis ​​diferentes (por exemplo, listas, tuplas, intervalos, geradores) dessa maneira - e não está limitado a Python >= 3.5 .


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

mergedlist = list(set(listone + listtwo))

Como já foi apontado por muitos, itertools.chain() é o caminho a percorrer se é necessário aplicar exatamente o mesmo tratamento para ambas as 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

(veja https://docs.python.org/2/library/itertools.html ), então me inspirei aqui e escrevi algo ao longo destas 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 principais pontos a serem entendidos aqui são que as listas são apenas um caso especial de iteráveis, que são objetos como qualquer outro; e for ... in loops for ... in python podem trabalhar com variáveis ​​tuple, então é simples fazer loop em múltiplas variáveis ​​ao mesmo tempo.


Você pode ir para a função list.extend .

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

Saída:

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


Também é possível criar um gerador que simplesmente repita os itens nas duas listas. Isso permite encadear 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

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

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

mergedlist = listone + listtwo

Saída:

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

Você também pode usar extend para adicionar uma list adicionar o final de outro:

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

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

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

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

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

Alternativamente, se você não gosta do uso de dunders você pode usar a importação do operator :

import operator

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

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

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

Alguém poderia argumentar que isso é um pouco mais legível.


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 uma iterável (tupla, lista, gerador, etc.) for a entrada, o método da classe from_iterable 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']

Então, existem duas maneiras fáceis.

  1. Usando + : Cria uma nova lista 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 estender : Acrescenta 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

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


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 se juntar a muitas listas (incluindo o caso quando você entra na lista zero).

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

Note que isto 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 uma list , mas apenas uma list() iterável, omitir list() .

Atualizar

Alternativa sugerida por Patrick Collins nos comentários também poderia funcionar para você:

sum(a, [])

Isso é bem simples, acho que até foi mostrado no tutorial :

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

Se você quisesse 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

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

Embora esta seja uma resposta antiga, outra alternativa foi introduzida através da aceitação do PEP 448 que merece ser mencionado.

O PEP, intitulado Additional Unpacking Generalizations , geralmente reduzia algumas restrições sintáticas ao usar a expressão starred * no Python; com isso, juntar duas listas (aplica-se a qualquer iterável) agora também pode ser feito com:

>>> 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 funcionalidade foi definida para o Python 3.5 e não foi retornada para versões anteriores da família 3.x Em versões não suportadas, um SyntaxError será aumentado.

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 realizá-la, qualquer coisa que seja iterável fará. Como afirmado no PEP:

Isso também é útil como uma forma mais legível de somar os iteráveis ​​em uma 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 + aumentaria um TypeError devido à incompatibilidade de tipos:

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

O seguinte não irá:

res = [*l, *r]

porque ele primeiro descompactará o conteúdo dos iteráveis ​​e depois criará uma list do conteúdo.


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]

Você pode usar a função extends

listone.extends(listtwo)

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]

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

numpy.concatenate([a,b])

Como uma maneira mais geral para mais listas, você pode colocá-las dentro de uma lista e usar a função itertools.chain.from_iterable() que, baseada nesta resposta, é a melhor maneira de se planar 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 em python => 2.6.Em outras versões use chain(*l)


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

print (c) dá

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

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

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


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

Saída:

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]

Você poderia usar o método append() definido em objetos de list :

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




list