Numpy 第四章 逻辑函数

绛橘色的日落(。・∀・)ノ2026-04-05 9:55

一.真值测试

1. numpy.all（）函数：所有元素是否为真

原型：

复制代码 
numpy.all(a, axis=None, out=None, keepdims=np._NoValue)

  • a：输入数组（或可转换为数组的对象）。

  • axis ：指定检查的轴（维度），None时检查所有元素。

  • out：输出数组（可选）。

  • keepdims：是否保持维度（可选）。

功能 ：沿指定轴检查所有元素是否都为 True（或非零），返回布尔值或布尔数组。

例：检查所有元素是否为真

复制代码 
import numpy as np

a = np.array([1, 2, 3])  # 所有元素非零 → True
print(np.all(a))  # True

a = np.array([1, 0, 3])  # 存在 0 → False
print(np.all(a))  # False

例：沿轴检查（二维数组）

复制代码 
x = np.array([[1, 2], 
              [3, 4]])

# axis=0：沿列检查（每列的所有元素是否为真）
print(np.all(x, axis=0))  # [True True]（两列的元素都非零）

# axis=1：沿行检查（每行的所有元素是否为真）
print(np.all(x, axis=1))  # [True True]（两行的元素都非零）

# axis=None：检查所有元素
print(np.all(x))  # True（所有元素非零）

2.numpy.any（）函数：存在元素是否为真

原型：

复制代码 
numpy.any(a, axis=None, out=None, keepdims=np._NoValue)
  • 参数含义与 all一致。

功能 ：沿指定轴检查是否存在至少一个 元素为 True（或非零），返回布尔值或布尔数组。

例：检查是否存在真元素

复制代码 
import numpy as np

a = np.array([1, 0, 3])  # 存在 1、3 → True
print(np.any(a))  # True

a = np.array([0, 0, 0])  # 全为 0 → False
print(np.any(a))  # False

例：沿轴检查（二维数组）

复制代码 
x = np.array([[1, 0], 
              [0, 4]])

# axis=0：沿列检查（每列是否存在真元素）
print(np.any(x, axis=0))  # [True True]（第一列有 1，第二列有 4）

# axis=1：沿行检查（每行是否存在真元素）
print(np.any(x, axis=1))  # [True True]（第一行有 1，第二行有 4）

# axis=None：检查所有元素
print(np.any(x))  # True（存在 1、4）

3.结合布尔运算和索引的例

复制代码 
import numpy as np

# 示例 1：数组比较 + all/any
a = np.array([0, 4, 5])
b = np.copy(a)  # 深拷贝
print(np.all(a == b))  # True（所有元素相等）
print(np.any(a == b))  # True（存在元素相等，实际是全部）

# 修改 a[0] 后验证
a[0] = 1
print(np.all(a == b))  # False（a[0]≠b[0]）
print(np.any(a == b))  # True（a[1]、a[2] 仍等于 b[1]、b[2]）

# 示例 2：浮点数和 NaN 的特殊处理（NaN 与自身不相等）
print(np.all([1.0, np.nan]))  # True（1.0 是真，nan 不影响？不，实际是：all 会检查所有元素是否为真，nan 在布尔上下文中视为 True？不对，numpy 中 nan 参与比较会返回 False，但 all 是"所有元素是否为真"，而 nan 本身的布尔值是 True？这里可能需要更仔细分析：
# 实际上，numpy 中 `np.all([1.0, np.nan])` 会返回 True，因为 1.0 是 True，而 nan 在布尔上下文中被视为 True（但 `1.0 == np.nan` 是 False）。但 `np.any([1.0, np.nan])` 也返回 True。

# 示例 3：单位矩阵（eye）的 all/any 检查
a = np.eye(3)  # 3x3 单位矩阵，对角线为 1，其余为 0
print(np.all(a, axis=0))  # [False False False]（每列只有一个 1，其余是 0 → 不是所有元素为真）
print(np.any(a, axis=0))  # [True True True]（每列至少有一个 1）

对比

