更多'Pythonic'方式替换列表shuffle

Question

Trying to 'shuffle' a list with even number of items. Splitting the list, L in half and alternating taking an element from each.

I've tried pop , but that approach was unable to get me to a one-liner. ( while loop) and I know there is likely some more succinct way to move through it.

The shuffle from random isn't exactly what I need, either – because that randomizes the entire order instead of alternating between the split list.

If a one-liner isn't possible, is that because it's more readable in a while loop?

def shuffle(L):
    '''
    I apologize in advance for how wet the following code is... 
    Example:
    >>> shuffle([1, 2, 3, 4, 5, 6])
    [1, 4, 2, 5, 3, 6]
    '''
    return [L[:(len(L)//2)][0], L[(len(L)//2):][0], L[:(len(L)//2)][1], L[(len(L)//2):][1], L[:(len(L)//2)][2], L[(len(L)//2):][2]]

other attempt:

def shuffle(L):
    x, L_first, L_next, L = len(L), L[:(len(L)//2)], L[(len(L)//2):], []
    while len(L) != x:
        L.extend([L_first.pop(0), L_next.pop(0)])
    return L

Answer 1

Use slice assignment with a step:

def shuffle(l):
    result = [None] * len(l)

    # Put the first half of l in the even indices of result
    result[::2] = l[:len(l)//2]

    # Put the second half of l in the odd indices of result
    result[1::2] = l[len(l)//2:]

    return result

Answer 2

If I understand correctly, you could also opt for itertools.chain.from_iterable after zipping to get the alternating effect.

from itertools import chain

def shuff(l):
    return list(chain.from_iterable(zip(l[:len(l)//2], l[len(l)//2:])))

Demo

>>> shuff(list(range(1, 7))
[1, 4, 2, 5, 3, 6]

Answer 3

One possibility (requires an external library but the recipe can also be found in the itertools -recipes section ) is:

from iteration_utilities import roundrobin

def shuffle(L):
    return list(roundrobin(L[:len(L)//2], L[len(L)//2:]))

This is probably slower than list assignment but it also works for arbitary amounts of iterables without problems and it doesn't require odd-sized-input handling:

>>> shuffle([1, 2, 3, 4, 5, 6, 7])
[1, 4, 2, 5, 3, 6, 7]
>>> shuffle([1, 2, 3, 4, 5, 6])
[1, 4, 2, 5, 3, 6]

---

I did some timings and @user2357112 definetly has the fastest solution but my solution is at least on the second place (note that this graph is in log-log, that means the difference in absolute terms may seem smaller than it really is!):

---

^{Disclaimer: I'm the author of that iteration_utilities library.}

Answer 4

list comprehension with index calculation using modulo and floor division

[ L[(i + (i % 2)*len(L))//2] for i in range(len(L)) ] # for case of even len(L)

still one line for the general case

[ L[i//2 + (i % 2)*len(L)//2] for i in range(2*(len(L)//2)) ] + [L[-1]]*(len(L) % 2)

the index calc (i + (i % 2)*len(L))//2

can be parsed as adding

i//2 which gives 0, 0, 1, 1, 2, 2 ...

and

(i % 2)*len(L)//2 where (i % 2) alternates 0, 1 for even/odd i

0, len(L)//2, 0, len(L)//2, 0, len(L)//2 ...

sum:

0, len(L)//2, 1, 1 + len(L)//2, 2, 2 + len(L)//2 ...

Answer 5

Found two solutions. First one is very unpythonic (using python 2.7)

a = [1, 2, 3, 4, 5, 6] # intial array

Method One (using string magic):

[int(p) for p in ' '.join([str(x) + ' ' + str(y) for x, y in zip(a[:len(a) / 2], a[len(a) / 2:])]).split(' ')]

Method Two:

[i for Tuple in zip(a[:len(a) / 2], a[len(a) / 2:]) for i in Tuple]