Operation trên mảng NumPy chứa hàng với kích thước khác nhau

Question

Tôi có hai danh sách, nhìn như thế này:

a= [[1,2,3,4], [2,3,4,5],[3,4,5,6,7]], b= [[5,6,7,8], [9,1,2,3], [4,5,6,7,8]] 

mà tôi muốn trừ từ mỗi phần tử khác bởi yếu tố cho một đầu ra như thế này:

a-b= [[-4,-4,-4,-4],[7,2,2,2],[-1,-1,-1,-1,-1]] 

để làm được vì vậy tôi chuyển đổi mỗi a và b cho các mảng và trừ chúng tôi sử dụng:

np.array(a)-np.array(b) 

Đầu ra chỉ cung cấp cho tôi lỗi:

Unsupported Operand type for-: 'list' and 'list'

Tôi đang làm gì sai? Không nên lệnh np.array đảm bảo chuyển đổi thành mảng?

Answer 1

Bạn có thể thử:

>>> a= [[1,2,3,4], [2,3,4,5],[3,4,5,6,7]] 
>>> b= [[5,6,7,8], [9,1,2,3], [4,5,6,7,8]] 
>>> 
>>> c =[] 
>>> for i in range(len(a)): 
    c.append([A - B for A, B in zip(a[i], b[i])]) 


>>> print c 
[[-4, -4, -4, -4], [-7, 2, 2, 2], [-1, -1, -1, -1, -1]] 

Hoặc phương pháp thứ 2 là sử dụng đồ:

from operator import sub 
a= [[1,2,3,4], [2,3,4,5],[3,4,5,6,7]] 
b= [[5,6,7,8], [9,1,2,3], [4,5,6,7,8]] 
c =[] 
for i in range(len(a)): 
    c.append(map(sub, a[i], b[i])) 
print c 
[[-4, -4, -4, -4], [-7, 2, 2, 2], [-1, -1, -1, -1, -1]] 

Answer 2

Kích thước của hai mảng không khớp nhau, nghĩa là hai danh sách con đầu tiên của a có 4 phần tử, nhưng phần tử thứ ba có 5 và ditto với b. Nếu bạn chuyển đổi các danh sách này để numpy arrays, numpy âm thầm mang lại cho bạn một cái gì đó như thế này:

In [346]: aa = np.array(a) 
In [347]: bb = np.array(b) 
In [348]: aa 
Out[348]: array([[1, 2, 3, 4], [2, 3, 4, 5], [3, 4, 5, 6, 7]], dtype=object) 
In [349]: bb 
Out[349]: array([[5, 6, 7, 8], [9, 1, 2, 3], [4, 5, 6, 7, 8]], dtype=object) 

Bạn cần phải chắc chắn rằng tất cả các danh sách con của bạn có cùng một số yếu tố, sau đó mã của bạn sẽ làm việc:

In [350]: a = [[1,2,3,4], [2,3,4,5],[3,4,5,6]]; b = [[5,6,7,8], [9,1,2,3], [4,5,6,7]] # I removed the last element of third sublist in a and b 
In [351]: np.array(a) - np.array(b) 
Out[351]: 
array([[-4, -4, -4, -4], 
     [-7, 2, 2, 2], 
     [-1, -1, -1, -1]]) 

Answer 3

Without NumPy:

result = [] 
for (m, n) in (zip(a, b)): 
    result.append([i - j for i, j in zip(m, n)]) 

cũng Xem this question và this one.

Answer 4

gì về một chức năng tùy chỉnh như:

import numpy as np 

a = [[1, 2, 3, 4], [2, 3, 4, 5], [3, 4, 5, 6, 7]] 
b = [[5, 6, 7, 8], [9, 1, 2, 3], [4, 5, 6, 7, 8]] 


def np_substract(l1, l2): 
    return np.array([np.array(l1[i]) - np.array(l2[i]) for i in range(len(l1))]) 

print np_substract(a, b) 

Answer 5

Dưới đây là một cách Numpythonic:

>>> y = map(len, a) 
>>> a = np.hstack(np.array(a)) 
>>> b = np.hstack(np.array(b)) 
>>> np.split(a-b, np.cumsum(y)) 
[array([-4, -4, -4, -4]), array([-7, 2, 2, 2]), array([-1, -1, -1, -1, -1]), array([], dtype=float64)] 
>>> 

