Modo pitonico per combinare due elenchi in modo alternato?

Ho due elenchi, il primo dei quali è garantito per contenere esattamente un elemento in più rispetto al secondo . Vorrei conoscere il modo più pitonico per creare una nuova lista i cui valori di indice pari provengono dalla prima lista e i cui valori di indice dispari provengono dalla seconda lista.

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

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

Funziona, ma non è carino:

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

In quale altro modo può essere ottenuto? Qual è l'approccio più pitonico?

Ecco un modo per farlo affettando:

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

C'è una ricetta per questo nella itertoolsdocumentazione :

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

MODIFICARE:

Per la versione di Python maggiore di 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))

Questo dovrebbe fare quello che vuoi:

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

Penso che questo sia il modo più pitonico per farlo.

Senza itertools e assumendo che l1 sia 1 elemento più lungo di l2:

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

Usando itertools e assumendo che gli elenchi non contengano Nessuno:

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

So che le domande fanno su due elenchi con uno che ha un elemento in più dell'altro, ma ho pensato di metterlo per altri che potrebbero trovare questa domanda.

Ecco la soluzione di Duncan adattata per funzionare con due elenchi di dimensioni diverse.

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

Questo produce:

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

Se entrambi gli elenchi hanno la stessa lunghezza, puoi fare:

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

Poiché il primo elenco ha un elemento in più, puoi aggiungerlo post hoc:

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

Ecco una linea che lo fa:

list3 = [ item for pair in zip(list1, list2 + [0]) for item in pair][:-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

Questo si basa sul contributo di Carlos Valiente sopra con un'opzione per alternare gruppi di più elementi e assicurarsi che tutti gli elementi siano presenti nell'output:

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

Questo intreccia le liste A e B per gruppi di 3 valori ciascuno:

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

Potrebbe essere un po 'tardi, compra ancora un'altra battuta in pitone. Funziona quando i due elenchi hanno dimensioni uguali o diverse. Una cosa che non vale niente è che modificherà a e b. Se è un problema, devi utilizzare altre soluzioni.

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

La mia opinione:

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

Ecco una riga che utilizza le comprensioni degli elenchi, senza altre librerie:

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

Ecco un altro approccio, se consenti l'alterazione della tua lista iniziale1 per effetto collaterale:

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

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

Si ferma sul più breve:

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

Certo, la risoluzione del metodo next / __ next__ potrebbe essere più veloce.

Questo è brutto ma funziona indipendentemente dalle dimensioni degli elenchi:

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

Più battute ispirate dalle risposte a un'altra domanda :

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]

Che ne dici di numpy? Funziona anche con le stringhe:

import numpy as np

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

Risultato:

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

Un'alternativa in modo funzionale e immutabile (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),[])

Farei il semplice:

chain.from_iterable( izip( list1, list2 ) )

Verrà fornito un iteratore senza creare esigenze di archiviazione aggiuntive.

Sono troppo vecchio per essere giù con le comprensioni degli elenchi, quindi:

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