Bitweise Operatoren / Pandas

[Bl3nder]

Hey Leute,
Ich habe eine kurze Frage...
Ich hatte vorhin folgendes Problem ich wollte mit Pandas einen Vergleich machen mit and was immer wieder zu Fehlern geführt hat ( siehe Bildern ) nach dem Ich in einem anderen Forum gelesen habe das Pandas "es nicht mag mit and oder == zu arbeiten da es nicht eindeutig ist" ??? Stattdessen sollte man mit | oder & Ich habe das am Anfang mal irgendwo gelesen in meinem Buch das es dort ein unterschied gibt ( | und & sind Bitweise ) nur meine Frage ist wann benutzt ihr die Bitweise Operatoren Ich war es bis jetzt immer gewöhnt Variablen zu vergleichen und hatte nie operatoren wo liegt der Vorteil darin das Bitweise zu machen ?Ich danke euch schon mal

Als Beispiel:

Code: Alles auswählen

import openpyxl
import os.path
import time
import datetime
import pandas as pd
from decimal import *
from pathlib import Path
import datetime
pd.set_option('display.max_rows', None)
pd.set_option('display.max_columns', None)
pd.set_option('display.width', None)
pd.set_option('display.max_colwidth', -1)






Pfad_Testdatei = "C:/Users/Marcel/Desktop/Klimareport Test Ordner/Klimastatistik_Test.xlsx"




def Suchen_in_Dataframe(Jahr,Monat):

    Daten_aus_Statistik = pd.read_excel(Pfad_Testdatei,sheet_name="statistik",skiprows=1)
    print(Daten_aus_Statistik)



    Test =Daten_aus_Statistik["Jahr"].isin([Jahr]) & Daten_aus_Statistik["Monat"].isin([Monat])

    print(Test)



if __name__ == "__main__":
    Suchen_in_Dataframe(2012,6)

Bilder:
[URL=https://www.directupload.net/file/ ... .png[/IMG][/url]

[URL=https://www.directupload.net/file/ ... .png[/IMG][/url]

Ich danke euch

[Sirius3]

`and` und `or` sind in Python spezielle Operatoren, deren Ergebnis nicht unbedingt ein Wahrheitswert ist.
Diese Operatoren kann man nicht überladen, um sie speziell für Vektoroperationen zugänglich zu machen. Daher hat pandas zwangsläufig einen anderen Operator für logische Verknüpfungen gebraucht, und da ist es naheliegend den bit-Operatoren & und | zu benutzen.

[__blackjack__]

Ergänzend dazu: Wobei das nicht zwingend Bitoperatoren sind, sondern erst einmal nur Operatoren. Die werden dann bei *ganzen Zahlen* für bitweise Und- und Oder-Verknüpfungen verwendet. Der *Datentyp* entscheidet darüber was ein Operator bedeutet, nicht der Operator selbst. ``+`` bedeutet bei Zahlen ja auch etwas anderes als bei Sequenztypen wie Zeichenketten, Tupel, oder Listen.

[Bl3nder]

Ich hoffe Ihr lacht mich nicht aus aber leider verstehe Ich es nicht ganz ...

Ich versuch es euch mal aus meiner Sicht zu erklären in meine Funktion gebe Ich 2 Integerwerte rein ( 2012,6) .In meinem Dataframe befinden sich mehre Spalten mit Informationen die zwei die Ich hier vergleiche ( wenn Ich mir die in Pycharm angucke sehen quasi so aus) :

Jahr| Monat.....
2012|6
2012|7
2012|8
.
.
.
Diese Werte sind ebenfalls Integer .

So da Ich in diesen Fall isin als Methode benutze würde Ich theoretisch ein Dataframe mit Boolean zurück erhalten ,das verstehe Ich auch ebenfalls.

Nur Ich verstehe nicht wie == in dem Fall keinen Eindeutigen Wahrheitswert haben kann ? Geschweige verstehe Ich nicht es wird im Netz davon geschrieben das etwas überschrieben wird ?

Tut mir leid das ich so schwer von Begriff bin ...

[Bl3nder]

Nachtrag:

Ich glaube Ich habe es verstanden wenn ICh schreibe Werte 1 == Wert 2 werden diese beiden Werte indirekt zu Boolean gewandelt damit auf True bzw False geprüft werden kann ?

Jedoch weiß Pandas in dem Fall nicht wann das Ergebnis True sein soll zum Beispiel wenn alle Elemente in der Spalte True sind oder nur eins ... um das zu umgehen benutzt man den Bitweise Vergleiche da hier quasi jedes Element einzlend geprüft wird ist es so richtig ?

[__blackjack__]

@Bl3nder: Was ``==`` macht hängt genau wie bei ``&`` und ``|`` vom Datentyp ab. Bei Numpy-Arrays liefert das bei Arrays mit gleichen Dimensionen ein Array wo das Ergebnis von ``==`` auf jedes Element angewendet wird. Das ist kein Problem und das ist auch eindeutig:

Code: Alles auswählen

In [368]: A = np.array([True, False, True])                                     

In [369]: B = np.array([True, False, True])                                     

In [370]: C = np.array([False, True, True])                                     

In [371]: A == B                                                                
Out[371]: array([ True,  True,  True])

In [372]: A == C                                                                
Out[372]: array([False, False,  True])

Das Problem taucht dann auf wenn man mit solchen Arrays ``and`` oder ``or`` verwenden will, denn hier bestimmt tatsächlich der Operator was passiert, weil man die nicht überladen kann. Die machen für alle Werte das gleiche und zwar Entscheidungen aufgrund des ”Wahrheitswertes” der Operanden treffen. Mindestens auf Grund des ersten Operanden. Und hier wird es dann uneindeutig, denn was ist denn der Wahrheitswert von einem Array mit Wahrheitswerten? Ist das immer wahr weil's ein Objekt ist? Nur wahr wenn es eine Länge >0 hat wie bei Listen? Wahr wenn mindestens ein `True` enthalten ist? Wahr wenn alle Werte `True` sind?

Code: Alles auswählen

In [373]: bool(A)                                                               
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-373-7a8b076fa92a> in <module>
----> 1 bool(A)

ValueError: The truth value of an array with more than one element is ambiguous. Use a.any() or a.all()

Was hättest Du denn hier sonst als Ergebnis erwartet und mit welcher Begründung?

Und selbst wenn der Arraydatentyp irgendeine dieser Definitionen verwenden würde, passt die Semantik von ``and`` und ``or`` ja nicht zu dem was man haben möchte: die liefern einen der beiden Operanden als Ergebnis und nicht die elementweise Verknüpfung, die Du ja dann als Maske/Index verwenden willst.