Vì bạn không thể trừ các mảng với hình dạng khác nhau, bạn có thể san bằng mảng bằng cách sử dụng np.hstack() sau đó trừ các mảng phẳng của bạn sau đó định hình lại dựa trên hình dạng trước đó.

Answer 6

Bạn đang gặp lỗi, vì mã của bạn đang cố gắng để trừ sublist từ sublist, nếu bạn muốn làm cho nó hoạt động, bạn có thể làm tương tự theo cách sau:

import numpy as np 
a= [[1,2,3,4], [2,3,4,5],[3,4,5,6,7]] 
b= [[5,6,7,8], [9,1,2,3], [4,5,6,7,8]] 

#You can apply different condition here, like (if (len(a) == len(b)), then only run the following code  
for each in range(len(a)): 
    list = np.array(a[each])-np.array(b[each]) 
    #for converting the output array in to list 
    subList[each] = list.tolist() 

print subList 

Answer 7

Một danh sách hiểu lồng nhau sẽ thực hiện công việc:

In [102]: [[i2-j2 for i2,j2 in zip(i1,j1)] for i1,j1 in zip(a,b)] 
Out[102]: [[-4, -4, -4, -4], [-7, 2, 2, 2], [-1, -1, -1, -1, -1]] 

vấn đề với np.array(a)-np.array(b) là các danh sách con khác nhau về chiều dài, vì vậy các mảng kết quả là loại đối tượng - mảng các danh sách

In [104]: np.array(a) 
Out[104]: array([[1, 2, 3, 4], [2, 3, 4, 5], [3, 4, 5, 6, 7]], dtype=object) 

Phép trừ đang lặp qua mảng ngoài tốt, nhưng nhấn vào một vấn đề khi trừ một danh sách con khỏi danh sách con khác - do đó là thông báo lỗi.

Nếu tôi làm đầu vào mảng của các mảng, các phép trừ sẽ làm việc

In [106]: np.array([np.array(a1) for a1 in a]) 
Out[106]: array([array([1, 2, 3, 4]), array([2, 3, 4, 5]), array([3, 4, 5, 6, 7])], dtype=object) 

In [107]: aa=np.array([np.array(a1) for a1 in a]) 
In [108]: bb=np.array([np.array(a1) for a1 in b]) 

In [109]: aa-bb 
Out[109]: 
array([array([-4, -4, -4, -4]), 
     array([-7, 2, 2, 2]), 
     array([-1, -1, -1, -1, -1])], dtype=object) 

Bạn không thể đếm hoạt động mảng làm việc trên mảng đối tượng dtype. Nhưng trong trường hợp này, subtraction được xác định cho các mạng con, vì vậy nó có thể xử lý việc lồng ghép.

Cách khác để làm tổ được sử dụng np.subtract. Đây là một phiên bản ufunc của - và sẽ áp dụng np.asarray đến đầu vào của nó khi cần thiết:

In [103]: [np.subtract(i1,j1) for i1,j1 in zip(a,b)] 
Out[103]: [array([-4, -4, -4, -4]), array([-7, 2, 2, 2]), array([-1, -1, -1, -1, -1])] 

Chú ý rằng những tính toán mảng trở lại mảng hoặc một danh sách các mảng. Việc chuyển các mảng bên trong trở lại danh sách yêu cầu lặp lại.

Nếu bạn đang bắt đầu với danh sách, chuyển đổi thành mảng thường không tiết kiệm thời gian. Mảng tính toán có thể nhanh hơn, nhưng điều đó không bù đắp cho chi phí trong việc tạo ra các mảng ở nơi đầu tiên.

Nếu tôi đệm đầu vào theo chiều dài bằng nhau, thì phép trừ mảng đơn giản sẽ tạo ra mảng 2d.

In [116]: ao= [[1,2,3,4,0], [2,3,4,5,0],[3,4,5,6,7]]; bo= [[5,6,7,8,0], [9,1,2,3,0], [4,5,6,7,8]] 

In [117]: np.array(ao)-np.array(bo) 
Out[117]: 
array([[-4, -4, -4, -4, 0], 
     [-7, 2, 2, 2, 0], 
     [-1, -1, -1, -1, -1]])