函数 功能 示例（一维数组 [0,1,2]）
all 所有元素是否为真（非零） np.all([0,1,2])→ False（存在 0）
any 存在元素是否为真（非零） np.any([0,1,2])→ True（存在 1、2）

二.数组内容

1. numpy.isnan：检测数组中的 NaN 值

原型：

复制代码 
numpy.isnan(x, *args, **kwargs)

  • x：输入数组（通常是浮点数数组，因为整数数组不会有 NaN）。

  • 功能：逐元素检测 是否为 NaN（Not a Number），返回布尔数组（元素为 NaN则为 True，否则 False）。

例：基础检测

复制代码 
import numpy as np

a = np.array([1, 2, np.nan])  # np.nan 是 NaN 的表示
print(np.isnan(a))  
# [False False  True]  # 只有第三个元素是 NaN

2.NaN 的特性

  • NaN是浮点数特有的 ，整数数组无法直接存储 NaN（会报错或自动转为浮点数）。

  • NaN与任何值（包括自身）比较都返回 False，例如 np.nan == np.nan→ False。

  • 因此，检测 NaN必须用 isnan ，不能用 ==或 !=。

3.运用场景

  • 数据清洗：检测数组/矩阵中的缺失值（NaN），并进行填充或删除。

  • 科学计算：在浮点数运算中（如除以零、无效运算），结果可能为 NaN，需检测并处理。

三.逻辑运算

1. numpy.logical_not()函数：逻辑非（NOT）

功能 ：对每个元素取反（True→False，False→True，非0→False，0→True）。

原型：

复制代码 
numpy.logical_not(x, *args, **kwargs)

例：标量输入

复制代码 
import numpy as np

print(np.logical_not(3))       # 3是非零→True？不，logical_not对"真值"取反。Python中3的真值是True，所以取反后是False
# False

print(np.logical_not(0))       # 0的真值是False，取反后是True
# True

例：数组/序列输入

复制代码 
# 对布尔列表取反
print(np.logical_not([True, False, 0, 1]))  
# [False  True  True False]  
# 解释：True→False；False→True；0（假）→True；1（真）→False

例：结合数组比较

复制代码 
x = np.arange(5)  # [0,1,2,3,4]
print(np.logical_not(x < 3))  
# [False False False  True  True]  
# 解释：x<3的结果是[True,True,True,False,False]，取反后对应上述结果

2.numpy.logical_and（）函数：逻辑与（AND）

功能 ：逐元素判断 x1 AND x2（两个元素都为真时，结果才为真）。

原型：

复制代码 
numpy.logical_and(x1, x2, *args, **kwargs)

例：标量输入

复制代码 
print(np.logical_and(True, False))  # 一真一假→False
# False

例：数组/序列输入（逐元素运算）

复制代码 
# 两个布尔列表逐元素AND
print(np.logical_and([True, False], [True, False]))  
# [ True False]  
# 解释：(True&True)=True；(False&False)=False

# 数组比较的AND（x>1 且 x<4）
x = np.arange(5)  # [0,1,2,3,4]
print(np.logical_and(x > 1, x < 4))  
# [False False  True  True False]  
# 解释：x>1→[F,F,T,T,F]；x<4→[T,T,T,T,F]；逐元素AND后得到上述结果

3.numpy.logical_or（）函数：逻辑或（OR）

功能 ：逐元素判断 x1 OR x2（两个元素至少一个为真时，结果为真）。

原型：

复制代码 
numpy.logical_or(x1, x2, *args, **kwargs)

例：标量输入

复制代码 
print(np.logical_or(True, False))  # 一真一假→True
# True

例：数组/序列输入（逐元素运算）

复制代码 
# 两个布尔列表逐元素OR
print(np.logical_or([True, False], [False, False]))  
# [ True False]  
# 解释：(True|False)=True；(False|False)=False

# OR（x<1 或 x>3）
x = np.arange(5)  # [0,1,2,3,4]
print(np.logical_or(x < 1, x > 3))  
# [ True False False False  True]  
# 解释：x<1→[T,F,F,F,F]；x>3→[F,F,F,F,T]；逐元素OR后得到上述结果

