Pythonische Möglichkeit, zwei Listen abwechselnd zu kombinieren?

Ich habe zwei Listen, von denen die erste garantiert genau einen Artikel mehr enthält als die zweite . Ich würde gerne wissen, wie man am pythonischsten eine neue Liste erstellt, deren gerade Indexwerte aus der ersten Liste und deren ungerade Indexwerte aus der zweiten Liste stammen.

# example inputs
list1 = ['f', 'o', 'o']
list2 = ['hello', 'world']

# desired output
['f', 'hello', 'o', 'world', 'o']

Das funktioniert, ist aber nicht schön:

list3 = []
while True:
    try:
        list3.append(list1.pop(0))
        list3.append(list2.pop(0))
    except IndexError:
        break

Wie kann dies sonst noch erreicht werden? Was ist der pythonischste Ansatz?

Hier ist eine Möglichkeit, dies durch Schneiden zu tun:

>>> list1 = ['f', 'o', 'o']
>>> list2 = ['hello', 'world']
>>> result = [None]*(len(list1)+len(list2))
>>> result[::2] = list1
>>> result[1::2] = list2
>>> result
['f', 'hello', 'o', 'world', 'o']

Ein Rezept dafür finden Sie in der itertoolsDokumentation :

from itertools import cycle, islice

def roundrobin(*iterables):
    "roundrobin('ABC', 'D', 'EF') --> A D E B F C"
    # Recipe credited to George Sakkis
    pending = len(iterables)
    nexts = cycle(iter(it).next for it in iterables)
    while pending:
        try:
            for next in nexts:
                yield next()
        except StopIteration:
            pending -= 1
            nexts = cycle(islice(nexts, pending))

####BEARBEITEN:

Für eine Python-Version größer als 3:

from itertools import cycle, islice

def roundrobin(*iterables):
    "roundrobin('ABC', 'D', 'EF') --> A D E B F C"
    # Recipe credited to George Sakkis
    pending = len(iterables)
    nexts = cycle(iter(it).__next__ for it in iterables)
    while pending:
        try:
            for next in nexts:
                yield next()
        except StopIteration:
            pending -= 1
            nexts = cycle(islice(nexts, pending))

Dies sollte tun, was Sie wollen:

>>> iters = [iter(list1), iter(list2)]
>>> print list(it.next() for it in itertools.cycle(iters))
['f', 'hello', 'o', 'world', 'o']

import itertools
print [x for x in itertools.chain.from_iterable(itertools.izip_longest(list1,list2)) if x]

Ich denke, das ist die pythonischste Art, es zu tun.

Ohne itertools und unter der Annahme, dass l1 1 Element länger als l2 ist:

>>> sum(zip(l1, l2+[0]), ())[:-1]
('f', 'hello', 'o', 'world', 'o')

Verwenden von itertools und unter der Annahme, dass Listen keine enthalten:

>>> filter(None, sum(itertools.izip_longest(l1, l2), ()))
('f', 'hello', 'o', 'world', 'o')

Ich weiß, dass die Fragen zwei Listen betreffen, von denen eine einen Eintrag mehr als die andere enthält, aber ich dachte, ich würde dies für andere verwenden, die diese Frage möglicherweise finden.

Hier ist Duncans Lösung, die für zwei Listen unterschiedlicher Größe geeignet ist.

list1 = ['f', 'o', 'o', 'b', 'a', 'r']
list2 = ['hello', 'world']
num = min(len(list1), len(list2))
result = [None]*(num*2)
result[::2] = list1[:num]
result[1::2] = list2[:num]
result.extend(list1[num:])
result.extend(list2[num:])
result

Dies gibt aus:

['f', 'hello', 'o', 'world', 'o', 'b', 'a', 'r'] 

Hier ist ein Einzeiler, der das macht:

list3 = [ item for pair in zip(list1, list2 + [0]) for item in pair][:-1]

Wenn beide Listen gleich lang sind, können Sie Folgendes tun:

[x for y in zip(list1, list2) for x in y]

Da die erste Liste ein weiteres Element enthält, können Sie es post hoc hinzufügen:

[x for y in zip(list1, list2) for x in y] + [list1[-1]]

def combine(list1, list2):
    lst = []
    len1 = len(list1)
    len2 = len(list2)

    for index in range( max(len1, len2) ):
        if index+1 <= len1:
            lst += [list1[index]]

        if index+1 <= len2:
            lst += [list2[index]]

    return lst

