Comment puis-je obtenir le NON logique élément par élément d'une série pandas?

J'ai un Seriesobjet pandas contenant des valeurs booléennes. Comment puis-je obtenir une série contenant la logique NOTde chaque valeur?

Par exemple, considérons une série contenant:

True
True
True
False

La série que j'aimerais obtenir contiendrait:

False
False
False
True

Cela semble être assez simple, mais apparemment, j'ai égaré mon mojo = (

Pour inverser une série booléenne, utilisez~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

En utilisant 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

Depuis Pandas 0.13.0, les séries ne sont plus des sous-classes de numpy.ndarray; ce sont maintenant des sous-classes de pd.NDFrame. Cela pourrait avoir quelque chose à voir avec pourquoi np.invert(s)n'est plus aussi rapide que ~sou -s.

Avertissement: les timeitrésultats peuvent varier en fonction de nombreux facteurs, notamment le matériel, le compilateur, le système d'exploitation, les versions Python, NumPy et Pandas.

La réponse de @ unutbu est parfaite, je voulais juste ajouter un avertissement que votre masque doit être dtype bool, pas 'object'. C'est-à-dire que votre masque ne doit jamais avoir de nan. Voyez ici - même si votre masque est maintenant sans nanos, il restera de type «objet».

L'inverse d'une série `` objet '' ne générera pas d'erreur, à la place, vous obtiendrez un masque d'ordures d'entiers qui ne fonctionnera pas comme prévu.

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

Après avoir parlé à mes collègues de celui-ci, j'ai une explication: il semble que les pandas reviennent à l'opérateur au niveau du bit:

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

Comme le dit @geher, vous pouvez le convertir en bool avec astype avant d'inverser avec ~

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

Je lui donne juste un coup de feu:

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

Vous pouvez également utiliser 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

EDIT: La différence de performances apparaît sur Ubuntu 12.04, Python 2.7, NumPy 1.7.0 - ne semble cependant pas exister avec 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

NumPy est plus lent car il convertit l'entrée en valeurs booléennes (donc None et 0 devient False et tout le reste devient True).

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

vous donne

0    False
1     True
2     True
3    False
dtype: object

alors que ~ s planterait. Dans la plupart des cas, le tilde serait un choix plus sûr que NumPy.

Pandas 0,25, NumPy 1,17