Logische Operatoren für Boolesche Indexierung Pandas

Arbeite ich mit boolean-index in der Pandas.
Die Frage ist, warum die Aussage:

a[(a['some_column']==some_number) & (a['some_other_column']==some_other_number)]

funktioniert in der Erwägung, dass

a[(a['some_column']==some_number) and (a['some_other_column']==some_other_number)]

beendet sich mit Fehler?

Beispiel:

a=pd.DataFrame({'x':[1,1],'y':[10,20]})

In: a[(a['x']==1)&(a['y']==10)]
Out:    x   y
     0  1  10

In: a[(a['x']==1) and (a['y']==10)]
Out: ValueError: The truth value of an array with more than one element is ambiguous.     Use a.any() or a.all()

Dies ist, weil numpy-arrays und pandas-Serie verwenden Sie den bitweisen Operatoren anstatt logisch wie Sie vergleichen jedes element im array/Serien mit einem anderen. Es ist daher nicht sinnvoll, so verwenden Sie den logischen operator in dieser situation. siehe Verwandte: stackoverflow.com/questions/8632033/...
In Python and != &. Die and - operator in Python nicht überschrieben werden kann, in der Erwägung, dass die & operator (__and__) kann. Daher die Wahl der Verwendung & in numpy und pandas.
Verwandte: Wahrheitswert einer Serie ist mehrdeutig. Verwenden Sie einen.leer, ein.bool(), ein.Element(), ein.jede() oder eine.alle()

InformationsquelleAutor user2988577 | 2014-01-28

157

Wenn Sie sagen,
```
(a['x']==1) and (a['y']==10)
```
Sind Sie implizit Fragen, Python zu konvertieren (a['x']==1) und (a['y']==10) boolean-Werte.

NumPy-arrays (mit einer Länge größer als 1) und Pandas Objekte wie Serie nicht über ein boolean-Wert -- in anderen Worten, Sie erhöhen
```
ValueError: The truth value of an array is ambiguous. Use a.empty, a.any() or a.all().
```
als booleschen Wert. Das ist, weil seine unklar, Wann es sein sollte True oder False. Einige Benutzer könnten annehmen, dass Sie Wahr sind, wenn Sie nicht die Länge null, wie ein Python-Liste. Andere wünschen es werden nur Wahr, wenn alle Ihre Elemente Wahr sind. Andere wollen es, um Wahr zu sein, wenn alle Ihre Elemente Wahr sind.

Weil es so viele widersprüchliche Erwartungen, die Designer von NumPy und Pandas verweigern, zu erraten, und anstatt aufwerfen einen ValueError.

Stattdessen müssen Sie explizit durch Aufruf der empty(), all() oder any() Methode zu zeigen, welches Verhalten Sie wünschen.

In diesem Fall, jedoch, es sieht aus wie Sie nicht möchten, dass Boolesche Auswertung, die Sie wollen element-wise logisch-und. Das ist das, was die & binary-operator führt:
```
(a['x']==1) & (a['y']==10)
```
gibt einen boolean-array.

Durch die Art und Weise, wie alexpmil Noten,
die Klammern sind zwingend erforderlich, da & hat eine höhere operator-Rangfolge als ==.
Ohne die Klammern a['x']==1 & a['y']==10 bewertet als a['x'] == (1 & a['y']) == 10 was sich wiederum entspricht dem verketteten Vergleich (a['x'] == (1 & a['y'])) and ((1 & a['y']) == 10). Das ist ein Ausdruck der form Series and Series.
Die Verwendung von and mit zwei Serien würde wieder auslösen das gleiche ValueError wie oben. Das ist, warum sind die Klammern zwingend.
- numpy arrays haben diese Eigenschaft falls Sie sind der Länge eins. Nur pandas devs (hartnäckig) zu verweigern, zu erraten :p
- Diskussion hier: groups.google.com/forum/#!Thema/pydata/XzSHSLlTSZ8
- Nicht '&' tragen die gleiche mehrdeutige Kurve wie 'und'? Wie kommt es, wenn es kommt zu '&', plötzlich alle Benutzer alle einig, es sollte element-Weise, während, wenn Sie sehen, 'und', Ihre Erwartungen variieren?
- href="https://docs.python.org/2/reference/expressions.html#boolean-operations" >Die Python-Sprache selbst erfordert, dass die expression x and y löst die Auswertung der bool(x) und bool(y). Python "first wertet x; wenn x false ist, wird dessen Wert zurückgegeben; anderenfalls y ausgewertet und der resultierende Wert wird zurückgegeben." Also die syntax x and y können nicht verwendet werden für-element-wised logisch-und da nur x oder y zurückgegeben werden können. Im Gegensatz dazu x & y löst x.__and__(y) und die __and__ Methode kann definiert werden, alles zurückzugeben, was wir mögen.
- Wichtiger Hinweis: die Klammern um die == Klausel sind obligatorisch. a['x']==1 & a['y']==10 wieder die gleichen Fehler wie in der Frage.
- Was ist ein " | " für?
- das bitweise or Betreiber. Python-Betreiber Google docs finden Sie hier.
InformationsquelleAutor unutbu
20

TLDR; _{Logische Operatoren in Pandas sind &, | und ~, und Klammern (...) ist wichtig!}

Python ' s and, or und not logische Operatoren arbeiten mit skalaren. Also Pandas zu tun hatten, ein besseres und überschreiben Sie die bitweisen Operatoren zu erreichen vektorisiert (element-wise) version dieser Funktion.

Also Folgendes in python (exp1 und exp2 sind Ausdrücke, die zu einem booleschen Wert ausgewertet-Ergebnis)...
```
exp1 and exp2              # Logical AND
exp1 or exp2               # Logical OR
not exp1                   # Logical NOT
```
...wird übersetzt zu...
```
exp1 & exp2                # Element-wise logical AND
exp1 | exp2                # Element-wise logical OR
~exp1                      # Element-wise logical NOT
```
für pandas.

Wenn in den Prozess der Durchführung von logischen operation erhalten Sie eine ValueError, dann müssen Sie die Verwendung von Klammern zum gruppieren von:
```
(exp1) op (exp2)
```
Beispielsweise
```
(df['col1'] == x) & (df['col2'] == y) 
```
Und so weiter.

Boolean Indizierung: Eine gemeinsame operation ist zur Berechnung boolescher Masken durch die logischen Bedingungen zum filtern der Daten. Pandas bietet drei Betreiber: & für das logische UND, | für das logische ODER und ~ für logische NICHT.

Betrachten Sie das folgende setup:
```
np.random.seed(0)
df = pd.DataFrame(np.random.choice(10, (5, 3)), columns=list('ABC'))
df

   A  B  C
0  5  0  3
1  3  7  9
2  3  5  2
3  4  7  6
4  8  8  1
```
Logische UND

Für df oben, sagen Sie, Sie möchten alle Zeilen, wo A < 5 B > 5. Dies geschieht mittels EDV-Masken für jede Bedingung separat, und-Verknüpfung Sie.

Überlastet Bitweise & Betreiber

Bevor Sie fortfahren, beachten Sie bitte die diesem bestimmten Auszug aus den docs, die Staatliche

Eine weitere übliche Aktion ist die Verwendung von booleschen Vektoren zu filtern
Daten. Die Operatoren sind: | für or, & für and, und ~ für not. Diese
müssen gruppiert werden, indem Sie Klammern verwenden, da Sie standardmäßig Python wird
auswerten eines Ausdrucks wie df.A > 2 & df.B < 3 als df.A > (2 & df.B) < 3, während die gewünschte Bewertung, Ordnung ist (df.A > 2) & (df.B < 3).

So, in diesem Sinne, element-Weise logisches UND können umgesetzt werden mit dem bitweisen operator &:
```
df['A'] < 5

0    False
1     True
2     True
3     True
4    False
Name: A, dtype: bool

df['B'] > 5

0    False
1     True
2    False
3     True
4     True
Name: B, dtype: bool
```
```
(df['A'] < 5) & (df['B'] > 5)

0    False
1     True
2    False
3     True
4    False
dtype: bool
```
Und die Filterung Schritt ist einfach,
```
df[(df['A'] < 5) & (df['B'] > 5)]

   A  B  C
1  3  7  9
3  4  7  6
```
Den Klammern werden verwendet, um die Standardeinstellung zu überschreiben Rangfolge der bitweisen Operatoren aus, die höhere Priorität über die bedingte Operatoren < und >. Siehe den Abschnitt Operator-Rangfolge in die python docs.

Wenn Sie keine Klammern verwenden, wird der Ausdruck falsch ausgewertet wird. Zum Beispiel, wenn Sie versehentlich versuchen, so etwas wie
```
df['A'] < 5 & df['B'] > 5
```
Es wird analysiert, wie
```
df['A'] < (5 & df['B']) > 5
```
Wird,
```
df['A'] < something_you_dont_want > 5
```
Wird (siehe die python docs auf verkettet operator Vergleich),
```
(df['A'] < something_you_dont_want) and (something_you_dont_want > 5)
```
Wird,
```
# Both operands are Series...
something_else_you_dont_want1 and something_else_you_dont_want2
```
Die wirft
```
ValueError: The truth value of a Series is ambiguous. Use a.empty, a.bool(), a.item(), a.any() or a.all().
```
Also, machen Sie nicht diesen Fehler!¹

Vermeidung Von Klammern Gruppieren

Die Lösung ist eigentlich ganz einfach. Die meisten Anbieter haben eine entsprechende gebundene Methode für DataFrames. Wenn die einzelnen Masken aufgebaut werden mit Funktionen anstelle von bedingten Operatoren, die Sie nicht mehr benötigen, um die Gruppe von Klammern, um anzugeben, Bewertung Reihenfolge:
```
df['A'].lt(5)

0     True
1     True
2     True
3     True
4    False
Name: A, dtype: bool

df['B'].gt(5)

0    False
1     True
2    False
3     True
4     True
Name: B, dtype: bool
```
```
df['A'].lt(5) & df['B'].gt(5)

0    False
1     True
2    False
3     True
4    False
dtype: bool
```
Siehe den Abschnitt über Flexible Vergleiche.. Um zusammenzufassen, wir haben
```
╒════╤════════════╤════════════╕
│    │ Operator   │ Function   │
╞════╪════════════╪════════════╡
│  0 │ >          │ gt         │
├────┼────────────┼────────────┤
│  1 │ >=         │ ge         │
├────┼────────────┼────────────┤
│  2 │ <          │ lt         │
├────┼────────────┼────────────┤
│  3 │ <=         │ le         │
├────┼────────────┼────────────┤
│  4 │ ==         │ eq         │
├────┼────────────┼────────────┤
│  5 │ !=         │ ne         │
╘════╧════════════╧════════════╛
```
Weitere option zur Vermeidung von Klammern ist die Verwendung DataFrame.query (oder eval):
```
df.query('A < 5 and B > 5')

   A  B  C
1  3  7  9
3  4  7  6
```
Habe ich ausgiebig dokumentiert query und eval im Dynamische Auswertung eines Ausdrucks in pandas mit pd.eval().

- operator.and_

Können Sie führen diesen Vorgang in einer funktionellen Art und Weise. Intern ruft Series.__and__ das entspricht dem bitweisen operator.
```
import operator 

operator.and_(df['A'] < 5, df['B'] > 5)
# Same as,
# (df['A'] < 5).__and__(df['B'] > 5) 

0    False
1     True
2    False
3     True
4    False
dtype: bool

df[operator.and_(df['A'] < 5, df['B'] > 5)]

   A  B  C
1  3  7  9
3  4  7  6
```
Sie in der Regel nicht brauchen, aber es ist nützlich zu wissen.

Verallgemeinern: np.logical_and (und logical_and.reduce)

Eine weitere alternative ist die Verwendung np.logical_and, der braucht auch keine Klammern gruppieren:
```
np.logical_and(df['A'] < 5, df['B'] > 5)

0    False
1     True
2    False
3     True
4    False
Name: A, dtype: bool

df[np.logical_and(df['A'] < 5, df['B'] > 5)]

   A  B  C
1  3  7  9
3  4  7  6
```
np.logical_and ist ein ufunc (Universal Funktion), und die meisten ufuncs haben eine reduzieren Methode. Dies bedeutet, dass es einfacher ist, zu verallgemeinern, mit logical_and wenn Sie mehrere Masken UND. Zum Beispiel, UND Masken m1 und m2 und m3 mit & Sie zu tun haben
```
m1 & m2 & m3
```
Jedoch eine einfachere Möglichkeit ist
```
np.logical_and.reduce([m1, m2, m3])
```
Dieser ist mächtig, weil es Ihnen ermöglicht, bauen auf diesem mit komplexer Logik (zum Beispiel der dynamischen Generierung von Masken in der Liste das Verständnis und das hinzufügen alle von Ihnen):
```
import operator

cols = ['A', 'B']
ops = [np.less, np.greater]
values = [5, 5]

m = np.logical_and.reduce([op(df[c], v) for op, c, v in zip(ops, cols, values)])
m 
# array([False,  True, False,  True, False])

df[m]
   A  B  C
1  3  7  9
3  4  7  6
```
_{1 - ich weiß, ich bin herumreiten auf diesem Punkt, aber bitte Geduld mit mir. Dies ist ein sehr, sehr häufige Anfängerfehler, und muss erklärt werden, sehr gründlich.}

