Comment concaténer deux listes en Python?
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
Sortie:
>>> 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. Cela vous permet de chaîner des listes (ou tout élément éditable) ensemble pour un traitement sans copier les éléments dans une nouvelle liste:
import itertools
for item in itertools.chain(listone, listtwo):
# Do something with each list item
Vous pouvez utiliser des ensembles pour obtenir une liste fusionnée de valeurs uniques
mergedlist = list(set(listone + listtwo))
Python _>= 3.5_ alternative: _[*l1, *l2]_
Même s'il s'agit d'une réponse ancienne, 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écompression supplémentaires , a généralement réduit certaines restrictions syntaxiques lors de l’utilisation de la classe étoilée _*_ expression en Python; avec elle, il est désormais possible de joindre deux listes (s’applique à toutes les variables):
_>>> 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]
_Cette fonctionnalité a été définie pour Python _3.5_ et n'a pas été restituée aux versions précédentes de la famille _3.x_. Dans les versions non prises en charge, une SyntaxError va être levée.
Comme avec les autres approches, ceci aussi crée 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ératif fera l'affaire. Comme indiqué dans le PEP:
Ceci est également utile en tant que moyen plus lisible de sommer des itérables dans une liste, telle que
my_list + list(my_Tuple) + list(my_range), qui est maintenant équivalente à juste _[*my_list, *my_Tuple, *my_range]_.
Ainsi, si l’ajout de _+_ soulève un TypeError en raison d’une incompatibilité de type:
_l = [1, 2, 3]
r = range(4, 7)
res = l + r
_Ce qui suit ne:
_res = [*l, *r]
_car il va d'abord décompresser le contenu des itérables, puis créer simplement un list à partir du contenu.
Vous pouvez aussi utiliser extend afin d’ajouter un list à la fin d’un autre:
listone = [1,2,3]
listtwo = [4,5,6]
mergedlist = []
mergedlist.extend(listone)
mergedlist.extend(listtwo)
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 concerne directement l’adhésion à deux listes. Cependant, le niveau de recherche est élevé, même lorsque vous cherchez un moyen de rejoindre plusieurs listes (y compris le cas où vous rejoignez des listes zéro).
Je pense que la meilleure option consiste à utiliser les 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, [])
Est-ce que la sortie:
[1, 2, 3, 4, 5, 6, 7, 8, 9]
Notez que cela fonctionne également correctement lorsque a est [] ou [[1,2,3]].
Cependant, ceci 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ératif, omettez list().
Mise à jour
La variante suggérée par Patrick Collins dans les commentaires pourrait également fonctionner pour vous:
sum(a, [])
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 même, si vous souhaitez que les valeurs de la liste fusionnée soient uniques, vous pouvez procéder comme suit:
c = list(set(a + b))
Il est à 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 une entrée est itérable (tuple, liste, générateur, etc.), 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']
Avec Python 3.3+, vous pouvez utiliser 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]
Comment concaténer deux listes en Python?
Depuis la version 3.7, ce sont les méthodes stdlib les plus répandues pour concaténer deux listes (ou plus) en python.
Notes de bas de page
C'est une solution astucieuse en raison de sa brièveté. Mais
sumexécute la concaténation par paires, 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.Voir
chainetchain.from_iterablede la documentation. Vous aurez besoin de _import itertools_ en premier. La concaténation est linéaire en mémoire, ce qui en fait le meilleur en termes de performances et de compatibilité des versions. _chain.from_iterable_ a été introduit dans 2.6.Cette méthode utilise Généralisations de décompression supplémentaires (PEP 448) , mais ne peut pas généraliser en N listes à moins de les décompresser manuellement vous-même.
_
a += b_ eta.extend(b)sont plus ou moins équivalents à toutes fins utiles. _+=_ lorsqu'il est appelé sur une liste appelle en interne _list.__iadd___, qui étend la première liste par la seconde.
Performance
Concaténation de 2 listes 1
Concaténation de la liste noire
Les tracés ont été générés à l'aide du module perfplot . Code, pour votre référence.
1. Les méthodes iadd (_+=_) et extend fonctionnent sur place. Par conséquent, une copie doit être générée à chaque fois avant le test. Pour que tout soit juste, 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 que ce soit. En fait, éloignez-vous des méthodes de dunder et utilisez les opérateurs et les fonctionsoperatorcomme ils ont été conçus. Python utilise une sémantique soignée qui est plus compliquée que d'appeler directement le dunder. Voici n exemple . Donc, pour résumer,a.__add__(b)=> BAD; _a + b_ => BON.Certaines réponses ici proposent
reduce(operator.add, [a, b])pour la concaténation par paires - c'est la même chose quesum([a, b], [])seulement plus verbeuse.Toute méthode qui utilise
setsupprime les doublons et perd la commande. Utiliser avec précaution.for i in b: a.append(i)est plus verbeux et plus lent quea.extend(b), qui est un appel à une seule fonction 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.merge_ fonctionnera, mais son cas d'utilisation est la fusion de listes triées dans le temps linéaire. L'utiliser dans toute autre situation est un anti-modèle.yielding liste des éléments d'une fonction est une méthode acceptable, maischainle fait plus rapidement et mieux (il a un chemin de code en C, il est donc rapide).operator.add(a, b)est un équivalent fonctionnel acceptable de _a + b_. Ses cas d'utilisation concernent principalement l'envoi de méthodes dynamiques. Sinon, préférez _a + b_ qui est plus court et plus lisible, à mon avis . YMMV.
Vous pouvez choisir la fonction list.extend .
_l1 = [1,2,3]
l2 = [4,5,6]
l1.extend(l2)
print l1
_Sortie:
_[1,2,3,4,5,6]_
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))
Si vous ne pouvez pas utiliser l'opérateur plus (+), vous pouvez utiliser le fichier operator import:
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]
De manière plus générale, vous pouvez les insérer dans une liste et utiliser la itertools.chain.from_iterable()1 fonction qui repose sur la réponse this est le meilleur moyen de mettre à plat 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).
Si vous avez besoin de fusionner deux listes ordonnées avec des règles de tri compliquées, vous devrez peut-être le faire vous-même, comme dans le code suivant (en utilisant une règle de tri simple pour la 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])
Rejoindre deux listes en Python:
>>> a = [1, 2, 3, 4]
>>> b = [1, 4, 6, 7]
>>> c = a + b
>>> c
[1, 2, 3, 4, 1, 4, 6, 7]
Si vous ne voulez pas de duplication:
>>> a = [1, 2, 3, 4, 5, 6]
>>> b = [5, 6, 7, 8]
>>> c = list(set(a + b))
>>> c
[1, 2, 3, 4, 5, 6, 7, 8]
list(set(listone) | set(listtwo))
Le code ci-dessus, ne conserve pas l'ordre, supprime les doublons de chaque liste (mais pas de la liste concaténée)
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)
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 différaient d'une liste à l'autre, donc j'avais besoin de quelque chose de légèrement plus complexe. Il se trouve que, en coulisse, 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 ), donc je me suis inspiré d'ici pour écrire 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 points principaux à comprendre ici sont que les listes ne sont qu’un cas particulier d’itéré, qui sont des objets comme les autres; et que for ... in boucles en python peuvent fonctionner avec des variables Tuple, il est donc simple de mettre en boucle plusieurs variables en même temps.
Pour étendre une liste avec une autre, il existe plusieurs méthodes, comme ci-dessous:
>>> listone = [1,2,3]
>>> listome = [4,5,6]
>>>
>>> listone+listome # adding 2 list is actually extending the list
[1, 2, 3, 4, 5, 6]
>>>
>>> listone.extend(listome)
>>> listone
[1, 2, 3, 4, 5, 6]
>>>
>>> listone = [1,2,3]
>>>
>>> listone.__add__(listome)
[1, 2, 3, 4, 5, 6]
De plus, for loop peut également être utilisé:
>>> for i in listome:
... listone.append(i)
...
>>> listone
[1, 2, 3, 4, 5, 6]
>>>
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 dernière approche consistant à utiliser Généralisations de décompression supplémentaires - vous pouvez ainsi concaténer un nombre arbitraire d'itérables différents (par exemple, des listes, des n-uplets, des plages et des générateurs) de cette façon - et c'est non limité à Python 3.5 ou version ultérieure.
Dans Python, vous pouvez concaténer deux tableaux de dimensions compatibles avec cette commande
numpy.concatenate([a,b])
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]
Vous pouvez utiliser l'opérateur '+' pour concaténer deux listes en Python:
>>> listone = [1,2,3]
>>> listtwo = [4,5,6]
>>>
>>> listSum = []
>>> listSum = listone + listtwo
>>> print(listSum)
[1, 2, 3, 4, 5, 6]
Donc, il y a deux façons simples.
- sing
+: 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
- sing extend: Ajoute une nouvelle liste à la liste existante. Cela signifie que cela ne crée pas de liste séparée.
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
Nous voyons donc que sur deux des méthodes les plus populaires, extend est efficace.
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]
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]
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