wie kann ich logische Operatoren mit kommazahen denn ausführen?

[moh]

a=10.5;
b=5.5;
print(f" a hat den wert: {a} b hat den wert:{b}")
c=a/b
print(f"{a}/{b}={c}")
if(a>=b):
print(1)
else:
print(0)
if((a &b) | c ):
print(f"{a} and {b} or {c} = ",True)
else:
print(f"{a} and {b} or {c} = ",False)

if(not (a & b) | (not c)):
print(f"!{a} und {b} oder !{c} = ",True)
else:
print(f"!{a} und {b} oder !{c} = ",False)


TypeError: unsupported operand type(s) for &: 'float' and 'float'

[/me]

Wenn du die logischen Operatoren "and" und "or" haben willst, dann solltest du sie auch verwenden. Du benutzt aktuell die Operatoren die auf Bit-Ebene arbeiten (& |).

[__blackjack__]

@moh: ``if`` ist keine Funktion, also sollte man das auch nicht so schreiben als wäre das ein Funktionsaufruf. Die Klammern um die Bedingungen sind überflüssig und gehören da nicht hin.

[Sirius3]

Was soll den Deiner Meinung nach die logischen Operationen auf einer Zahl 10.5 sein?

[snafu]

@moh: Es ist nicht sinnvoll, Kommazahlen für Bit-Operationen zu nutzen. Daher funktioniert das auch nicht.

[moh]

sind and und or nicht gleich && und ||?
es wurde mir so erklärt.

[moh]

Wenn du die logischen Operatoren "and" und "or" haben willst, dann solltest du sie auch verwenden. Du benutzt aktuell die Operatoren die auf Bit-Ebene arbeiten (& |).

sind && und || nicht einer andern schreibweise für or und and?

[__blackjack__]

@moh: Es gibt in Python keine ``&&`` und ``||`` Operatoren. Die gibt es beispielsweise in C oder Java und ja, dort haben sie die gleiche Bedeutung wie ``and`` und ``or`` in Python. Du hast aber ``&`` und ``|`` verwendet. Die haben eine andere Bedeutung als ``and`` und ``or``. Und zwar die gleiche die sie auch in C und Java haben (zumindest wenn die Operanden ganze Zahlen sind), denn auch in C und Java gibt es ``&`` und ``|`` als Operatoren (für ganze Zahlen).

In Python kann man die Operatoren ``&`` und ``|`` auch für andere Typen implementieren, aber für Gleitkommazahlen sind sie nicht implementiert. Was Du ja schon an dem `TypeError` aus dem ersten Beitrag in diesem Thema ablesen konntest.

[moh]

@moh: Es gibt in Python keine ``&&`` und ``||`` Operatoren. Die gibt es beispielsweise in C oder Java und ja, dort haben sie die gleiche Bedeutung wie ``and`` und ``or`` in Python. Du hast aber ``&`` und ``|`` verwendet. Die haben eine andere Bedeutung als ``and`` und ``or``. Und zwar die gleiche die sie auch in C und Java haben (zumindest wenn die Operanden ganze Zahlen sind), denn auch in C und Java gibt es ``&`` und ``|`` als Operatoren (für ganze Zahlen).

In Python kann man die Operatoren ``&`` und ``|`` auch für andere Typen implementieren, aber für Gleitkommazahlen sind sie nicht implementiert. Was Du ja schon an dem `TypeError` aus dem ersten Beitrag in diesem Thema ablesen konntest.
[/q
danke dir

[__blackjack__]

@moh: Noch ein paar Anmerkungen zum Quelltext aus dem ersten Beitrag:

Um Zuweisungen ausserhalb von Argumentlisten und binäre Operatoren und nach Kommas erhöhen Leerzeichen die Lesbarkeit. Siehe auch den Style Guide for Python Code.

Semikolons werden verwendet um Anweisungen innerhalb der gleichen Zeile zu trennen, nicht um Anweisungen abzuschliessen. Die beiden Semikolons im Quelltext sind also Überflüssig. Die sind in Python-Quelltext *sehr* selten, weil üblicherweise immer nur eine Anweisung pro Zeile geschrieben wird.

All die ``if``/``else``-Konstrukte sind überflüssig. Das erste kann durch `int()` beseitigt werden weil der Typ für Wahrheitswerte `bool` von `int` erbt und die Werte `True` und `False` die Zahlwerte 1 und 0 haben und man ein `bool`-Objekt mit `int()` in eine Zahl umwandeln kann.

Bei den anderen beiden Fallunterscheidungen wird in den beiden Zweigen im Grunde genau das gleiche gemacht. Der einzige Unterschied ist der `bool`-Wert den die Bedingung des ``if``\s hat. Das heisst man kann da auch die Bedingung auswerten und in ein `bool()` umwandeln.

Code: Alles auswählen

    print(int(a >= b))
    
    print(f'{a} und {b} oder {c} = ', bool(a and b or c))
        
    print(f'!{a} und {b} oder !{c} = ', bool(not (a and b) or not c))

Wirklich Sinn macht das mit Gleitkommazahlen für `a`, `b`, und `c` natürlich nicht.