Logische ODER

Für die df oben, sagen Sie, dass Sie möchten, um alle Zeilen, in denen A == 3 oder B == 7.

Überlastet Bitweise |
```
df['A'] == 3

0    False
1     True
2     True
3    False
4    False
Name: A, dtype: bool

df['B'] == 7

0    False
1     True
2    False
3     True
4    False
Name: B, dtype: bool
```
```
(df['A'] == 3) | (df['B'] == 7)

0    False
1     True
2     True
3     True
4    False
dtype: bool

df[(df['A'] == 3) | (df['B'] == 7)]

   A  B  C
1  3  7  9
2  3  5  2
3  4  7  6
```
Falls Sie es noch nicht, Lesen Sie bitte auch den Abschnitt über Logische UND oben, alle Vorbehalte gelten hier.

Alternativ kann dieser Vorgang angegeben werden, mit
```
df[df['A'].eq(3) | df['B'].eq(7)]

   A  B  C
1  3  7  9
2  3  5  2
3  4  7  6
```
- operator.or_

Anrufe Series.__or__ unter der Haube.
```
operator.or_(df['A'] == 3, df['B'] == 7)
# Same as,
# (df['A'] == 3).__or__(df['B'] == 7)

0    False
1     True
2     True
3     True
4    False
dtype: bool

df[operator.or_(df['A'] == 3, df['B'] == 7)]

   A  B  C
1  3  7  9
2  3  5  2
3  4  7  6
```
np.logical_or

Für die zwei Bedingungen, verwenden Sie logical_or:
```
np.logical_or(df['A'] == 3, df['B'] == 7)

0    False
1     True
2     True
3     True
4    False
Name: A, dtype: bool

df[np.logical_or(df['A'] == 3, df['B'] == 7)]

   A  B  C
1  3  7  9
2  3  5  2
3  4  7  6
```
Für mehrere Masken verwenden logical_or.reduce:
```
np.logical_or.reduce([df['A'] == 3, df['B'] == 7])
# array([False,  True,  True,  True, False])

df[np.logical_or.reduce([df['A'] == 3, df['B'] == 7])]

   A  B  C
1  3  7  9
2  3  5  2
3  4  7  6
```
Logisch NICHT

Gegeben, eine Maske, wie
```
mask = pd.Series([True, True, False])
```
Wenn Sie müssen umkehren, jeder booleschen Wert (so dass das end-Ergebnis ist [False, False, True]), dann Sie können verwenden Sie eine der folgenden Methoden.

Bitweise ~
```
~mask

0    False
1    False
2     True
dtype: bool
```
Wieder Ausdrücke sein müssen, parenthesised.
```
~(df['A'] == 3)

0     True
1    False
2    False
3     True
4     True
Name: A, dtype: bool
```
Dieser ruft intern
```
mask.__invert__()

0    False
1    False
2     True
dtype: bool
```
Aber verwenden Sie es nicht direkt.

operator.inv

Intern ruft __invert__ auf die Reihe.
```
operator.inv(mask)

0    False
1    False
2     True
dtype: bool
```
np.logical_not

