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]

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]

Il est également possible de créer un générateur qui itère simplement sur les éléments des deux listes à l'aide de itertools.chain(). Cela vous permet de chaîner des listes (ou tout 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

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

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

Le PEP, intitulé Additional Unpacking Generalizations , 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 3.xfamille. Dans les versions non prises en charge, un SyntaxErrorva être augmenté.

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

L' avantage 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 sommer les itérables dans une liste, comme celle my_list + list(my_tuple) + list(my_range)qui est maintenant équivalente à juste [*my_list, *my_tuple, *my_range].

Ainsi, alors que l'ajout avec +soulèverait une TypeErrorincompatibilité due au 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 à listpartir du contenu.

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

mergedlist = list(set(listone + listtwo))

Vous pouvez également utiliser la list.extend()méthode afin d'ajouter un listà la fin d'un autre:

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

listone.extend(listtwo)

Si vous souhaitez conserver la liste d'origine intacte, vous pouvez créer un nouvel listobjet et les extenddeux listes:

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

Comment concaténer deux listes en Python?

Depuis la version 3.7, ce sont les méthodes stdlib les plus populaires pour concaténer deux (ou plus) listes en python.

Notes de bas de page

1. Il s'agit d'une solution lisse en raison de sa brièveté. Mais sumeffectue la concaténation par paire, ce qui signifie qu'il s'agit d'une opération quadratique car la mémoire doit être allouée pour chaque étape. NE PAS UTILISER si vos listes sont grandes.

2. Voir chain et à chain.from_iterable partir des documents. Vous devrez d' import itertoolsabord. La concaténation est linéaire en mémoire, c'est donc le meilleur en termes de performances et de compatibilité de version. chain.from_iterablea été introduit en 2.6.

3. Cette méthode utilise des généralisations de décompactage supplémentaires (PEP 448) , mais ne peut pas généraliser à N listes, sauf si vous décompressez chacune manuellement vous-même.

4. a += bet a.extend(b)sont plus ou moins équivalents à toutes fins pratiques. +=lorsqu'il est appelé sur une liste, il appelle en interne list.__iadd__, ce qui étend la première liste par la seconde.

Performance

Concaténation 2 listes ¹

Il n'y a pas beaucoup de différence entre ces méthodes mais cela a du sens étant donné qu'elles ont toutes le même ordre de complexité (linéaire). Il n'y a aucune raison particulière de préférer l'un à l'autre, sauf pour une question de style.

Concaténation de N-List

Les tracés ont été générés à l'aide du module perfplot . Code, pour votre référence.

_{1. Le iadd( +=) et les extendméthodes fonctionnent en place, une copie doit donc être générée à chaque fois avant le test. Pour garder les choses justes, toutes les méthodes ont une étape de pré-copie pour la liste de gauche qui peut être ignorée.}

Commentaires sur d'autres solutions

• N'UTILISEZ PAS LA MÉTHODE DUNDER list.__add__directement de quelque manière, forme ou forme. En fait, évitez les méthodes de détournement et utilisez les opérateurs et les operatorfonctions pour lesquels ils ont été conçus. Python a une sémantique minutieuse intégrée à ceux-ci qui sont plus compliqués que d'appeler directement le connard. Voici un exemple . Donc, pour résumer, a.__add__(b)=> BAD; a + b=> BON.

• Certaines réponses offrent ici reduce(operator.add, [a, b])une concaténation par paire - c'est la même chose sum([a, b], [])que plus verbeux.

• Toute méthode qui utilise setsupprimera les doublons et perdra l'ordre. Utiliser avec précaution.

• for i in b: a.append(i)est plus verbeux et plus lent que a.extend(b), qui est un appel à fonction unique et plus idiomatique. appendest plus lent en raison de la sémantique avec laquelle la mémoire est allouée et développée pour les listes. Voir ici pour une discussion similaire.

• heapq.mergefonctionnera, mais son cas d'utilisation est pour la fusion de listes triées en temps linéaire. L'utiliser dans toute autre situation est un anti-modèle.

• yieldLier des éléments de liste à partir d'une fonction est une méthode acceptable, mais elle le chainfait plus rapidement et mieux (elle a un chemin de code en C, donc c'est rapide).

• operator.add(a, b)est un équivalent fonctionnel acceptable de a + b. Ses cas d'utilisation sont principalement pour l'envoi de méthode dynamique. Sinon, préférez a + bce qui est plus court et plus lisible, à mon avis . YMMV.

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]

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 listes de compréhension:

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

Notez que cela fonctionne également correctement lorsque aest []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().

Mise à jour

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

sum(a, [])

Vous pouvez simplement utiliser l' opérateur +or +=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))

Il convient de noter que la itertools.chainfonction 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 from_iterableméthode de classe 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']

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]

Si vous souhaitez fusionner les deux listes sous forme triée, vous pouvez utiliser la mergefonction de la heapqbibliothèque.

from heapq import merge

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

print list(merge(a, b))

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

import operator

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

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

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

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

Comme moyen plus général pour plus de listes, vous pouvez les mettre dans une liste et utiliser la fonction itertools.chain.from_iterable()¹ qui, sur la base de cette réponse, est le meilleur moyen d'aplatir 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 qu'il chain.from_iterable()est disponible dans Python 2.6 et versions ultérieures. Dans d'autres versions, utilisez chain(*l).}

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

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

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

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)

Comme plusieurs l'ont déjà souligné, itertools.chain()c'est la voie à suivre si l'on doit 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 fin de compte, dans les coulisses fait itertools.chain()simplement ce qui suit:

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

(voir https://docs.python.org/2/library/itertools.html ), donc 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 for ... inboucles en python peuvent fonctionner avec des variables de tuple, il est donc simple de boucler sur plusieurs variables en même temps.

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 généralisations de décompression 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 .

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]

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

numpy.concatenate([a,b])

Il y a donc deux façons simples.

1. Utilisation+ : il crée une nouvelle liste à partir des listes fournies

Exemple:

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. Utilisation de extend : il ajoute une nouvelle liste à la liste existante. Cela signifie qu'il ne crée pas de liste distincte.

Exemple:

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

Ainsi, nous voyons que sur deux des méthodes les plus populaires, extendest efficace.

Il existe plusieurs façons de concaténer des listes en 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))

Production:

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]

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

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]

Vous pouvez suivre le code

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

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

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