Question

我想在不导入任何模块的情况下随机播放列表的元素。 shuffle的类型是riffle shuffle。你要在哪里划分号码。将列表中的元素分成两部分，然后将它们交错。

如果有奇数没有。然后下半部分应该包含额外的元素

例如：list = [1,2,3,4,5,6,7]

then the final list should look like [1,4,2,5,3,6,7]

Answer 1

listA = [1,2,3,4,5,6,7,8,9]
listLen = len(listA)/2
listB = listA[:listLen]
listC = listA[listLen:]
listD = []
num = 0
while num < listLen:
    if len(listB) >= num:
        listD.append(listB[num])
        listD.append(listC[num])
    num += 1
if len(listA)%2 != 0:
    listD.append(listC[num])
print listD

在看了另一个答案之后，我还添加了一个递归版本，这是另一个人的答案的修订版本，但更容易调用，因为你只需要用一个参数调用该函数（你正在尝试的列表）已经洗牌了）它会做其他所有事情：

def interleave(lst):
    def interleaveHelper(lst1,lst2):
        if not lst1:
            return lst2
        elif not lst2:
            return lst1
        return lst1[0:1] + interleaveHelper(lst2, lst1[1:])
    return interleaveHelper(lst[:len(lst)/2], lst[len(lst)/2:])

当你去打电话时，你可以说interleave(list)

Answer 2

只是为了好玩，一个递归的解决方案：

def interleave(lst1, lst2):
    if not lst1:
        return lst2
    elif not lst2:
        return lst1
    return lst1[0:1] + interleave(lst2, lst1[1:])

在Python 2.x中使用如下（在Python 3.x中，使用//而不是/）：

lst = [1,2,3,4,5,6,7]
interleave(lst[:len(lst)/2], lst[len(lst)/2:])
=> [1, 4, 2, 5, 3, 6, 7]

以上内容适用于任何长度的列表，如果长度是偶数或奇数，则无关紧要。

Answer 3

例如：list = [1,2,3,4,5,6,7] 那么最终的名单应该看起来像[1,4,2,5,3,6,7]

这是一个应该可靠地执行此操作的函数：

def riffle(deck):
    '''
    Shuffle a list like a deck of cards.
    i.e. given a list, split with second set have the extra if len is odd
    and then interleave, second deck's first item after first deck's first item
    and so on. Thus:
    riffle([1,2,3,4,5,6,7])
    returns [1, 4, 2, 5, 3, 6, 7]
    '''
    cut = len(deck) // 2                        # floor division
    deck, second_deck = deck[:cut], deck[cut:]
    for index, item in enumerate(second_deck):
        insert_index = index*2 + 1
        deck.insert(insert_index, item)
    return deck

并对其进行单元测试......

import unittest
class RiffleTestCase(unittest.TestCase):
    def test_riffle(self):
        self.assertEqual(riffle(['a','b','c','d','e']), ['a','c','b','d','e'])
        self.assertEqual(riffle([1,2,3,4,5,6,7]), [1,4,2,5,3,6,7])

unittest.main()
----------------------------------------------------------------------
Ran 1 test in 0.000s

OK

Answer 4

通过在Python中使用迭代器的next功能，您可以相当轻松地完成此操作。

您要做的第一件事是将元素分成两部分。

接下来，使用Python的iter函数将这两部分转换为迭代器。您可以跳过此步骤，但我发现调用next(iterable)比手动索引列表更清晰。

最后，你将遍历列表的前半部分，并为你添加的那一半的每个元素添加后者的相应元素（调用next给出序列中的下一个项目）。

例如：

elements = [1,2,3,4,5,6,7]

half_point = len(elements)/2

a = iter(elements[0:half_point])
b = iter(elements[half_point: ])

result = []
for i in range(half_point):
    result.append(next(a))
    result.append(next(b))

if len(elements) % 2 != 0:
    result.append(next(b))

print result

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

底部的最后一位检查列表是否为奇数。如果是，则将最后一个元素追加到列表的末尾。

如果你有创意，你可以通过压缩然后解压缩来缩短这一点，但是当你探索itertools时，我会留下它;）

Answer 5

您可以将输入列表拆分为两部分，然后使用zip和一些列表操作来交错项目。

n = 9
l = range(1,n+1)
a = l[:n/2]
b = l[n/2:]
c = zip(a,b)
d = list()
for p in c :
    d.extend(list(p))
if n%2==1:
    d.append(b[n/2])
print(d)

Answer 6

>>> ll = list(range(1,8))
>>> mid = len(ll)/2   # for Python3, use '//' operator
>>> it1 = iter(ll[:mid])
>>> it2 = iter(ll[mid:])
>>> riff = sum(zip(it1,it2), ()) + tuple(it2)
>>> riff
(1, 4, 2, 5, 3, 6, 7)

如果这是作业，请准备好解释sum和zip在此工作的方式，sum的第二个参数是什么，为什么tuple(it2)被添加到结束，以及这种解决方案如何具有固有的低效率。

Answer 7

如果deck是一个列表，编写一个执行列表理解的函数来执行洗牌：

wso2/wso2mi:1.2.0

我们怎样才能在python中重新排列列表中的元素？

7 个答案: