Python 将两个列表汇总为另一个列表

我有两个输入列表，如下面的小示例，并想对它们进行总结：

小例子：

a = [4, 5, 2]
b = [3, 5, 4]

RES = [1, 1]

我想逐项比较这两个列表，并以此为基础 比较给每个列表打分。如果它们相等，则两个列表都相同 如果得分为0，并且一个列表中的项目更大，则该列表将 得1分。最后，结果将是一个列表（名为

RES

） 有两个项目。第一项是a和a的所有结果的总和 第二项是b的所有结果的总和。 在本例中，我比较了a和b中的项目1，因为4>3，a将 得1分。通过比较其他两个项目，两个列表的 第二项和b将获得第三项的1。全部加起来 所有比较的分数，a得1

（1+0+0）

，b得1 太

（0+0+1）

。 以下是小示例的预期输出：

a = [4, 5, 2]
b = [3, 5, 4]

RES = [1, 1]

为了得到这个结果，我用python编写了以下代码：

def fun(a, b):
    for i in range(len(a)):
        if a[i] > b[i]:
            AL = 1
        elif a[i] == b[i]:
            AL = BL = 0
        elif a[i] < b[i]:
            BL = 1
    RES = list(AL, BL)
    return RES

def fun（a，b）：
对于范围内的i（len（a））：
如果a[i]>b[i]：
AL=1
如果a[i]==b[i]：
AL=BL=0
以利夫a[i]

---

但它没有返回我想要的。您知道如何修复它吗？

使用变量跟踪两个列表的分数

def fun(a, b):
    score_a = score_b = 0
    for a_i, b_i in zip(a, b):
        if a_i > b_i:
            score_a += 1
        ...

    return [score_a, score_b]

---

请注意，我在这里使用了，这样我们就可以从

a

和

b

中成对地读取每个元素，这是代码中的一些问题

• RES=list（AL，BL）

  不是定义包含两个元素的列表的方式，而是要执行

  RES=[AL，BL]

• 您没有为每次迭代更新

  AL

  和

  BL

  ，而是将其重置为新值
• 在循环之前，您需要初始化

  AL

  和

  BL

所以更新代码可能看起来像

a = [4, 5, 2]
b = [3, 5, 4]

def fun(a, b):
    #Initialize AL and BL
    AL = 0
    BL = 0
    #Increment AL and BL according to the conditions
    for i in range(len(a)):
        if a[i] > b[i]:
            AL += 1 
        elif a[i] < b[i]:
            BL += 1

    #Make a list and return it
    return [AL, BL]

print(fun(a,b))

---

您的代码有两个问题

首先，这不是

list

的工作原理。它接受一个具有某种iterable的参数，并将其转换为

列表

。你想要

[AL，BL]

第二个问题是，您一直在覆盖

AL

和

BL

的值，因此您实际上从未取得任何进展

我想你想要这个：

def fun(a, b):
    AL = 0
    BL = 0
    for i in range(len(a)):
        a_value = a[i]
        b_value = b[i]
        if a_value > b_value:
            AL += 1
        elif a_value < b_value:
            BL += 1
    return [AL, BL]

print(fun([4, 5, 2], [3, 5, 4]))

这就是说，当您想要的是

列表中的实际元素时，直接在
列表中进行迭代就更像python了。您还可以使用
列表
理解，例如：

import numpy as np

def fun(a, b):
    diff = [np.sign(a_value - b_value) for a_value, b_value in zip(a, b)]
    return [diff.count(1), diff.count(-1)]

print(fun([4, 5, 2], [3, 5, 4]))

这利用了这样一个事实，即如果计算
a-b
，如果
a>b
，结果将为正，如果
a
，结果将为负，如果它们相等，结果将为0。然后我们可以取每个元素的符号，分别计算正元素和负元素的数量。
代码的问题是：

AL和BL变量未初始化

在每次迭代中覆盖AL和BL的值。通过
AL+=1尝试增量
AL
和
BL

List类在构造函数中最多接受一个参数
RES=list（AL，BL）
无效。试试
RES=[AL，BL]

两个挑剔的细节-使用range（len（iterable））构造迭代iterable不是很好的实践。如果需要索引，请使用枚举。这样，就不需要创建新的范围对象。因此，不要对范围内的i（len（ITERABLE））使用
：而是对枚举（ITERABLE）中的i、elem使用
：
。此外，常量通常使用大写变量名

正确的实施方法是：

def fun(a, b):
    a_is_greater = 0
    b_is_greater = 0
    for element_a, element_b in zip(a, b):
        if element_a > element_b:
            a_is_greater += 1
        elif element_a < element_b:
            b_is_greater += 1
    return [a_is_greater, b_is_greater]

def fun（a，b）：
a_大于等于0
b_大于等于0
对于zip（a，b）中的元素a和元素b：
如果元素a>元素b：
a_大于+=1
elif元素a<元素b：
b_大于+=1
返回[a_大于，b_大于]

编辑：较短的解决方案是：

def fun(a,b):
    return [sum(col) for col in zip(*[(al > bl, al < bl) for al, bl in zip(a, b)])]

def fun（a，b）：
返回[zip中列的和（列）（[（al>bl，al
Ares=[]
Bres=[]
a=[4,5,2]
b=[3,5,4]
al=len（a）
对于范围（0，al）内的i：
如果a[i]>b[i]：
战神附加（“1”）
如果a[i]a[i]：
附件（“1”）
如果b[i]您在每次迭代时都在重写
AL
和
BL
，那么事实是只有最后一次迭代（当
i==len（a）-1
时）才确定代码的结果。您在问题中专门使用了
+
，但您的代码中没有一个
+
RES=list（AL，BL）
将引发一个
TypeError
。当两个列表的长度不相同时会发生什么？当您可以简单地
+=
？？？要求两个求和，因此中间列表（最终求和）在这里是完全冗余的，以获得有效的解决方案。对于附加到列表而不是
Ares的字符串，只需执行
Aresult+=1
。列表
Ares
和
Bres
是冗余的，您的代码对于给定的问题是一个效率极低的解决方案。
def fun(a,b):
    return [sum(col) for col in zip(*[(al > bl, al < bl) for al, bl in zip(a, b)])]

Ares=[]
Bres=[]
a = [4, 5, 2]
b = [3, 5, 4]
al=len(a)
for i in range(0,al):
        if a[i]>b[i]:
            Ares.append("1")
        if a[i]<b[i]:
            Ares.append("0")
        if b[i]>a[i]:
            Bres.append("1")
        if b[i]<a[i]:
            Bres.append("0") 
        if a[i]==b[i]:
            Ares.append("0")
            Bres.append("0")
Adata= list(map(int, Ares))
Aresult=sum(list(Adata))
Bdata= list(map(int, Bres))
Bresult=sum(list(Bdata))
RES=[Aresult,Bresult]
print(RES)