我只是试了一下:

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

你也可以使用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

要反转一个布尔序列，使用~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版本。

@unutbu的答案是正确的，只是想添加一个警告，你的蒙版需要是dtype bool，而不是'object'。你的面具不可能有奶奶的。看这里-即使你的蒙版现在是无nan的，它仍然是“对象”类型。

“object”系列的逆函数不会抛出错误，相反，你会得到一个int类型的垃圾掩码，它不会像你期望的那样工作。

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

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

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

熊猫0.25，公司1.17

为了支持这里的优秀答案，并且为了将来的方便，可能会有这样的情况，您希望翻转列中的真值，而让其他值保持不变(例如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。检查types2。逆bool

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