Python'da iki listeyi nasıl birleştirebilirim?

Misal:

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

Beklenen sonuç:

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

Bunları +birleştirmek için operatörü kullanabilirsiniz :

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

joinedlist = listone + listtwo

Çıktı:

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

Her iki listedeki öğeler üzerinde sadece yinelenen bir jeneratör oluşturmak da mümkündür itertools.chain(). Bu, öğeleri yeni bir listeye kopyalamadan işlem yapmak için listeleri (veya yinelenebilir) birlikte zincirlemenizi sağlar:

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

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

PEP 448Bahsetmeyi hak eden başka bir alternatif kabul edilmiştir .

Ek Açma Genelleştirmeleri başlıklı PEP, *Python'da yıldızlı ifadeyi kullanırken genellikle bazı sözdizimsel kısıtlamaları azalttı ; bununla birlikte, iki listeye katılmak (herhangi bir yinelenebilir için geçerlidir) artık aşağıdakilerle de yapılabilir:

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

Bu işlevsellik , Python3.5 için tanımlanmış ve 3.xailenin önceki sürümlerine bildirilmemiştir . Desteklenmeyen versiyonlarda a SyntaxErroryükseltilecektir.

Diğer yaklaşımlarda olduğu gibi, bu da ilgili listelerdeki öğelerin sığ bir kopyası olarak oluşturulur .

Ters Bu yaklaşıma Gerçekten gerçekleştirmek için, iterable yapacak olan hiçbir şeye gerek listeleri yapmak olmasıdır. KEP'de belirtildiği gibi:

Bu aynı zamanda örneğin bir liste içine Iterables toplayarak bir daha okunabilir bir yolu olarak yararlıdır my_list + list(my_tuple) + list(my_range)şimdi sadece eşdeğerdir hangi [*my_list, *my_tuple, *my_range].

İle ilave süre Yani +bir gündeme getireceğini TypeErroruyuşmazlığı yazın dolayı:

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

Aşağıdakiler olmaz:

res = [*l, *r]

çünkü ilk önce yinelenenlerin içeriğini açacak ve daha sonra listiçeriklerden bir tane oluşturacaktır .

Birleştirilmiş benzersiz değerlerin listesini elde etmek için kümeleri kullanabilirsiniz

mergedlist = list(set(listone + listtwo))

list.extend()Yöntemi, bir listbaşkasının sonuna a eklemek için de kullanabilirsiniz :

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

listone.extend(listtwo)

Orijinal listeyi olduğu gibi tutmak istiyorsanız, yeni bir listnesne oluşturabilirsiniz ve extendher iki liste de listeyi oluşturabilir:

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

Python'da iki listeyi nasıl birleştirebilirim?

3.7 itibariyle, bunlar python'da iki (veya daha fazla) listeyi birleştirmek için en popüler stdlib yöntemleridir.

Dipnotlar

1. Bu, özlü olması nedeniyle kaygan bir çözümdür. Ancak sumbirleştirmeyi ikili bir şekilde gerçekleştirir, yani her adım için bellek tahsis edilmesi gerektiğinden bu ikinci dereceden bir işlemdir. Listeleriniz büyükse KULLANMAYIN.

2. Bkz chain ve chain.from_iterable dokümanlardan. Önce yapmanız gerekecek import itertools. Birleştirme bellekte doğrusaldır, bu nedenle performans ve sürüm uyumluluğu açısından en iyisi budur. chain.from_iterable2.6 yılında tanıtıldı.

3. Bu yöntemde, Ek Paketinden Çıkarma Genelleştirmeleri (PEP 448) kullanılır , ancak her birini kendiniz elle paketlemediğiniz sürece N listeye genelleme yapılamaz.

4. a += bve a.extend(b)tüm pratik amaçlar için aşağı yukarı eşdeğerdir. +=bir listede çağrıldığında dahili olarak çağrılacak ve list.__iadd__bu ilk listeyi ikinci listeye genişletecektir.

Verim

2 Liste Birleştirme ¹

Bu yöntemler arasında çok fazla fark yoktur, ancak hepsinin aynı karmaşıklık düzenine (doğrusal) sahip olması mantıklıdır. Bir stil meselesi dışında birini tercih etmek için özel bir neden yoktur.

N-Listesi Birleştirme

Parseller perfplot modülü kullanılarak oluşturulmuştur . Referans için kod.

_{1. iadd( +=) ve extendyöntemler yerinde çalışır, bu nedenle testten önce her seferinde bir kopya oluşturulmalıdır. İşleri adil tutmak için, tüm yöntemlerin soldaki liste için göz ardı edilebilecek bir ön kopya adımı vardır.}

Diğer Çözümler için yorumlar

• DUNDER YÖNTEMİNİ list.__add__doğrudan hiçbir şekilde, şekilde veya biçimde KULLANMAYIN . Aslında, şimşek yöntemlerinden uzak durun ve operatörleri ve operatorişlevleri tasarlandıkları gibi kullanın . Python, bunlara pişmiş, sadece doğrudan şimşek çağırmaktan daha karmaşık olan dikkatli semantiklere sahiptir. İşte bir örnek . Özetlemek gerekirse, a.__add__(b)=> KÖTÜ; a + b=> İYİ.

• Buradaki bazı cevaplar reduce(operator.add, [a, b])ikili birleştirme için sunulur - bu sum([a, b], [])sadece daha fazla kelime ile aynıdır .

• Kullanan herhangi bir yöntem, setkopyaları bırakır ve sıralamayı kaybeder. Dikkatle kullanın.

• for i in b: a.append(i)a.extend(b)tek işlev çağrısı ve daha deyimsel olandan daha garip ve daha yavaştır . appendhafızanın listeler için ayrıldığı ve büyüdüğü semantikler nedeniyle daha yavaştır. Benzer bir tartışma için buraya bakın .

• heapq.mergeçalışır, ancak kullanım durumu sıralı listeleri doğrusal zamanda birleştirmektir. Başka herhangi bir durumda kullanmak bir anti-kalıptır.

• yieldBir fonksiyondan liste öğelerinin chaingirilmesi kabul edilebilir bir yöntemdir, ancak bunu daha hızlı ve daha iyi yapar (C'de bir kod yolu vardır, bu yüzden hızlıdır).

• operator.add(a, b)kabul edilebilir bir işlevsel eşdeğerdir a + b. Kullanım durumları esas olarak dinamik yöntem gönderimi içindir. Aksi takdirde, bencea + b daha kısa ve daha okunabilir olanı tercih edin . YMMV.

Bu oldukça basit ve hatta öğreticide gösterildiğini düşünüyorum :

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

Bu soru doğrudan iki listeye katılmayı soruyor. Ancak, birçok listeye katılmanın bir yolunu ararken bile (sıfır listeye katıldığınızda dahil) arama oldukça yüksektir.

Bence en iyi seçenek liste anlamalarını kullanmaktır:

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

Jeneratörler de oluşturabilirsiniz:

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

Eski Cevap

Bu daha genel yaklaşımı düşünün:

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

Çıktı olacak:

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

Bu da düzgün çalışır, Not aolduğu []veya [[1,2,3]].

Bununla birlikte, bu daha verimli bir şekilde yapılabilir itertools:

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

Bir list, ama sadece bir yinelemeye ihtiyacınız yoksa, atlayın list().

Güncelleme

Yorumlarda Patrick Collins tarafından önerilen alternatif sizin için de işe yarayabilir:

sum(a, [])

+Veya +=işlecini aşağıdaki gibi kullanabilirsiniz :

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

c = a + b

Veya:

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

c += (a + b)

Ayrıca, birleştirilmiş listedeki değerlerin benzersiz olmasını istiyorsanız şunları yapabilirsiniz:

c = list(set(a + b))

itertools.chainFonksiyonun değişken sayıda argümanı kabul ettiğini belirtmek gerekir :

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

Bir yinelenebilir (grup, liste, jeneratör vb.) Giriş ise, from_iterablesınıf yöntemi kullanılabilir:

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

Python 3.3+ ile şunlardan elde edebilirsiniz :

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]

Veya, rasgele sayıda yineleyiciyi desteklemek istiyorsanız:

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]

İki listeyi sıralı biçimde birleştirmek istiyorsanız, mergeişlevi heapqkitaplıktan kullanabilirsiniz.

from heapq import merge

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

print list(merge(a, b))

Artı işlecini ( +) kullanamıyorsanız, operatoriçe aktarmayı kullanabilirsiniz :

import operator

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

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

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

Alternatif olarak, __add__ dunder işlevini de kullanabilirsiniz :

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

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

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

Daha fazla liste için daha genel bir yol olarak, bunları bir listeye koyabilir ve bu yanıta dayalı itertools.chain.from_iterable()¹ işlevini kullanarak iç içe bir listeyi düzleştirmenin en iyi yolu kullanabilirsiniz:

>>> 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. Bunun chain.from_iterable()Python 2.6 ve sonraki sürümlerinde kullanılabildiğini unutmayın . Diğer sürümlerde kullanın chain(*l).}

İki sıralı listeyi karmaşık sıralama kuralları ile birleştirmeniz gerekiyorsa, aşağıdaki koddaki gibi kendiniz yuvarlamanız gerekebilir (okunabilirlik için basit bir sıralama kuralı kullanarak :-)).

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

Nesneler append()üzerinde tanımlanan yöntemi kullanabilirsiniz list:

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

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

Yukarıdaki kod, sıralamayı korumaz, her listeden yinelenenleri kaldırır (ancak birleştirilmiş listeden kaldırmaz)

Birçok kişi tarafından zaten belirtildiği gibi, her iki listeye de aynı tedaviyiitertools.chain() uygulamak gerekiyorsa gitmenin yolu . Benim durumumda, bir listeden diğerine farklı bir etiket ve bayrak vardı, bu yüzden biraz daha karmaşık bir şeye ihtiyacım vardı. Anlaşıldığı gibi, perde arkasında aşağıdakileri yapar:itertools.chain()

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

(bkz. https://docs.python.org/2/library/itertools.html ), bu yüzden buradan ilham aldım ve şu satırlarda bir şeyler yazdım:

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

Burada anlaşılması gereken ana noktalar, listelerin sadece diğerleri gibi nesneler olan tekrarlanabilir özel bir durum olmasıdır; ve for ... inpython'daki döngüler tuple değişkenleri ile çalışabilir, bu nedenle aynı anda birden fazla değişken üzerinde döngü yapmak kolaydır.

Basit bir liste kavrayışı kullanın:

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

Ek Paketten Çıkarma Genelleştirmelerini kullanma konusundaki en yeni yaklaşımın tüm avantajlarına sahiptir - yani, rasgele sayıda farklı yinelenebilirleri (örneğin listeler, tuples, aralıklar ve jeneratörler) bu şekilde birleştirebilirsiniz - ve Python 3.5 veya üstü ile sınırlı değildir. .

Bir liste listesini birleştirmenin gerçekten özlü bir yolu

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

bu bize

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

Python'da, uyumlu boyutlu iki diziyi bu komutla birleştirebilirsiniz

numpy.concatenate([a,b])

Yani iki kolay yol var.

1. Kullanımı+ : Sağlanan listelerden yeni bir liste oluşturur

Misal:

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. Extend kullanma : Mevcut listeye yeni liste ekler. Bu, ayrı bir liste oluşturmadığı anlamına gelir.

Misal:

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

Bu nedenle, en popüler iki yöntemden extendbirinin etkili olduğunu görüyoruz .

Python'da listeleri birleştirmenin birden fazla yolu vardır.

l1 = [1,2,3,4]
l2 = [3,4,5,6]

1. new_list = l1.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))

Çıktı:

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]

İki eski listeyi tutarken yeni bir liste istiyorsanız:

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]

Kodu takip edebilirsiniz

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

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

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