Vraag Hoe twee lijsten samen te voegen in Python?

Het is ook mogelijk om een ​​generator te maken die eenvoudigweg itereert over de items in beide lijsten. Hiermee kunt u lijsten (of een iterabel) samen ketenen voor verwerking zonder de items naar een nieuwe lijst te kopiëren:

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

U kunt sets gebruiken om een ​​samengevoegde lijst met unieke waarden te verkrijgen

mergedlist = list(set(listone + listtwo))

Je zou ook kunnen gebruiken extend om een ​​toe te voegen list voeg het einde toe van een andere:

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

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

Hoewel dit een oud antwoord is, is een ander alternatief geïntroduceerd via de acceptatie van PEP 448 die het verdient te vermelden.

De PEP, getiteld Aanvullende generalisaties voor uitpakken, verminderde in het algemeen enkele syntactische beperkingen bij het gebruik van de ster * expressie in Python; hiermee kan het meedoen aan twee lijsten (van toepassing op elke iterable) nu ook worden gedaan met:

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

Deze functionaliteit werd gedefinieerd voor Python 3.5 het is niet teruggezet naar vorige versies in de 3.x familie. In niet-ondersteunde versies a SyntaxError zal worden verhoogd.

Net als bij de andere benaderingen, ook dit maakt als ondiepe kopie van de elementen in de overeenkomstige lijsten.

De bovenkant aan deze benadering is dat je echt geen lijsten nodig hebt om het uit te voeren, alles wat iterabel is zal het doen. Zoals vermeld in de PEP:

Dit is ook handig als een beter leesbare manier om iterables op te sommen in een   lijst, zoals my_list + list(my_tuple) + list(my_range) wat nu is   gelijk aan rechtvaardig [*my_list, *my_tuple, *my_range].

Dus terwijl toevoeging met + zou verhogen TypeError vanwege type mismatch:

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

Het volgende zal niet:

res = [*l, *r]

omdat het eerst de inhoud van de iterables zal uitpakken en dan gewoon een list van de inhoud.

Dit is vrij eenvoudig, ik denk dat het zelfs werd getoond in de zelfstudie:

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

Je zou gewoon de + of += operator als volgt:

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

c = a + b

Of:

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

c += (a + b)

Als u wilt dat de waarden in de samengevoegde lijst uniek zijn, kunt u ook het volgende doen:

c = list(set(a + b))

Deze vraag stelt direct de vraag of je lid wilt worden van twee lijsten. Het is echter vrij hoog in zoeken, zelfs als u op zoek bent naar een manier om lid te worden van veel lijsten (inclusief het geval wanneer u deelneemt aan nullijsten). Overweeg deze meer generieke aanpak:

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

Zal output:

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

Let op, dit werkt ook correct wanneer a is [] of [[1,2,3]].

Dit kan echter efficiënter worden gedaan met itertools:

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

Als je geen a nodig hebt list, maar gewoon een iterabele, weglaten list().

Bijwerken

Alternatief voorgesteld door Patrick Collins in de opmerkingen zou ook voor u kunnen werken:

sum(a, [])

Het is vermeldenswaard dat de itertools.chain functie accepteert variabel aantal argumenten:

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

Als een iterabele (tuple, lijst, generator, etc.) de invoer is, de from_iterable klassemethode mag worden gebruikt:

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

Met Python 3.3+ kunt u gebruiken opbrengst van:

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]

Of, als u een willekeurig aantal iterators wilt ondersteunen:

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]

Als u de twee lijsten in gesorteerde vorm wilt samenvoegen, kunt u de samenvoegfunctie uit de heapq-bibliotheek gebruiken.

from heapq import merge

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

print list(merge(a,b))