Dies ist die numpy-Variante.
```
np.logical_not(mask)

0    False
1    False
2     True
dtype: bool
```
Hinweis, np.logical_and ausgetauscht werden können, für np.bitwise_and, logical_or mit bitwise_or, und logical_not mit invert.
- cs95 in die TLDR, für element-wise boolean ODER Sie befürworten die Verwendung | entspricht numpy.bitwise_or statt numpy.logical_or. Darf ich Fragen, warum? Nicht numpy.logical_or speziell für diese Aufgabe speziell? Warum sollten Sie die Last, es zu tun, bitweise für jedes paar von Elementen?
- können Sie zitieren den entsprechenden text bitte? Ich kann nicht finden, was Sie sich beziehen. FWIW ich behaupte, dass logical_* ist die korrekte funktionale äquivalent für die Betreiber.
- cs95, ich beziehe mich auf die erste Zeile der Antwort: "TLDR; Logische Operatoren in Pandas sind &, | und ~".
- Es ist buchstäblich in den Dokumentation: "eine Weitere übliche Aktion ist die Verwendung von booleschen Vektoren, die Daten zu filtern. Die Operatoren sind: | oder, & für das und-und ~ nicht."
- cs95, ok, ich habe gerade diesen Abschnitt gelesen, und es wird | für element-wise booleschen operation. Aber für mich, dass die Dokumentation ist mehr ein "tutorial", und im Gegensatz, ich fühle mich mit diesen API-Referenzen sind näher an der Quelle der Wahrheit: numpy.bitwise_or und numpy.logical_or - so bin ich versucht zu verstehen, was hier beschrieben wird.
- Was mir unklar ist: In den ersten numpy-doc, es wird erwähnt numpy.bitwise_or entspricht |. Aber Sie sagen nicht numpy.bitwise_or ist funktionell äquivalent zu numpy.logical_or. Wie können wir also sicher sein, dass Sie sind? Die erstere ist eine bitweise operation nicht also es hängt von NumPy ist die binäre Darstellung der booleschen Werte?
- der wesentliche Unterschied zwischen logischen und bitweisen Operationen ist die Kurzschluss-Eigenschaft (bitweise Operatoren nicht Kurzschluss). Also in dieser Hinsicht, Sie sind nicht gleichwertig. Aber Sie produzieren die gleiche Ausgabe für boolean-Masken.
- cs95 aber einen boolean-Wert (ein element in der boolean-Maske) ist nicht codiert/dargestellt als 1-bit-oder ist es? Wenn es nicht 1 bit, dann einer bitweisen operation kann es zu unterschiedlichen Ausgang als eine logische operation.
- Ein bool ist, wird durch eine 8 bit-Zahl, verwendet jedoch nur 1 bit. Dies wird gut verstanden.
- cs95-Und das bitweise Boolesche Operationen funktionieren nur auf das 1-bit-8? Würden Sie einen Verweis auf diese Tatsache?
- Beispielsweise tut einer bitweisen nicht-operation normalerweise invertiert alle bits, einschließlich den anderen 7.
- es wird nicht, wenn das array dtype bool. Ansonsten, du hast Recht. Probieren Sie es aus: np.bitwise_not([False]) versus np.bitwise_not(np.array([False], dtype=object))
- cs95 das ist interessant. Ich habe auch getestet mit bitwise_xor, und es scheint, daß diese bitweisen Operatoren nicht blind auf allen bits - er überprüft auch die Art, wie Sie erwähnt; wenn es np._bool es ist "smart" genug, um zu wissen, zu bedienen nur die sinnvolle bisschen. So, zurück zu meinem ursprünglichen Punkt: ich sehe jetzt, für Boolean-element-Weise Operationen | und numpy.bitwise_or sind äquivalent zu numpy.logical_or, und | ist wahrscheinlich bevorzugt durch lapidare.
InformationsquelleAutor cs95
2

Logische Operatoren für Boolesche Indexierung Pandas

Ist es wichtig zu erkennen, dass Sie nicht verwenden die Python logische Operatoren (and, or oder not) auf pandas.Series oder pandas.DataFrames (ähnlich wie man nicht auf numpy.arrays mit mehr als einem element). Der Grund, warum Sie nicht verwenden können, diejenigen, die, weil Sie implizit nennen bool auf Ihre Operanden, die eine Ausnahme wirft, denn diese Datenstrukturen entschieden, dass das boolean-array aber ist zweideutig:
```
>>> import numpy as np
>>> import pandas as pd
>>> arr = np.array([1,2,3])
>>> s = pd.Series([1,2,3])
>>> df = pd.DataFrame([1,2,3])
>>> bool(arr)
ValueError: The truth value of an array with more than one element is ambiguous. Use a.any() or a.all()
>>> bool(s)
ValueError: The truth value of a Series is ambiguous. Use a.empty, a.bool(), a.item(), a.any() or a.all().
>>> bool(df)
ValueError: The truth value of a DataFrame is ambiguous. Use a.empty, a.bool(), a.item(), a.any() or a.all().
```
Habe ich diese noch Ausführlicher in meiner Antwort auf die "Wahrheit Wert einer Folge ist eindeutig. Verwenden Sie einen.leer, ein.bool(), ein.Element(), ein.jede() oder eine.alle()" Q+A.

NumPys logische Funktionen

Jedoch NumPy bietet element-wise Betriebs-äquivalente für diese Operatoren als Funktionen, die verwendet werden können, die auf numpy.array, pandas.Series, pandas.DataFrame oder andere (konforme) numpy.array Unterklasse:
- and hat np.logical_and
- or hat np.logical_or
- not hat np.logical_not
- numpy.logical_xor , die keine Python-äquivalent, sondern ist eine logische "exklusives oder" Betrieb
So, im wesentlichen, sollte man Sie nutzen (vorausgesetzt df1 und df2 sind pandas DataFrames):
```
np.logical_and(df1, df2)
np.logical_or(df1, df2)
np.logical_not(df1)
np.logical_xor(df1, df2)
```
Bitweise Funktionen und bitweise Operatoren für boolsche Variablen

