通过python在列表中找到不同的对

Question

I have a list and I want to find different pair in list. I implement a function --> different()

import numpy as np


def different(array):
    res = []
    for (x1, y1), (x2, y2) in array:
        if (x1, y1) != (x2, y2):
            res.append([(x1, y1), (x2, y2)])
    return res


a = np.array([[[1, 2], [3, 4]],
              [[1, 2], [1, 2]],
              [[7, 9], [6, 3]],
              [[3, 3], [3, 3]]])

out = different(a)  # get [[(1, 2), (3, 4)],
                    #      [(7, 9), (6, 3)]]

Is there any other better way to do it? I want to improve my function different . List size may be greater than 100,000.

Answer 1

The numpy way to do it is

import numpy as np

a = np.array([[[1, 2], [3, 4]],
              [[1, 2], [1, 2]],
              [[7, 9], [6, 3]],
              [[3, 3], [3, 3]]])

b = np.logical_or(a[:,0,0] != a[:,1,0],  a[:,0,1] != a[:,1,1])

print(a[b])

Answer 2

Vectorized Comparison

a[~(a[:, 0] == a[:, 1]).all(1)]

array([[[1, 2],
        [3, 4]],

       [[7, 9],
        [6, 3]]])

This works by taking the first pair of each subarray and comparing each one with the second pair. All subarrays for which entries which are not identical only are selected. Consider,

a[:, 0] == a[:, 1]

array([[False, False],
       [ True,  True],
       [False, False],
       [ True,  True]])

From this, we want those rows which do not have True at each column. So, on this result, use all and then negate the result.

~(a[:, 0] == a[:, 1]).all(1)
array([ True, False,  True, False])

This gives you a mask you can then use to select subarrays from a .

---

np.logical_or.reduce

Similar to the first option above, but approaches this problem from the other end (see DeMorgan's Law).

a[np.logical_or.reduce(a[:, 0] != a[:, 1], axis=1)]

Answer 3

Solutions time comparisons

When there are so many different approaches to a problem, time comparisons can really help sort out the better answers.

Setup

We use an array of size (200000, 2, 2) as OP Vincentlai pointed out that is in the range of the expected array size.

a = np.array(np.random.randint(10, size=(200000, 2, 2)))

---

---

Using Joe answer: numpy.logical_and

%timeit b = a[np.logical_and(a[:,0,0] != a[:,1,0],  a[:,0,1] != a[:,1,1])]
>>> 5.12 ms ± 110 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

---

Using Coldspeed first answer: vectorised comparison

%timeit b = a[~(a[:, 0] == a[:, 1]).all(1)]
>>> 13.7 ms ± 559 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

---

Using Coldspeed second answer: numpy.logical_or

%timeit b = a[np.logical_or.reduce(a[:, 0] != a[:, 1], axis=1)]
>>> 13.2 ms ± 498 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

---

Using U9 Forward answer: filters

%timeit b = list(filter(lambda x: x[0]!=x[1],a.tolist()))
>>> 102 ms ± 4.02 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)

---

Using aydow answer: filters

%timeit b = [[(x1, y1), (x2, y2)] for (x1, y1), (x2, y2) in a if (x1, y1) != (x2, y2)]
>>> 752 ms ± 11.6 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

---

---

Conclusions

Joe's approach with numpy.logical_and is by far the faster one. Predictably, every full python approach falls extremely short to anything numpy.

Answer 4

Try using filter :

import numpy as np

def different(array):   
   return list(filter(lambda x: x[0]!=x[1],array.tolist()))

a = np.array([[[1, 2], [3, 4]],
              [[1, 2], [1, 2]],
              [[7, 9], [6, 3]],
              [[3, 3], [3, 3]]])

out = different(a)
print(out)

Answer 5

By using list comprehension in one line we can do like as below,

items_list = [[[1, 2], [3, 4]],
              [[1, 2], [1, 2]],
              [[7, 9], [6, 3]],
              [[3, 3], [3, 3]]
             ]

# Output
[itm for itm in items_list if itm[0] != itm[1]]

Answer 6

Use a list comprehension

def different(array):
    return [[(x1, y1), (x2, y2)] for (x1, y1), (x2, y2) in array if (x1, y1) != (x2, y2)]