IX. NumPy Logical Operations (逻辑运算)#

Logical operations (逻辑运算) in NumPy work element-wise on arrays and always return a boolean array (布尔数组). These are the foundation of masking (掩码) and conditional filtering (条件筛选).

1. Comparison Operators (比较运算符)#

Core idea: Compare each element to a value or to another array. Returns True/False for each position.

1
import numpy as np
2

3
a = np.array([1, 2, 3, 4, 5])
4

5
a > 3          # [False False False  True  True]
6
a == 3         # [False False  True False False]
7
a != 3         # [ True  True False  True  True]
8
a >= 3         # [False False  True  True  True]
9

10
# Functional equivalents (函数式写法)
11
np.greater(a, 3)       # same as a > 3
12
np.less(a, 3)          # same as a < 3
13
np.equal(a, 3)         # same as a == 3
14
np.not_equal(a, 3)     # same as a != 3

Note: Never use Python's `and` / `or` / `not` on arrays — they raise errors. Always use np.logical_and / logical_or / logical_not instead.

2. Logical AND / OR / NOT (逻辑与/或/非)#

Core idea: Combine boolean arrays element-wise. Use &, |, ~ as shorthand.

1
a = np.array([1, 2, 3, 4, 5])
2

3
# AND (与): both conditions must be True
4
mask = (a > 2) & (a < 5)             # [F F T T F]
5
np.logical_and(a > 2, a < 5)         # same
6

7
# OR (或): at least one condition is True
8
mask = (a < 2) | (a > 4)             # [T F F F T]
9
np.logical_or(a < 2, a > 4)          # same
10

11
# NOT (非): invert boolean
12
mask = ~(a > 3)                       # [T T T F F]
13
np.logical_not(a > 3)                 # same

Note: Always wrap individual conditions in parentheses when using & and |, because & has higher precedence than > in Python. E.g., write (a > 2) & (a < 5), not a > 2 & a < 5.

3. Boolean Masking — Filter Arrays (布尔掩码筛选)#

Core idea: Use a boolean array as an index to select matching elements.

1
a = np.array([10, 25, 3, 47, 8, 60])
2

3
mask = a > 20
4
print(mask)    # [False  True False  True False  True]
5
print(a[mask]) # [25 47 60]  — only values where mask is True
6

7
# One-liner
8
a[a > 20]      # [25 47 60]
9
a[(a > 10) & (a < 50)]  # [25 47]

4. `np.where()` — Conditional Selection (条件选择)#

Core idea: Like a vectorized ternary: where(condition, value_if_true, value_if_false).

1
a = np.array([1, -2, 3, -4, 5])
2

3
np.where(a > 0, a, 0)       # [1  0  3  0  5]  — replace negatives with 0
4
np.where(a > 0, 'pos', 'neg')  # ['pos' 'neg' 'pos' 'neg' 'pos']
5

6
# Without x, y: returns indices where condition is True (返回满足条件的索引)
7
np.where(a > 0)    # (array([0, 2, 4]),)

5. `any()` / `all()` — Global Boolean Tests (全局布尔检验)#

Core idea: Test whether any or all elements satisfy a condition.

1
a = np.array([1, 2, 3, 4, 5])
2

3
np.any(a > 4)          # True  — at least one element > 4
4
np.all(a > 0)          # True  — all elements > 0
5
np.all(a > 3)          # False — not all > 3
6

7
# With axis
8
m = np.array([[1, 2], [0, 4]])
9
np.any(m == 0, axis=1)  # [False  True]

6. `isnan()` / `isinf()` — Special Value Checks (特殊值检验)#

1
a = np.array([1.0, np.nan, np.inf, -np.inf, 2.0])
2

3
np.isnan(a)    # [F  T  F  F  F]
4
np.isinf(a)    # [F  F  T  T  F]
5
np.isfinite(a) # [T  F  F  F  T]
6

7
# Clean NaN values (清除NaN值)
8
a[~np.isnan(a)]   # [1.  inf -inf  2.]

7. Quick Comparison Table#

Operation (操作)	Shorthand	Function
Greater than (大于)	`a > b`	`np.greater(a, b)`
Less than (小于)	`a < b`	`np.less(a, b)`
Equal (等于)	`a == b`	`np.equal(a, b)`
AND (与)	`mask1 & mask2`	`np.logical_and(m1, m2)`
OR (或)	`mask1	mask2`
NOT (非)	`~mask`	`np.logical_not(mask)`
Conditional replace	—	`np.where(cond, x, y)`
Any true?	—	`np.any(cond)`
All true?	—	`np.all(cond)`

💡 One-line Takeaway
Build boolean masks with & / | / ~ (always use parentheses!), apply them for filtering, and use np.where() for conditional replacement.