如何获得熊猫系列的元素逻辑非？

Posted 2023-03-12

【中文标题】如何获得熊猫系列的元素逻辑非？

【英文标题】：How can I obtain the element-wise logical NOT of a pandas Series?

【发布时间】：2013-04-06 13:32:47

【问题描述】：

我有一个包含布尔值的 pandas Series 对象。如何获得包含每个值的逻辑NOT 的系列？

例如，考虑一个包含以下内容的系列：

True
True
True
False

我想获得的系列将包含：

False
False
False
True

这看起来应该相当简单，但显然我放错了我的魔力 =(

【问题讨论】：

重要的是数据不包含object 类型以使以下答案起作用，因此请使用：~ df.astype('bool')

我在this post 中写过所有的逻辑运算符。该帖子还包括替代方案。

【参考方案1】：

要反转布尔系列，use ~s：

In [7]: s = pd.Series([True, True, False, True])

In [8]: ~s
Out[8]: 
0    False
1    False
2     True
3    False
dtype: bool

使用 Python2.7、NumPy 1.8.0、Pandas 0.13.1：

In [119]: s = pd.Series([True, True, False, True]*10000)

In [10]:  %timeit np.invert(s)
10000 loops, best of 3: 91.8 µs per loop

In [11]: %timeit ~s
10000 loops, best of 3: 73.5 µs per loop

In [12]: %timeit (-s)
10000 loops, best of 3: 73.5 µs per loop

从 Pandas 0.13.0 开始，Series 不再是 numpy.ndarray 的子类；它们现在是pd.NDFrame 的子类。这可能与为什么 np.invert(s) 不再像 ~s 或 -s 一样快有关。

警告：timeit 结果可能因许多因素而异，包括硬件、编译器、操作系统、Python、NumPy 和 Pandas 版本。

【讨论】：

正式注明。除了速度慢得多，波浪号和- 有什么区别？

奇怪，我实际上测试了文档中提到的tilde，但它的性能与np.invert不同：S

@blz：至少在我的Ubuntu机器上，运行NumPy 1.6.2，np.invert(s)、~s和-s的性能都是一样的。

@root：我不确定为什么我们的 timeit 结果存在如此大的差异，但它肯定会发生。您使用的是什么操作系统和 NumPy 版本？

同样在 Ubuntu 上，但使用 NumPy 1.7.0...（np.bitwise_not(s) 执行与 np.inverse 相同）。

【参考方案2】：

@unutbu 的回答很到位，只是想添加一个警告，即您的掩码需要是 dtype bool，而不是“object”。即你的面具不可能有曾经有任何nan。请参阅here - 即使您的掩码现在是无 nan 的，它仍将保持“对象”类型。

“对象”系列的倒数不会引发错误，相反，您会得到一个无法按预期工作的整数垃圾掩码。

In[1]: df = pd.DataFrame('A':[True, False, np.nan], 'B':[True, False, True])
In[2]: df.dropna(inplace=True)
In[3]: df['A']
Out[3]:
0    True
1   False
Name: A, dtype object
In[4]: ~df['A']
Out[4]:
0   -2
0   -1
Name: A, dtype object

在与同事讨论过这个问题后，我有一个解释：看起来 pandas 正在恢复为按位运算符：

In [1]: ~True
Out[1]: -2

正如@geher 所说，您可以使用 astype 将其转换为 bool，然后再使用 ~

~df['A'].astype(bool)
0    False
1     True
Name: A, dtype: bool
(~df['A']).astype(bool)
0    True
1    True
Name: A, dtype: bool

【讨论】：

在您的示例中，可以使用 .astype(bool) 将输出整数掩码转换为您想要的布尔系列，例如~df['A'].astype(bool)

这是有效的，因为 astype(bool) 发生在 ~ ~df['A'].astype(bool) 与 (~df['A']).astype(bool) 之前发生

【参考方案3】：

我只是试一试：

In [9]: s = Series([True, True, True, False])

In [10]: s
Out[10]: 
0     True
1     True
2     True
3    False

In [11]: -s
Out[11]: 
0    False
1    False
2    False
3     True

【讨论】：

我尝试了除- 之外的所有运算符！下次我会记住这一点。

【参考方案4】：

你也可以使用numpy.invert:

In [1]: import numpy as np

In [2]: import pandas as pd

In [3]: s = pd.Series([True, True, False, True])

In [4]: np.invert(s)
Out[4]: 
0    False
1    False
2     True
3    False

编辑：性能差异出现在 Ubuntu 12.04、Python 2.7、NumPy 1.7.0 上——但使用 NumPy 1.6.2 似乎不存在：

In [5]: %timeit (-s)
10000 loops, best of 3: 26.8 us per loop

In [6]: %timeit np.invert(s)
100000 loops, best of 3: 7.85 us per loop

In [7]: %timeit ~s
10000 loops, best of 3: 27.3 us per loop

【讨论】：

在不同的平台上可能不正确。 Win 7，python 3.6.3 numpy 1.13.3，pandas 0.20.3，(-s) 会最快，(~s) 次之，np.invert(s) 最慢

【参考方案5】：

NumPy 速度较慢，因为它将输入转换为布尔值（因此 None 和 0 变为 False，其他一切都变为 True）。

import pandas as pd
import numpy as np
s = pd.Series([True, None, False, True])
np.logical_not(s)

给你

0    False
1     True
2     True
3    False
dtype: object

而 ~s 会崩溃。在大多数情况下，波浪号是比 NumPy 更安全的选择。

熊猫 0.25，NumPy 1.17

【参考方案6】：

为了支持这里的优秀答案，并且为了将来的方便，可能存在您想要翻转列中的真值并使其他值保持不变（例如 nan 值）的情况

In[1]: series = pd.Series([True, np.nan, False, np.nan])
In[2]: series = series[series.notna()] #remove nan values
 
In[3]: series # without nan                                            
Out[3]: 
0     True
2    False
dtype: object

# Out[4] expected to be inverse of Out[3], pandas applies bitwise complement 
# operator instead as in `lambda x : (-1*x)-1`

In[4]: ~series
Out[4]: 
0    -2
2    -1
dtype: object

作为一个简单的非矢量化解决方案，您可以： 1. 检查类型 2。逆布尔值

In[1]: series = pd.Series([True, np.nan, False, np.nan])

In[2]: series = series.apply(lambda x : not x if x is bool else x)
Out[2]: 
Out[2]: 
0     True
1      NaN
2    False
3      NaN
dtype: object