Comment concaténer deux listes en Python?

Exemple:

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

Résultat attendu:

>>> joinedlist
[1, 2, 3, 4, 5, 6]
2398
y2k 12 nov. 2009 à 10:04

23 réponses

Meilleure réponse

Vous pouvez utiliser l'opérateur + pour les combiner:

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

joinedlist = listone + listtwo

Production:

>>> joinedlist
[1,2,3,4,5,6]
3721
TrebledJ 7 juin 2019 à 06:45

Alternative >= 3.5 en Python: [*l1, *l2]

Une autre alternative a été introduite via l'acceptation de PEP 448 qui mérite d'être mentionné.

Le PEP, intitulé Généralisations de déballage supplémentaires , a généralement réduit certaines restrictions syntaxiques lors de l'utilisation de l'expression * étoilée en Python; avec elle, la jonction de deux listes (s'applique à tout itérable) peut désormais aussi se faire avec:

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

Cette fonctionnalité a été définie pour Python 3.5 , elle n'a pas été rétroportée vers les versions précédentes de la famille 3.x. Dans les versions non prises en charge, un SyntaxError va être généré.

Comme pour les autres approches, cela crée également une copie superficielle des éléments dans les listes correspondantes.


L'inconvénient de cette approche est que vous n'avez vraiment pas besoin de listes pour l'exécuter, tout ce qui est itérable fera l'affaire. Comme indiqué dans le PEP:

Ceci est également utile comme moyen plus lisible de résumer les itérables en un telle que my_list + list(my_tuple) + list(my_range) qui est maintenant équivalent à seulement [*my_list, *my_tuple, *my_range].

Ainsi, si l'ajout avec + soulèverait un TypeError en raison de la différence de type:

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

Les éléments suivants ne seront pas:

res = [*l, *r]

Car il déballera d'abord le contenu des itérables puis créera simplement un list à partir du contenu.

228
Boris 22 nov. 2019 à 12:44

Si vous devez fusionner deux listes ordonnées avec des règles de tri complexes, vous devrez peut-être les faire rouler vous-même comme dans le code suivant (en utilisant une règle de tri simple pour plus de lisibilité :-)).

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])
10
Peter Mortensen 22 déc. 2013 à 09:23

Une façon très concise de combiner une liste de listes est

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

Ce qui nous donne

[1, 2, 3, 4, 5, 6, 7, 8, 9]
4
Akash Singh 29 juin 2018 à 12:16

Vous pouvez utiliser des ensembles pour obtenir une liste fusionnée de valeurs uniques

mergedlist = list(set(listone + listtwo))
203
thefourtheye 2 avril 2014 à 07:28
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]
-2
Dimitris Fasarakis Hilliard 4 juil. 2017 à 12:00

En Python, vous pouvez concaténer deux tableaux de dimensions compatibles avec cette commande

numpy.concatenate([a,b])
3
AkshayNevrekar 3 oct. 2018 à 07:43

Si vous souhaitez fusionner les deux listes sous forme triée, vous pouvez utiliser la fonction merge de la bibliothèque heapq.

from heapq import merge

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

print list(merge(a, b))
18
Peter Mortensen 17 mars 2019 à 09:19

Il est également possible de créer un générateur qui itère simplement sur les éléments des deux listes en utilisant {{ X0}}. Cela vous permet de chaîner des listes (ou tout autre itérable) ensemble pour les traiter sans copier les éléments dans une nouvelle liste:

import itertools
for item in itertools.chain(listone, listtwo):
    # Do something with each list item
302
Boris 22 nov. 2019 à 12:53

Utilisez une compréhension de liste simple:

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

Il présente tous les avantages de la nouvelle approche d'utilisation des Généralisations de déballage supplémentaires - c'est-à-dire que vous pouvez concaténer un nombre arbitraire d'itérables différents (par exemple, des listes, des tuples, des plages et des générateurs) de cette façon - et ce n'est pas limité à Python 3.5 ou version ultérieure.

5
z33k 23 avril 2019 à 20:39

Il convient de noter que la fonction itertools.chain accepte un nombre variable d'arguments:

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

Si un itérable (tuple, liste, générateur, etc.) est l'entrée, la méthode de classe from_iterable peut être utilisée:

>>> il = [['a'], ['b', 'c'], ['d', 'e', 'f']]
>>> [i for i in itertools.chain.from_iterable(il)]
['a', 'b', 'c', 'd', 'e', 'f']
27
Dariusz Walczak 5 févr. 2013 à 05:01

