用ChatGPT解决这个技术问题 Extra ChatGPT

如何并行遍历两个列表？

我有两个可迭代对象，我想成对检查它们： 

foo = [1, 2, 3]
bar = [4, 5, 6]

for (f, b) in iterate_together(foo, bar):
    print("f: ", f, "; b: ", b)

这应该导致： 

f: 1; b: 4
f: 2; b: 5
f: 3; b: 6

一种方法是迭代索引： 

for i in range(len(foo)):
    print("f: ", foo[i], "; b: ", bar[i])

但这对我来说似乎有点不合时宜。有更好的方法吗？

b
blkpingu

蟒蛇 3 

for f, b in zip(foo, bar):
    print(f, b)

当 foo 或 bar 中较短者停止时，zip 停止。

在 Python 3 中，zip 返回元组的迭代器，如 Python2 中的 itertools.izip。要获取元组列表，请使用 list(zip(foo, bar))。要压缩直到两个迭代器都用完，您可以使用 itertools.zip_longest。

蟒蛇2

在 Python 2 中，zip 返回一个元组列表。当 foo 和 bar 不是很大时，这很好。如果它们都是大量的，则形成 zip(foo,bar) 是一个不必要的大量临时变量，应替换为 itertools.izip 或 itertools.izip_longest，它返回一个迭代器而不是一个列表。 

import itertools
for f,b in itertools.izip(foo,bar):
    print(f,b)
for f,b in itertools.izip_longest(foo,bar):
    print(f,b)

当 foo 或 bar 用尽时，izip 停止。当 foo 和 bar 都用尽时，izip_longest 停止。当较短的迭代器用尽时，izip_longest 产生一个元组，其中 None 位于与该迭代器对应的位置。如果您愿意，您还可以设置除 None 之外的其他 fillvalue。 full story 请参见此处。

另请注意，zip 及其类似 zip 的 brethen 可以接受任意数量的迭代作为参数。例如， 

for num, cheese, color in zip([1,2,3], ['manchego', 'stilton', 'brie'], 
                              ['red', 'blue', 'green']):
    print('{} {} {}'.format(num, color, cheese))

印刷 

1 red manchego
2 blue stilton
3 green brie
@unutbu 为什么我更喜欢 OP 的方法而不是 izip 方法（即使 izip/ zip 看起来更干净）？
您可能想首先提及 Python 3，因为它可能更具前瞻性。此外，值得指出的是，在 Python 3 中，zip() 具有只有 itertools.izip() 在 Python 2 中才有的优势，因此它通常是要走的路。
我是否可以要求您更新您的答案以明确声明 itertools 中的 zip 和类似 zip 的函数接受任意数量的可迭代对象，而不仅仅是 2 个？这个问题现在是规范的，您的答案是唯一值得更新的问题。
如果我还想要索引 i 怎么办？我可以在枚举中包装那个拉链吗？
@CharlieParker：是的，你可以，但你会使用 for i, (f, b) in enumerate(zip(foo, bar))。
K
Karl Guertin

您需要 zip 函数。 

for (f,b) in zip(foo, bar):
    print "f: ", f ,"; b: ", b
在 Python 3.0 之前，如果您有大量元素，您可能需要使用 itertools.izip。
V
Vlad Bezden

您应该使用“zip”功能。这是您自己的 zip 函数的示例 

def custom_zip(seq1, seq2):
    it1 = iter(seq1)
    it2 = iter(seq2)
    while True:
        yield next(it1), next(it2)
这与 zip(seq1, seq2) 的结果不完全相同吗？
@NiklasMertsch 是的，结果完全相同。我刚刚提供了 zip 函数的示例
这是对 zip 的相当有限的重新发明，而且措辞颇具误导性。如果您要重新发明轮子（不要——它是一个内置函数，而不是依赖项），至少 this answer 接受可变数量的可迭代对象，并且通常表现得像您期望的 zip 那样。
P
Peter Mortensen

基于 @unutbu 的答案，我比较了两个相同列表在使用 Python 3.6 的 zip() 函数、Python 的 enumerate() 函数、使用手动计数器（参见 count() 函数）、使用index-list，以及在两个列表之一（foo 或 bar）的元素可用于索引另一个列表的特殊情况下。分别使用 timeit() 函数研究了它们在打印和创建新列表方面的性能，其中使用的重复次数为 1000 次。下面给出了我为执行这些调查而创建的 Python 脚本之一。 foo 和 bar 列表的大小范围从 10 到 1,000,000 个元素。

结果：

