Question

我只想添加两个列表，如下所示。我不必使用嵌套列表，但可以将其更改为numpy数组。请告诉我。谢谢！

input
lst1 = [[1,0,1],[1,0,0],[0,1,0]]
lst2 = [[0,1,0],[1,0,1],[1,0,1]]

output
lst = [[1,1,1],[2,0,1],[1,1,1]]

我试图添加简单的＆＃34; +＆＃34;或合并，但似乎它不会像Pandas DataFrame一样，您可以使用＆＃39; +＆＃39;来执行相同的功能。我不愿意使用DataFrame，但是将其简化为列表或数组。

如果可以在不使用循环的情况下完成，那将是完美的！

Answer 1

numpy：

np.add(lst1, lst2).tolist()

# [[1, 1, 1], [2, 0, 1], [1, 1, 1]]

如果您想要快速并且可以使用numpy数组而不是列表列表，则忽略.tolist()：

np.add(lst1, lst2)

# array([[1, 1, 1],
#        [2, 0, 1],
#        [1, 1, 1]])

只要您的列表列表全部转换为数组，您只需编写+，如果两个术语中的一个是数组，它就足够了：

lst1 + np.array(lst2)

# array([[1, 1, 1],
#        [2, 0, 1],
#        [1, 1, 1]])

Answer 2

两个层次深=双重理解！：）

[[x + y for x, y in zip(sublst1, sublst2)] for sublst1, sublst2 in zip(lst1, lst2)]

编辑：或者，更短（感谢Stefan Pochmann）：

[[x + y for x, y in zip(*sublists)] for sublists in zip(lst1, lst2)]

Answer 3

你一直在问，你能没有循环更快地完成吗？你有没有做过什么时间？

In [225]: lst1 = [[1,0,1],[1,0,0],[0,1,0]]
     ...: lst2 = [[0,1,0],[1,0,1],[1,0,1]]
     ...: 
In [226]: np.add(lst1,lst2).tolist()
Out[226]: [[1, 1, 1], [2, 0, 1], [1, 1, 1]]

In [227]: timeit np.add(lst1,lst2).tolist()
12 µs ± 20.2 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)

In [228]: [[i+j for i,j in zip(a,b)] for a,b in zip(lst1,lst2)]
Out[228]: [[1, 1, 1], [2, 0, 1], [1, 1, 1]]
In [229]: timeit [[i+j for i,j in zip(a,b)] for a,b in zip(lst1,lst2)]
4.88 µs ± 1.05 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)

对于此示例，循环版本比阵列版本快。那是因为从列表中创建数组需要时间。 np.add必须在添加之前将列表参数转换为数组。

纯数组版本：

In [230]: %%timeit a,b = np.array(lst1), np.array(lst2)
     ...: np.add(a,b)
     ...: 
794 ns ± 10.5 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)

对于更大的列表，相对时间可能会有所不同 - 但是当我过去测试过这种情况时，列表操作对于相当大的范围仍然更快。

Answer 4

lst1 = [[1,0,1],[1,0,0],[0,1,0]]
lst2 = [[0,1,0],[1,0,1],[1,0,1]]

result = []
for l1, l2 in zip(lst1, lst2):
    result.append([x+y for x,y in zip(l1,l2)])

print(result)

Answer 5

您可以按如下方式创建自己的功能：

def list_add(list1, list2):
    res_list = []
    for each_item1, each_item2 in zip(list1, list2):
        new_list = []
        for each_ele1, each_ele2 in zip(each_item1, each_item2):
            new_list.append(each_ele1 + each_ele2)
        res_list.append(new_list)
    return res_list

lst1 = [[1,0,1],[1,0,0],[0,1,0]]
lst2 = [[0,1,0],[1,0,1],[1,0,1]]

print(list_add(lst1, lst2))

<强>输出：

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

Answer 6

嵌套lambda(map(...)不需要循环：

lst1 = [[1,0,1],[1,0,0],[0,1,0]]
lst2 = [[0,1,0],[1,0,1],[1,0,1]]

result = list(map(lambda x: list(map(lambda y: y[0] + y[1], zip(*x))), zip(lst1, lst2)))

print(result)
# [[1, 1, 1], [2, 0, 1], [1, 1, 1]]

虽然与@Amaden建议的列表理解相比要慢得多：

In [1]: lst1 = [[1,0,1],[1,0,0],[0,1,0]]

In [2]: lst2 = [[0,1,0],[1,0,1],[1,0,1]]

In [3]: timeit list(map(lambda x: list(map(lambda y: y[0] + y[1], zip(*x))), zip(lst1, lst2)))
100000 loops, best of 3: 5.78 µs per loop

In [4]: timeit [[x + y for x, y in zip(*sublists)] for sublists in zip(lst1, lst2)
100000 loops, best of 3: 2.92 µs per loop

Answer 7

虽然已经回答了，但是在numpy

的帮助下我这样做了

#include <iostream>
// C++17
#include <functional>

int Func(int a, int b)
{
  return a + b;
}

struct S
{
  void operator() (int a)
  {
    std::cout << a << '\n';
  }
};


int main(/*int argc, char* argv[]*/)
{
  using namespace std;

  std::cout << std::invoke(Func, 10, 20) << '\n'; // 30
  std::invoke(S(), 42); // 42
  std::invoke([]() { std::cout << "hello\n"; }); // hello

  return 0;
}

输出：

import numpy as np
list1=[[1,0,1],[1,0,0],[0,1,0]]
list2 = [[0,1,0],[1,0,1],[1,0,1]]

arr1=np.array((list1)) #Convert list to 2darray
arr2=np.array((list2)) #convert list to 2d array 

arr1+arr2   # simply adds the 2d array

Answer 8

如果您想要一行，也可以试试这个：

std::lower_bound/upper_bound

输出：

lst1 = [[1,0,1],[1,0,0],[0,1,0]]
lst2 = [[0,1,0],[1,0,1],[1,0,1]]

print(list(map(lambda x,y:(list(map(lambda y,z:(y+z),x,y))),lst1,lst2)))

Python：嵌套列表合并，在同一索引中添加int

8 个答案: