以并行方式从数组中删除条目

Question

I have a list/array of x and y coordinates, for example:

x = [x1, x2, x3,...]
y = [y1, y2, y3,...]

Now, I want to remove certain entries based on conditions, for example, the following:

for i in x:
    if i <= 40 and i >= -40:
        print "True"
    else:
        x.remove(i)

for i in y:
    if i <= 20 and i >=- 20:
        print "True"
    else:
        y.remove(i)

The code above removes the respective entries from the lists, but if x1 is removed, y1 still remains in the list. What I want to achieve is, if x1 is removed, y1 should also be removed. How can I go about doing this? My final goal is to try to plot x and y , so I am unable to do this as the lists end up having different dimensions. I can also use

zeta_list = np.column_stack((x, y))

to get an array like ([[x1, y1], [x2, y2], [x3, y3],...]]) , but I am not sure how to remove entries from this using an if conditional.

Thanks.

Answer 1

Form a boolean selection mask:

mask = ~((x > 40) | (x < -40) | (y > 20) | (y < -20))

then, to select values from x and y where mask is True:

x, y = x[mask], y[mask]

---

When x is a NumPy array, (x > 40) returns a boolean array of the same shape as x which is True where the elements of x are greater than 40.

Note the use of | for bitwise-or and ~ for not (boolean negation).

---

Alternatively, by De Morgan's law , you could use

mask = ((x <= 40) & (x >= -40) & (y <= 20) & (y >= -20))

NumPy operations are performed element-wise . So mask is True whereever an element of x is between -40 and 40 and the corresponding element of y is between -20 and 20.

---

For example,

import numpy as np
x = [-50, -50, 30, 0, 50]
y = [-30, 0, 10, 30, 40]

# change the lists to NumPy arrays
x, y = np.asarray(x), np.asarray(y)
# mask = ~((x > 40) | (x < -40) | (y > 20) | (y < -20))
mask = ((x <= 40) & (x >= -40) & (y <= 20) & (y >= -20))
x, y = x[mask], y[mask]

yields

In [35]: x
Out[35]: array([30])

In [36]: y
Out[36]: array([10])

with

In [37]: mask
Out[37]: array([False, False,  True, False, False], dtype=bool)

Answer 2

Another option is to work with list-comprehension :

Input :

x = [50, 10, -50, 30, 5, 6]
y = [2, 40, 10, 5, 3, 5]

Code :

x, y = list(zip(*[(x, y) for x, y in zip(x, y) if x <= 40 and x > -40 and y <= 20 and y > -20]))

Output :

x
# (30, 5, 6)

y
# (5, 3, 5)

Answer 3

Try this:

mask = ((x <= 40) & (x >= -40) & (y <= 20) & (y >= -20))
x, y = x[mask], y[mask]

NumPy will vectorize these operations, so it should be very efficient.

This blog post might be helpful, and here's the manual for np.where() which shows some similar examples.

Answer 4

This should do it.

for i in x1:
    if i <= 40 and i >= -40:
        print "True"
        for i in y1:
            if i <=20 and i >=-20:
                print "True"
            else:
                x1.remove(i)
                y1.remove(i)
    else:
        x1.remove(i)
        y1.remove(i)

Hope this helped!

Thanks!

Answer 5

For completeness, here is a solution based on itertools .

Consider the following lists of coordinates:

x = [-50, -50, -10,   0,  10, 50, 50, -10, -10, 0, 10, 40]
y = [-50, -20, -50,  50, -50, 20, 50, -20, -10, 0, 20, 10]

Our goal is to set-up a boolean mask with the value True in those indices n for which x[n] and y[n] lie in certain intervals, and False elsewhere. The intervals' boundaries are:

xmin, xmax = -40, 40
ymin, ymax = -20, 20

We can create such a mask through a list comprehension:

mask = [xmin <= i <= xmax and ymin <= j <= ymax for (i, j) in zip(x, y)]

The boolean expression xmin <= i <= xmax and ymin <= j <= ymax is evaluated for each pair of corresponding coordinates. If both i and j belong to the specified intervals the expression is evaluated as True , and False otherwise. The fact that comparisons can be chained in Python makes this boolean expression pretty compact and readable.

Finally, we can get rid of those coordinate pairs that fall outside limits using the function itertools.compress() :

from itertools import compress
x_clipped = list(compress(x, mask))
y_clipped = list(compress(y, mask))

Demo:

In [117]: mask
Out[117]: [False, False, False, False, False, False, False, True, True, True, True, True]

In [118]: x_clipped
Out[118]: [-10, -10, 0, 10, 40]

In [119]: y_clipped
Out[119]: [-20, -10, 0, 20, 10]