出于打印目的：在考虑 +/-5% 的精度容差后，观察到所有考虑的方法的性能与 zip() 函数大致相似。当列表大小小于 100 个元素时发生异常。在这种情况下，index-list 方法比 zip() 函数稍慢，而 enumerate() 函数要快约 9%。其他方法产生了与 zip() 函数类似的性能。用于创建列表：探索了两种类型的列表创建方法：使用 (a) list.append() 方法和 (b) 列表推导。在考虑到 +/-5% 的精度容差后，对于这两种方法，发现 zip() 函数比使用列表索引的函数比使用手动计数器执行得更快。在这些比较中，zip() 函数的性能增益可以快 5% 到 60%。有趣的是，使用 foo 的元素来索引 bar 可以产生与 zip() 函数相同或更快的性能（5% 到 20%）。

理解这些结果：

程序员必须确定每个有意义或有意义的操作的计算时间量。

例如，出于打印目的，如果此时间标准为 1 秒，即 10**0 秒，则查看左侧 1 秒处图形的 y 轴并将其水平投影，直到到达单项式曲线，我们看到超过 144 个元素的列表大小将产生大量的计算成本和对程序员的重要性。也就是说，本调查中提到的针对较小列表大小的方法所获得的任何性能对程序员来说都是微不足道的。程序员会得出结论，zip() 函数迭代打印语句的性能与其他方法相似。

结论

在创建 list 期间使用 zip() 函数并行遍历两个列表可以获得显着的性能。当并行遍历两个列表以打印出两个列表的元素时，zip() 函数将产生与 enumerate() 函数相似的性能，如使用手动计数器变量、使用索引列表，以及至于在两个列表之一的元素（foo 或 bar）可用于索引另一个列表的特殊情况下。

用于调查列表创建的 Python 3.6 脚本。 

import timeit
import matplotlib.pyplot as plt
import numpy as np


def test_zip( foo, bar ):
    store = []
    for f, b in zip(foo, bar):
        #print(f, b)
        store.append( (f, b) )

def test_enumerate( foo, bar ):
    store = []
    for n, f in enumerate( foo ):
        #print(f, bar[n])
        store.append( (f, bar[n]) )

def test_count( foo, bar ):
    store = []
    count = 0
    for f in foo:
        #print(f, bar[count])
        store.append( (f, bar[count]) )
        count += 1

def test_indices( foo, bar, indices ):
    store = []
    for i in indices:
        #print(foo[i], bar[i])
        store.append( (foo[i], bar[i]) )

def test_existing_list_indices( foo, bar ):
    store = []
    for f in foo:
        #print(f, bar[f])
        store.append( (f, bar[f]) )


list_sizes = [ 10, 100, 1000, 10000, 100000, 1000000 ]
tz = []
te = []
tc = []
ti = []
tii= []

tcz = []
tce = []
tci = []
tcii= []

for a in list_sizes:
    foo = [ i for i in range(a) ]
    bar = [ i for i in range(a) ]
    indices = [ i for i in range(a) ]
    reps = 1000

    tz.append( timeit.timeit( 'test_zip( foo, bar )',
                              'from __main__ import test_zip, foo, bar',
                              number=reps
                              )
               )
    te.append( timeit.timeit( 'test_enumerate( foo, bar )',
                              'from __main__ import test_enumerate, foo, bar',
                              number=reps
                              )
               )
    tc.append( timeit.timeit( 'test_count( foo, bar )',
                              'from __main__ import test_count, foo, bar',
                              number=reps
                              )
               )
    ti.append( timeit.timeit( 'test_indices( foo, bar, indices )',
                              'from __main__ import test_indices, foo, bar, indices',
                              number=reps
                              )
               )
    tii.append( timeit.timeit( 'test_existing_list_indices( foo, bar )',
                               'from __main__ import test_existing_list_indices, foo, bar',
                               number=reps
                               )
                )

    tcz.append( timeit.timeit( '[(f, b) for f, b in zip(foo, bar)]',
                               'from __main__ import foo, bar',
                               number=reps
                               )
                )
    tce.append( timeit.timeit( '[(f, bar[n]) for n, f in enumerate( foo )]',
                               'from __main__ import foo, bar',
                               number=reps
                               )
                )
    tci.append( timeit.timeit( '[(foo[i], bar[i]) for i in indices ]',
                               'from __main__ import foo, bar, indices',
                               number=reps
                               )
                )
    tcii.append( timeit.timeit( '[(f, bar[f]) for f in foo ]',
                                'from __main__ import foo, bar',
                                number=reps
                                )
                 )

print( f'te  = {te}' )
print( f'ti  = {ti}' )
print( f'tii = {tii}' )
print( f'tc  = {tc}' )
print( f'tz  = {tz}' )

print( f'tce  = {te}' )
print( f'tci  = {ti}' )
print( f'tcii = {tii}' )
print( f'tcz  = {tz}' )

