在 Python 中生成和 zip 兩個列表的最干凈有效的方法

Question

鑒於這兩個列表

zeros = [2,3,1,2]
ones = [3,4,5]

（條件總是len(zeros) == len(ones) + 1 ）

我想創建一個列表，其中交替包含列表中提到的大小的 0 和 1。 我可以通過以下方式實現：

zeros_list = [[0]*n for n in zeros]
ones_list = [[1]*n for n in ones]
output = [z for x in zip(zeros_list, ones_list) for y in x for z in y]
output += [0]*zeros[-1]
print(output)
> [0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 0]

然而，這是最有效/最干凈的方式嗎？ 我得到了 2.66 µs ± 78.8 ns 的性能，但我仍然認為這可以在單行中完成，而且效率可能更高

Answer 1

兩個明顯更快的解決方案，使用“技巧”來特殊處理第一個零而不是最后一個零，使用它來初始化output 。

def superb_rain(zeros, ones):
    zeros = iter(zeros)
    output = [0] * next(zeros)
    for o in ones:
        output += (1,) * o
        output += (0,) * next(zeros)
    return output

def superb_rain2(zeros, ones):
    z = iter(zeros).__next__
    output = [0] * z()
    for o in ones:
        output += (1,) * o
        output += (0,) * z()
    return output

（正如@schwobaseggl 指出的那樣，元組使它的速度提高了大約 30%。）

基准測試結果：

0.14 us  0.13 us  0.13 us  baseline
3.04 us  3.02 us  2.98 us  original
3.27 us  3.19 us  3.29 us  chepner_1
5.03 us  5.12 us  5.25 us  chepner_2
4.66 us  4.74 us  4.68 us  chepner_2__superb_rain
2.52 us  2.53 us  2.47 us  Alain_T
3.35 us  3.27 us  3.42 us  python_user
1.02 us  0.99 us  1.04 us  superb_rain
1.07 us  1.11 us  1.09 us  superb_rain2

基准代碼：

import timeit
from itertools import zip_longest, cycle, islice, repeat, chain

def baseline(zeros, ones):
    pass

def original(zeros, ones):
    zeros_list = [[0]*n for n in zeros]
    ones_list = [[1]*n for n in ones]
    output = [z for x in zip(zeros_list, ones_list) for y in x for z in y]
    output += [0]*zeros[-1]
    return output

def chepner_1(zeros, ones):
    return list(chain.from_iterable(chain.from_iterable(zip_longest((repeat(0, x) for x in zeros), (repeat(1, x) for x in ones), fillvalue=[]))))

def roundrobin(*iterables):
    "roundrobin('ABC', 'D', 'EF') --> A D E B F C"
    # Recipe credited to George Sakkis
    num_active = len(iterables)
    nexts = cycle(iter(it).__next__ for it in iterables)
    while num_active:
        try:
            for next in nexts:
                yield next()
        except StopIteration:
            # Remove the iterator we just exhausted from the cycle.
            num_active -= 1
            nexts = cycle(islice(nexts, num_active))
def chepner_2(zeros, ones):
    zero_groups = (repeat(0, x) for x in zeros)
    one_groups = (repeat(1, x) for x in ones)    
    return list(chain.from_iterable(roundrobin(zero_groups, one_groups)))
def chepner_2__superb_rain(zeros, ones):
    return list(chain.from_iterable(map(repeat, cycle([0, 1]), roundrobin(zeros, ones))))

def Alain_T(zeros, ones):
    return [B for N,P in zip(zeros+[0],ones+[0]) for B in ([0]*N+[1]*P)]

def python_user(zeros, ones):
    res = [None] * (len(ones) + len(zeros))

    res[::2] = ([0]*n for n in zeros)
    res[1::2] = ([1]*n for n in ones)

    res = [y for x in res for y in x]
    return res

def superb_rain(zeros, ones):
    zeros = iter(zeros)
    output = [0] * next(zeros)
    for o in ones:
        output += (1,) * o
        output += (0,) * next(zeros)
    return output