Si vous vouliez une nouvelle liste tout en conservant les deux anciennes listes:

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

    sorted(joinedList)

    return joinedList
-1
Ukendar Vadivel 31 juil. 2018 à 09:35

Vous pouvez également utiliser extend afin pour ajouter un list à la fin d'un autre:

listone = [1,2,3]
listtwo = [4,5,6]
mergedlist = []
mergedlist.extend(listone)
mergedlist.extend(listtwo)
171
3 revs, 2 users 76% 17 mai 2019 à 00:30

Vous pouvez simplement utiliser l'opérateur + ou += comme suit:

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

c = a + b

Ou:

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

c += (a + b)

De plus, si vous voulez que les valeurs de la liste fusionnée soient uniques, vous pouvez faire:

c = list(set(a + b))
40
Peter Mortensen 22 déc. 2013 à 09:21

Comme plusieurs l'ont déjà souligné, itertools.chain() est la voie à suivre s'il faut appliquer exactement le même traitement aux deux listes. Dans mon cas, j'avais une étiquette et un drapeau qui étaient différents d'une liste à l'autre, j'avais donc besoin de quelque chose d'un peu plus complexe. En fait, dans les coulisses itertools.chain() fait simplement ce qui suit:

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

(voir https://docs.python.org/2/library/itertools.html), alors je me suis inspiré d'ici et j'ai écrit quelque chose dans ce sens:

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

Les principaux points à comprendre ici sont que les listes ne sont qu'un cas particulier d'itérables, qui sont des objets comme les autres; et que les boucles for ... in en python peuvent fonctionner avec des variables de tuple, il est donc simple de boucler sur plusieurs variables en même temps.

6
Francesco Marchetti-Stasi 2 nov. 2015 à 18:59

Cette question pose directement la question de joindre deux listes. Cependant, il est assez élevé dans la recherche même lorsque vous recherchez un moyen de joindre de nombreuses listes (y compris le cas lorsque vous rejoignez des listes nulles).

Je pense que la meilleure option est d'utiliser des compréhensions de liste:

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

Vous pouvez également créer des générateurs:

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

Ancienne réponse

Considérez cette approche plus générique:

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

Sortira:

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

Remarque, cela fonctionne également correctement lorsque a est [] ou [[1,2,3]].

Cependant, cela peut être fait plus efficacement avec itertools:

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

Si vous n'avez pas besoin d'un list, mais simplement d'un itérable, omettez list().

Mettre à jour

L'alternative suggérée par Patrick Collins dans les commentaires pourrait également vous convenir:

sum(a, [])
50
wonder.mice 4 sept. 2018 à 18:15

C'est assez simple, et je pense que cela a même été montré dans le tutoriel:

>>> listone = [1,2,3]
>>> listtwo = [4,5,6]
>>>
>>> listone + listtwo
[1, 2, 3, 4, 5, 6]
76
Peter Mortensen 17 mars 2019 à 09:15

Vous pouvez utiliser la méthode append() définie sur les objets list:

mergedlist =[]
for elem in listone:
    mergedlist.append(elem)
for elem in listtwo:
    mergedlist.append(elem)
7
Dimitris Fasarakis Hilliard 5 mai 2016 à 09:05

Si vous ne pouvez pas utiliser l'opérateur plus (+), vous pouvez utiliser l'importation operator:

import operator

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

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

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

Vous pouvez également utiliser la fonction __add__ dunder:

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

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

>>> [1, 2, 3, 4, 5, 6]
15
jpihl 4 juin 2019 à 07:09

Avec Python 3.3+, vous pouvez utiliser le rendement 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, si vous souhaitez prendre en charge un nombre arbitraire d'itérateurs:

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]
22
user688635user688635 21 juil. 2014 à 00:53
list(set(listone) | set(listtwo))

Le code ci-dessus, ne préserve pas l'ordre, supprime les doublons de chaque liste (mais pas de la liste concaténée)

7
SuperNova 7 juil. 2016 à 07:42
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))

Sortie:

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]
-1
JamesVeug 16 févr. 2018 à 03:46

De manière plus générale pour plus de listes, vous pouvez les placer dans une liste et utiliser la fonction itertools.chain.from_iterable() 1 qui repose sur cette réponse est le meilleur moyen d'aplanir une liste imbriquée:

>>> 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. Notez que chain.from_iterable() est disponible dans Python 2.6 et versions ultérieures. Dans les autres versions, utilisez chain(*l).

13
Peter Mortensen 17 mars 2019 à 09:18