4. numpy.logical_xor（）函数：逻辑异或（XOR）

功能 ：逐元素判断 x1 XOR x2（两个元素不同时，结果为真；相同时为假）。

原型：

复制代码 
numpy.logical_xor(x1, x2, *args, **kwargs)

例：标量输入

复制代码 
print(np.logical_xor(True, False))  # 一真一假→True
# True

例：数组/序列输入（逐元素运算）

复制代码 
# 两个布尔列表逐元素XOR
print(np.logical_xor([True, True, False, False], [True, False, True, False]))  
# [False  True  True False]  
# 解释：(T^T)=F；(T^F)=T；(F^T)=T；(F^F)=F 数组与矩阵的XOR（0 与 np.eye(2)）
print(np.logical_xor(0, np.eye(2)))  
# [[ True False]
#  [False  True]]  
# 解释：np.eye(2)是[[1,0],[0,1]]；0的逻辑值是False，所以逐元素XOR（False ^ 1=True；False ^ 0=False；以此类推）

# 数组比较的XOR（x<1 异或 x>3）
x = np.arange(5)  # [0,1,2,3,4]
print(np.logical_xor(x < 1, x > 3 [ True False False False  True]？不，看图片示例：
# 图片中示例：print(np.logical_xor([True, True, False, False], [True, False, True, False])) → [False  True  True False]
# 另一个示例：print(np.logical_xor(0, np.eye(2))) → [[ True False], [False  True]]
# 再看图片中最后一个示例：
x = np(5)
print(np.logical_xor(x < 1, x > 3))  
# 图片中输出：#[ True False False False  True]？不，图片里的示例是：
# print(np.logical_xor([True, True, False, False], [True, False, True, False]))
# #[False  True  True False]
# 而x[True,False,False,False,False]，x>3是[False,False,False,False,True]，异或后：
# True^False=True；False^False=False；False^False=False；False^False=False；False^True=True → 所以结果是[True,False,False,False,True]，和图片中的注释一致。

注：

  • 这四个函数都是逐元素进行逻辑运算，支持数组、列表、标量混合输入（会自动广播）。

  • 逻辑运算的"真值"：非0数值视为 True，0 视为 False；布尔值直接按 True/False运算。

  • 常用于数组比较的组合条件 （比如 x>1 且 x<4用 logical_and，x<1 或 x>3用 logical_or等）。

四.对照

1.比较函数

NumPy 的比较函数支持元素级运算 ，即对数组中的每个元素分别进行比较，返回布尔值数组。这些函数与 Python 的运算符（>, >=, ==, !=, <, <=）一一对应，且功能完全等价。

函数 运算符 含义
numpy.greater(x1, x2) x1 > x2 大于
numpy.greater_equal(x1, x2) x1 >= x2 大于等于
numpy.equal(x1, x2) x1 == x2 等于
numpy.not_equal(x1, x2) x1 != x2 不等于
numpy.less(x1, x2) x1 < x2 小于
numpy.less_equal(x1, x2) x1 <= x2 小于等于

例：

复制代码 
import numpy as np

x = np.array([1, 2, 3, 4, 5, 6, 7, 8])

# 1. 大于 (>) / greater
y = x > 2
print("x > 2:", y)
print("np.greater(x, 2):", np.greater(x, 2))
# 输出: [False False  True  True  True  True  True  True]

# 2. 大于等于 (>=) / greater_equal
y = x >= 2
print("\nx >= 2:", y)
print("np.greater_equal(x, 2):", np.greater_equal(x, 2))
# 输出: [False  True  True  True  True  True  True  True]

# 3. 等于 (==) / equal
y = x == 2
print("\nx == 2:", y)
print("np.equal(x, 2):", np.equal(x, 2))
# 输出: [False  True False False False False False False]

# 4. 不等于 (!=) / not_equal
y = x != 2
print("\nx != 2:", y)
print("np.not_equal(x, 2):", np.not_equal(x, 2))
# 输出: [ True False  True  True  True  True  True  True]

# 5. 小于 (<) / less
y = x < 2
print("\nx < 2:", y)
print("np.less(x, 2):", np.less(x, 2))
# 输出: [ True False False False False False False False]

# 6. 小于等于 (<=) / less_equal
y = x <= 2
print("\nx <= 2:", y)
print("np.less_equal(x, 2):", np.less_equal(x, 2))
# 输出: [ True  True False False False False False False]

注：

  1. 元素级运算​

    NumPy 会自动将标量（如 2）与数组的每个元素进行比较，无需显式循环。

  2. 运算符重载​

    NumPy 重载了 Python 的运算符，因此 x > 2和 np.greater(x, 2)的结果完全一致。

  3. 布尔数组用途​

    生成的布尔数组常用于条件筛选 （如 x[x > 2]会返回所有大于 2 的元素）。

  4. 性能优势​

    这些函数在底层用 C 实现，比手动写循环遍历数组快得多。

常见应用场景

  • 数据清洗（过滤异常值）

  • 条件索引（如 x[x % 2 == 0]筛选偶数）

  • 逻辑判断（结合 np.all()/np.any()检查整体条件）

2.numpy.isclose（）函数

复制代码 
numpy.isclose(a, b, rtol=1.e-5, atol=1.e-8, equal_nan=False)

  • 作用 ：逐元素比较两个数组是否在指定容差范围内相等。

  • 返回值：一个布尔数组，长度与输入数组相同。

  • 判断条件（对每个元素）：

    复制代码 
    |a - b| <= atol + rtol * |b|

    • rtol：相对容差 （Relative Tolerance），默认 1e-5。

    • atol：绝对容差 （Absolute Tolerance），默认 1e-8。

    • equal_nan：若为 True，则 NaN被视为相等（仅当两个数组在相同位置都为 NaN时）。

  • 适用场景：比较浮点数是否"足够接近"，避免因浮点运算误差导致的严格不等。

3.numpy.allclose（）函数

复制代码 
 numpy.allclose(a, b, rtol=1.e-5, atol=1.e-8, equal_nan=False)

  • 作用 ：判断两个数组是否所有元素都在容差范围内相等。

  • 返回值 ：单个布尔值 True或 False。

  • 等价写法：

    复制代码 
    numpy.all(isclose(a, b, rtol=rtol, atol=atol, equal_nan=equal_nan))

  • 适用场景：判断两个浮点数数组是否"整体近似相等"。

特殊值处理

  • NaN ：默认 isclose和 allclose认为 NaN != NaN（返回 False），除非设置 equal_nan=True。

  • Inf ：若两个数组在相同位置的 Inf符号相同（如都是 +inf或都是 -inf），则视为相等。

例：

复制代码 
import numpy as np

# ========== 示例 1：基本比较（大数与小数） ==========
x = np.isclose([1e10, 1e-7], [1.00001e10, 1e-8])
print("x = np.isclose([1e10, 1e-7], [1.00001e10, 1e-8])")
print(x)  # [ True False ]

x = np.allclose([1e10, 1e-7], [1.00001e10, 1e-8])
print("\nx = np.allclose([1e10, 1e-7], [1.00001e10, 1e-8])")
print(x)  # False

x = np.isclose([1e10, 1e-8], [1.00001e10, 1e-9])
print("\nx = np.isclose([1e10, 1e-8], [1.00001e10, 1e-9])")
print(x)  # [ True  True ]

x = np.allclose([1e10, 1e-8], [1.00001e10, 1e-9])
print("\nx = np.allclose([1e10, 1e-8], [1.00001e10, 1e-9])")
print(x)  # True

# ========== 示例 2：NaN 处理 ==========
x = np.isclose([1.0, np.nan], [1.0, np.nan])
print("\nx = np.isclose([1.0, np.nan], [1.0, np.nan])")
print(x)  # [ True False ]

x = np.allclose([1.0, np.nan], [1.0, np.nan])
print("\nx = np.allclose([1.0, np.nan], [1.0, np.nan])")
print(x)  # False

x = np.isclose([1.0, np.nan], [1.0, np.nan], equal_nan=True)
print("\nx = np.isclose([1.0, np.nan], [1.0, np.nan], equal_nan=True)")
print(x)  # [ True  True ]

x = np.allclose([1.0, np.nan], [1.0, np.nan], equal_nan=True)
print("\nx = np.allclose([1.0, np.nan], [1.0, np.nan], equal_nan=True)")
print(x)  # True

分析：

代码示例 输出 说明
np.isclose([1e10, 1e-7], [1.00001e10, 1e-8]) [ True False ] 第一个元素：`
np.allclose([1e10, 1e-7], [1.00001e10, 1e-8]) False 因为有一个元素不满足 isclose
np.isclose([1e10, 1e-8], [1.00001e10, 1e-9]) [ True True ] 第一个元素同上；第二个元素：`
np.allclose([1e10, 1e-8], [1.00001e10, 1e-9]) True 所有元素都满足 isclose
np.isclose([1.0, np.nan], [1.0, np.nan]) [ True False ] 默认 equal_nan=False，NaN != NaN→ False
np.allclose([1.0, np.nan], [1.0, np.nan]) False 同上
np.isclose([1.0, np.nan], [1.0, np.nan], equal_nan=True) [ True True ] equal_nan=True，NaN == NaN→ True
np.allclose([1.0, np.nan], [1.0, np.nan], equal_nan=True) True 所有元素都满足 isclose

运用方法

  1. 浮点数比较 ：永远不要用 ==比较浮点数，应使用 isclose或 allclose。

  2. 容差选择：

    • rtol适用于数值较大的情况（相对误差）。

    • atol适用于数值接近 0 的情况（绝对误差）。

  3. NaN 处理 ：若数组中可能包含 NaN，且希望将它们视为相等，务必设置 equal_nan=True。

  4. 性能考虑 ：isclose是逐元素操作，allclose是在 isclose基础上做聚合，适合最终判断"整体是否近似相等"。

相关推荐
world-wide-wait1 天前
机器学习04——numpy
人工智能·机器学习·numpy
书到用时方恨少!1 天前
Python NumPy 使用指南：科学计算的基石
开发语言·python·numpy
人工干智能2 天前
科普：Python / Numpy / PyTorch 的数据拼接方法
pytorch·python·numpy
恋喵大鲤鱼4 天前
DYOR CAKE
numpy
FelixZhang0285 天前
从 PDF 到 AI 知识库：RAG 数据预处理的六步标准流水线 (SOP)
人工智能·python·目标检测·计算机视觉·语言模型·ocr·numpy
哈伦20195 天前
第四章 Numpy
numpy
MediaTea6 天前
NumPy 应用实例：用户行为数据分析（归一化和标准化处理）
数据挖掘·数据分析·numpy
chushiyunen8 天前
python numpy包的使用
开发语言·python·numpy
MediaTea8 天前
NumPy 函数手册：线性代数
线性代数·numpy
热门推荐
01GitHub 镜像站点02Qwen3.5-Omni与Qwen3.6模型全面解析（含测评/案例/使用教程）03VMware Workstation Pro 17 虚拟机完整安装教程（2026最新）04OpenClaw 请求超时 llm request timed out 怎么解决？3 种方案实测，附完整排查流程052026年3月AI领域大事件：DeepSeek引领开源风暴06【技术干货】Gemma 4 上手深度指南：本地多模态大模型的新基线07AI 编程效率翻倍：Superpowers Skills 上手清单 + 完整指南08纯 HTML/CSS/JS 实现的高颜值登录页，还会眨眼睛！少女心爆棚！09Claude Code + GLM4.7 避坑指南：解决 Unable to connect to Anthropic services10“wsl --install -d Ubuntu-22.04”下载慢，中国地区离线安装 Ubuntu 22.04 WSL方法（亲测2025年5月6日）