fig, ax = plt.subplots( 2, 2 )
ax[0,0].plot( list_sizes, te, label='enumerate()', marker='.' )
ax[0,0].plot( list_sizes, ti, label='index-list', marker='.' )
ax[0,0].plot( list_sizes, tii, label='element of foo', marker='.' )
ax[0,0].plot( list_sizes, tc, label='count()', marker='.' )
ax[0,0].plot( list_sizes, tz, label='zip()', marker='.')
ax[0,0].set_xscale('log')
ax[0,0].set_yscale('log')
ax[0,0].set_xlabel('List Size')
ax[0,0].set_ylabel('Time (s)')
ax[0,0].legend()
ax[0,0].grid( b=True, which='major', axis='both')
ax[0,0].grid( b=True, which='minor', axis='both')

ax[0,1].plot( list_sizes, np.array(te)/np.array(tz), label='enumerate()', marker='.' )
ax[0,1].plot( list_sizes, np.array(ti)/np.array(tz), label='index-list', marker='.' )
ax[0,1].plot( list_sizes, np.array(tii)/np.array(tz), label='element of foo', marker='.' )
ax[0,1].plot( list_sizes, np.array(tc)/np.array(tz), label='count()', marker='.' )
ax[0,1].set_xscale('log')
ax[0,1].set_xlabel('List Size')
ax[0,1].set_ylabel('Performances ( vs zip() function )')
ax[0,1].legend()
ax[0,1].grid( b=True, which='major', axis='both')
ax[0,1].grid( b=True, which='minor', axis='both')

ax[1,0].plot( list_sizes, tce, label='list comprehension using enumerate()',  marker='.')
ax[1,0].plot( list_sizes, tci, label='list comprehension using index-list()',  marker='.')
ax[1,0].plot( list_sizes, tcii, label='list comprehension using element of foo',  marker='.')
ax[1,0].plot( list_sizes, tcz, label='list comprehension using zip()',  marker='.')
ax[1,0].set_xscale('log')
ax[1,0].set_yscale('log')
ax[1,0].set_xlabel('List Size')
ax[1,0].set_ylabel('Time (s)')
ax[1,0].legend()
ax[1,0].grid( b=True, which='major', axis='both')
ax[1,0].grid( b=True, which='minor', axis='both')

ax[1,1].plot( list_sizes, np.array(tce)/np.array(tcz), label='enumerate()', marker='.' )
ax[1,1].plot( list_sizes, np.array(tci)/np.array(tcz), label='index-list', marker='.' )
ax[1,1].plot( list_sizes, np.array(tcii)/np.array(tcz), label='element of foo', marker='.' )
ax[1,1].set_xscale('log')
ax[1,1].set_xlabel('List Size')
ax[1,1].set_ylabel('Performances ( vs zip() function )')
ax[1,1].legend()
ax[1,1].grid( b=True, which='major', axis='both')
ax[1,1].grid( b=True, which='minor', axis='both')

plt.show()
几乎所有时间都花在了 print 测试中。印刷很贵。列表构建也有一些成本。
@user2357112supportsMonica 同意。对于打印，迭代性能由慢速系统 I/O 操作决定，因此对 zip() 函数或我考虑的其他方法的性能不敏感。
D
Don F

您可以使用理解将第 n 个元素捆绑到元组或列表中，然后使用生成器函数将它们传递出去。 

def iterate_multi(*lists):
    for i in range(min(map(len,lists))):
        yield tuple(l[i] for l in lists)

for l1, l2, l3 in iterate_multi([1,2,3],[4,5,6],[7,8,9]):
    print(str(l1)+","+str(l2)+","+str(l3))
P
Peter Mortensen

我们可以只使用索引来迭代...... 

foo = ['a', 'b', 'c']
bar = [10, 20, 30]
for indx, itm in enumerate(foo):
    print (foo[indx], bar[indx])
如果您实际上没有使用 itm，为什么还要使用 enumerate？更改为 print(itm, bar[index]) 或简单地循环为 for indx in range(len(foo))
P
Peter Mortensen

以下是使用 list comprehension 的方法： 

a = (1, 2, 3)
b = (4, 5, 6)
[print('f:', i, '; b', j) for i, j in zip(a, b)]

它打印： 

f: 1 ; b 4
f: 2 ; b 5
f: 3 ; b 6

关注公众号,不定期副业成功案例分享
关注公众号

不定期副业成功案例分享

想领先一步获取最新的外包任务吗？

立即订阅

HuntsBot(狩猎机器人)，一站式外包任务、远程工作、产品创意分享与订阅平台，支持钉钉、飞书、企业微信、邮箱、Telegram机器人订阅。平台会以及时、稳定、可靠的技术把外包任务需求、远程工作机会、产品创意等推送给每一位订阅的用户。

简体中文 English

平台

支持

友情链接

联系我们

在使用过程中有任何问题或建议，可以通过以下方式联系我们：

微信公众号: 火星来客

Email: huntsbot@xinbeitime.com

Copyright© 2022-2023 www.huntsbot.com 浙ICP备2022000860号-4 All Rights Reserved.