Jedoch in Fall müssen Sie Boolesche NumPy-array, pandas Serie, oder pandas DataFrames können Sie auch das element-Weise bitweise Funktionen (für booleans Sie sind - oder zumindest sein sollte - nicht von den logischen Funktionen):
- bitweise und: np.bitwise_and oder die & Betreiber
- bitweise oder: np.bitwise_or oder die | Betreiber
- Bitweises nicht: np.invertieren (oder den alias np.bitwise_not) oder die ~ Betreiber
- Bitweises xor: np.bitwise_xor oder die ^ Betreiber
In der Regel der Betreiber verwendet werden. Allerdings, wenn in Kombination mit Vergleichsoperatoren daran zu erinnern, um wickeln Sie den Vergleich in Klammern, weil die bitweisen Operatoren haben eine höhere Priorität als die Vergleichsoperatoren:
```
(df1 < 10) | (df2 > 10)  # instead of the wrong df1 < 10 | df2 > 10
```
Diese kann irritierend sein, weil das Python-logische Operatoren haben eine niedrigere precendence als die Vergleichsoperatoren, so dass Sie normalerweise schreiben a < 10 and b > 10 (wo a und b sind zum Beispiel einfache Ganzzahlen) und brauchen nicht die Klammer.

Unterschiede zwischen logischen und bitweisen Operationen (auf nicht-Boolesche Werte)

Es ist wirklich wichtig zu betonen, dass die bit-und logischen Operationen sind nur äquivalent für "boolean" NumPy-arrays (und boolean-Serie & DataFrames). Wenn diese nicht enthalten Boolesche Werte dann bei den Operationen zu unterschiedlichen Ergebnissen führen. Ich werde auch Beispiele, die über NumPy arrays, aber die Ergebnisse werden ähnlich wie bei den pandas Datenstrukturen:
```
>>> import numpy as np
>>> a1 = np.array([0, 0, 1, 1])
>>> a2 = np.array([0, 1, 0, 1])

>>> np.logical_and(a1, a2)
array([False, False, False,  True])
>>> np.bitwise_and(a1, a2)
array([0, 0, 0, 1], dtype=int32)
```
Und da NumPy (und ähnlich pandas) macht verschiedene Dinge für boolean (Boolean oder "Maske" index-arrays) und integer (Index-arrays) Indizes, die die Ergebnisse der Indexierung wird auch anders sein:
```
>>> a3 = np.array([1, 2, 3, 4])

>>> a3[np.logical_and(a1, a2)]
array([4])
>>> a3[np.bitwise_and(a1, a2)]
array([1, 1, 1, 2])
```
Zusammenfassung Tabelle
```
Logical operator | NumPy logical function | NumPy bitwise function | Bitwise operator
-------------------------------------------------------------------------------------
       and       |  np.logical_and        | np.bitwise_and         |        &
-------------------------------------------------------------------------------------
       or        |  np.logical_or         | np.bitwise_or          |        |
-------------------------------------------------------------------------------------
                 |  np.logical_xor        | np.bitwise_xor         |        ^
-------------------------------------------------------------------------------------
       not       |  np.logical_not        | np.invert              |        ~
```
Wo den logischen operator funktioniert nicht bei NumPy-arrays, pandas Serie und pandas DataFrames. Die anderen arbeiten, die auf diesen Datenstrukturen (und plain Python-Objekte) und element-Weise.
Seien Sie jedoch vorsichtig mit der bitweisen invertieren auf plain Python bools, weil die bool interpretiert werden als Ganzzahlen in diesem Zusammenhang (zum Beispiel ~False zurück -1 und ~True zurück -2).

InformationsquelleAutor MSeifert

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.

TLDR; Logische Operatoren in Pandas sind &, | und ~, und Klammern (...) ist wichtig!

Logische UND

Logische ODER

Logisch NICHT

NumPys logische Funktionen

Bitweise Funktionen und bitweise Operatoren für boolsche Variablen

Unterschiede zwischen logischen und bitweisen Operationen (auf nicht-Boolesche Werte)

Zusammenfassung Tabelle

TLDR; _{Logische Operatoren in Pandas sind &, | und ~, und Klammern (...) ist wichtig!}