def superb_rain2(zeros, ones):
    z = iter(zeros).__next__
    output = [0] * z()
    for o in ones:
        output += (1,) * o
        output += (0,) * z()
    return output

funcs = [
    baseline,
    original,
    chepner_1,
    chepner_2,
    chepner_2__superb_rain,
    Alain_T,
    python_user,
    superb_rain,
    superb_rain2,
    ]

zeros = [2,3,1,2]
ones = [3,4,5]
number = 10**5

expect = original(zeros, ones)
for func in funcs:
    print(func(zeros, ones) == expect, func.__name__)
print()

tss = [[] for _ in funcs]
for _ in range(4):
    for func, ts in zip(funcs, tss):
        t = min(timeit.repeat(lambda: func(zeros, ones), number=number)) / number
        ts.append(t)
        print(*('%.2f us ' % (1e6 * t) for t in ts[1:]), func.__name__)
    print()

Answer 2

具有列表理解的 Zip 應該可以解決問題。

zeros = [2,3,1,2]
ones = [3,4,5]

output = [B for N,P in zip(zeros,ones+[0]) for B in [0]*N+[1]*P]

print(output)

[0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 0]

請注意， ones+[0]是為了確保您不會在 zip 操作中刪除零列表中的最后一個值。

Answer 3

您可以使用itertools.chain 、 zip_longest和itertools.repeat創建一個不太容易混淆的單行代碼。

>>> list(chain.from_iterable(chain.from_iterable(zip_longest((repeat(0, x) for x in zeros), (repeat(1, x) for x in ones), fillvalue=[]))))
[0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 0]

在我的機器上，這花費了 3.34µs。 更重要的是，這次是要list的包裝器。 迭代器本身會按需生成元素，如果您實際上並不一次需要它們的話。

---

list(chain.from_iterable(
        chain.from_iterable(zip_longest((repeat(0, x) for x in zeros),
                                        (repeat(1, x) for x in ones),
                                        fill_value=[]))))

• (repeat(0, x) for x in zeros)創建一系列repeat對象，代表您運行的 0； 同樣創建 1 組。
• zip_longest將它們壓縮成一對序列，添加一個什么都不做的空列表來平衡zeros中的額外值
• chain.from_iterable將該序列展平 (from (a, b), (c, d) to (a, b, c, d) 。
• 外層的chain.from_iterable然后將repeat的對象壓平成一個序列，這個list變成一個列表。

---

您還可以使用itertools文檔中的roundrobin方法簡化單行代碼，它處理合並零組和一個組，以及第一輪展平。

from itertools import cycle, islice, repeat, chain

zeros = [2,3,1,2]
ones = [3,4,5]

# From the itertools documentation
def roundrobin(*iterables):
    "roundrobin('ABC', 'D', 'EF') --> A D E B F C"
    # Recipe credited to George Sakkis
    num_active = len(iterables)
    nexts = cycle(iter(it).__next__ for it in iterables)
    while num_active:
        try:
            for next in nexts:
                yield next()
        except StopIteration:
            # Remove the iterator we just exhausted from the cycle.
            num_active -= 1
            nexts = cycle(islice(nexts, num_active))


zero_groups = (repeat(0, x) for x in zeros)
one_groups = (repeat(1, x) for x in ones)
    
print(list(chain.from_iterable(roundrobin(zero_groups, one_groups))))

Answer 4

鑒於這兩個列表

zeros = [2,3,1,2]
ones = [3,4,5]

（條件總是len(zeros) == len(ones) + 1 ）

我想創建一個列表，其中包含列表中提到的數量級的交替 0 和 1。 我可以通過以下方式實現：

zeros_list = [[0]*n for n in zeros]
ones_list = [[1]*n for n in ones]
output = [z for x in zip(zeros_list, ones_list) for y in x for z in y]
output += [0]*zeros[-1]
print(output)
> [0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 0]

然而，這是最有效/最干凈的方式嗎？ 我得到了 2.66 µs ± 78.8 ns 的性能，但我仍然認為這可以在單線中完成，而且效率可能更高