Dieser basiert auf dem obigen Beitrag von Carlos Valiente mit der Option, Gruppen mehrerer Elemente zu wechseln und sicherzustellen, dass alle Elemente in der Ausgabe vorhanden sind:

A=["a","b","c","d"]
B=[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16]

def cyclemix(xs, ys, n=1):
    for p in range(0,int((len(ys)+len(xs))/n)):
        for g in range(0,min(len(ys),n)):
            yield ys[0]
            ys.append(ys.pop(0))
        for g in range(0,min(len(xs),n)):
            yield xs[0]
            xs.append(xs.pop(0))

print [x for x in cyclemix(A, B, 3)]

Dadurch werden die Listen A und B nach Gruppen mit jeweils 3 Werten verschachtelt:

['a', 'b', 'c', 1, 2, 3, 'd', 'a', 'b', 4, 5, 6, 'c', 'd', 'a', 7, 8, 9, 'b', 'c', 'd', 10, 11, 12, 'a', 'b', 'c', 13, 14, 15]

Meine Einstellung:

a = "hlowrd"
b = "el ol"

def func(xs, ys):
    ys = iter(ys)
    for x in xs:
        yield x
        yield ys.next()

print [x for x in func(a, b)]

Hier ist ein Einzeiler mit Listenverständnis ohne andere Bibliotheken:

list3 = [sub[i] for i in range(len(list2)) for sub in [list1, list2]] + [list1[-1]]

Hier ist ein anderer Ansatz, wenn Sie eine Änderung Ihrer ursprünglichen Liste1 durch Nebenwirkungen zulassen:

[list1.insert((i+1)*2-1, list2[i]) for i in range(len(list2))]

Könnte etwas spät sein, noch einen Python-Einzeiler zu kaufen. Dies funktioniert, wenn die beiden Listen gleich oder ungleich groß sind. Eine Sache, die nichts wert ist, ist, dass sie a und b modifiziert. Wenn es ein Problem ist, müssen Sie andere Lösungen verwenden.

a = ['f', 'o', 'o']
b = ['hello', 'world']
sum([[a.pop(0), b.pop(0)] for i in range(min(len(a), len(b)))],[])+a+b
['f', 'hello', 'o', 'world', 'o']

from itertools import chain
list(chain(*zip('abc', 'def')))  # Note: this only works for lists of equal length
['a', 'd', 'b', 'e', 'c', 'f']

Stoppt am kürzesten:

def interlace(*iters, next = next) -> collections.Iterable:
    """
    interlace(i1, i2, ..., in) -> (
        i1-0, i2-0, ..., in-0,
        i1-1, i2-1, ..., in-1,
        .
        .
        .
        i1-n, i2-n, ..., in-n,
    )
    """
    return map(next, cycle([iter(x) for x in iters]))

Sicher, das Auflösen der next / __ next__ -Methode kann schneller sein.

Das ist böse, funktioniert aber unabhängig von der Größe der Listen:

list3 = [element for element in list(itertools.chain.from_iterable([val for val in itertools.izip_longest(list1, list2)])) if element != None]

Mehrere Einzeiler, inspiriert von Antworten auf eine andere Frage :

import itertools

list(itertools.chain.from_iterable(itertools.izip_longest(list1, list2, fillvalue=object)))[:-1]

[i for l in itertools.izip_longest(list1, list2, fillvalue=object) for i in l if i is not object]

[item for sublist in map(None, list1, list2) for item in sublist][:-1]

Wie wäre es mit Numpy? Es funktioniert auch mit Strings:

import numpy as np

np.array([[a,b] for a,b in zip([1,2,3],[2,3,4,5,6])]).ravel()

Ergebnis:

array([1, 2, 2, 3, 3, 4])

Eine funktionale und unveränderliche Alternative (Python 3):

from itertools import zip_longest
from functools import reduce

reduce(lambda lst, zipped: [*lst, *zipped] if zipped[1] != None else [*lst, zipped[0]], zip_longest(list1, list2),[])

Ich würde das Einfache tun:

chain.from_iterable( izip( list1, list2 ) )

Es wird ein Iterator erstellt, ohne dass zusätzlicher Speicherbedarf entsteht.

Ich bin zu alt, um mit Listenverständnissen fertig zu werden, also:

import operator
list3 = reduce(operator.add, zip(list1, list2))