True/False

python's boolean-Type bool

bool ist ein Typ der genau zwei Zustände annehmen kann:
True (wahr) oder False (falsch, unwahr).
Man beachte, dass beide mit Gro&zlig;buchstaben beginnen (True, False)

>>>  wahr = True
>>>  falsch = False
>>>  print( type( falsch ) )
<class 'bool'>
>>>

in früheren python-Versionen (vor python-2.3) gabe es kein True/False, stattdessen war war statt True eine 1 und an Stelle von False war 0 und der Wahrheitsgehalt der Objekte wurde anhand der Zahlen 0 1 dargestellt; aber so, mit den Namen True/False an Stelle der Zahlen, tut man sich viel leichter. Man könnte mit dem bool-Wert auch rechnen!

>>>  zahl = 5
>>>  zahl += True
>>>  print (zahl)
6
>>>  zahl += False
>>>  print (zahl)
6
>>> 

übrigens; es gibt KEIN i++ --i, also keine increment/decrement-Operationen in python, für all jene, die es schon vermisst haben.
sondern, um einen Wert um 1 zu erhöhen (inkrementieren)
zahl += 1
Freilich könnte man auch zahl = zahl + 1 schreiben (das Argument, das dafür spricht, ist bessere Lesbarkeit), aber dann müsste der Interpreter zwei Mal die Referenz auflösen (von Name zahl hin zu Objekt, auf das dieser Name im Arbeitsspeicher zeigt), was um einen Tick länger dauert.
zum Rechnen wurde True/False nicht erfunden. Vergessen sollten wir darüber hinaus aber nicht, dass es die Boolesche Algebra gibt, die auf den englischen Mathematiker George Boole zurückgeht.
Jetzt wollen wir Aussagen auf deren Wahrheitsgehalt testen:

>>> zeichen = 'abcdefgh'
>>> 'a' in zeichen
True
>>> a = 5
>>> 5 == a
True
>>> a > 2
True
>>> 2 < a <= 10#nettes Konstrukt, nicht wahr? ;-)
True
>>> b = 8.2
>>> b < a
False
>>> a < b
True
>>> 2 < b <=10 and isinstance(b, int)
False
>>> 2 < b <=10 or isinstance(b, int)
True
>>>

ah - haben wir auch gleich die and und or Verknüpfung mitabgehandelt.
eine UND-Verknüpfung ist wahr, wenn beide bzw. alle Teile der Verknüpfung wahr sind.

>>> a = 1
>>> b = 2
>>> c = 0
>>> d = False
>>> e = None
>>> f = ''
>>> print (a and b)
2
>>> print (b and d and a)
False
>>> print (b and a and f)

>>>

Die UND-Verknüpfung lässt sich nun so erkl¨ren, dass:
wahr and wahr -> wahr
falsch and wahr -> falsch
wahr and falsch -> falsch
falsch and falsch -> falsch

Objekte sind False, wenn sie False sind, 0 (Null) sind, ein leerer string sind oder ein ein None-Objekt darstellen.
Daher ist es klar, dass bei
print (0 and 2)
0 ausgegeben wird, da er nicht zur 2 kommt (False and True ergibt False).

Bei der OR-Verknüfung verhält es sich anders. Hier muss mindestens ! Objekt in der kete wahr sein, damit der Ausdruck wahr ist.

wahr or wahr -> wahr
wahr or falsch -> wahr
falsch or wahr -> wahr
falsch or falsch -> falsch

>>> a or b
1
>>> False or b
2
>>> f or a
1
>>> d or e #ergibt None
>>> d or e or a
1
>>>

Die ODER-Verknüpfung kann man sich in einem print-statement zunutze machen -
wenn ein Wert einen Anfangswert von '' (leerer String) hat, und sich nix beim Programmdurchlauf daran ändert, könnte man das so schreiben:

>>> wort = ''
>>> print ("Das Wort ist {}".format(wort))
Das Wort ist 
>>>

Das ist nicht sehr schön, anzusehen. Mittels einer OR-Verknüpfung könnenwir eine Art Default-Wert angeben, für den Fall, dass der name auf False zeigt.

>>>  wort = ''
>>> print ("Das Wort ist {}".format(wort or 'ein leerer string'))
Das Wort ist ein leerer string
>>>

in python2 gab es übrigens noch 2 <> a - das wurde abgeschafft in python3 (KRACHT) - also nur noch
2 != a

Was liefert nocheinmal False? Erinnern wir uns und geben eine noch genauere Antwort:
Alle Zahlenwerte, die 0 ergeben (0, 0.0, 0+0j )
leerer string, leere Objektgruppen wie (), [], {}, etc.
False itself
und der Datentyp None

um das überprüfen zu können, gibt es die built-in-function bool()
Damit kann man den Wahrheitsgehalt eines jeden Objekts abfragen.

>>> l = [1,2,3]
>>> L = bool(l)
>>> print (L)
True
>>> ll = []
>>> LL = bool(ll)
>>> print (LL)
False
>>> bool()
False
>>> bool(None)
False
>>> for i in [],(),{},False,0,'',None,22:
...     print (bool(i))
... 
False
False
False
False
False
False
False
True
>>>

Noch ein letztes, weil mir das auch gefällt, einfach so hier reingepastet.

>>> a=5
>>> b=7
>>> a<b,b>10,a*b
(True, False, 35)
>>>

a<b
b>10,a*b
wird also gleich wieder zum tuple-Objekt und als solches ausgegeben. Ist doch geschmeidig!?