Wie man prüft, ob ein Wert in Python True ist

Einführung

In diesem Lab lernen Sie, wie Sie in Python prüfen können, ob ein Wert True ist. Wir beginnen damit, die grundlegenden booleschen Werte True und False zu untersuchen und ihre Rolle bei Entscheidungen und im Programmfluss zu verstehen.

Anschließend lernen Sie, wie Sie mit dem Gleichheitsoperator == einen direkten Vergleich mit True durchführen, um zu prüfen, ob eine Bedingung erfüllt ist. Abschließend werden Sie die sogenannten "truthy" Werte in Python verstehen.

Lernen Sie über True und False

In diesem Schritt werden wir die grundlegenden booleschen Werte in Python untersuchen: True und False. Diese Werte sind für Entscheidungen und die Steuerung des Programmflusses unerlässlich.

In Python sind True und False Schlüsselwörter, die boolesche Werte repräsentieren. Sie werden verwendet, um die Wahrheit oder Falschheit einer Bedingung auszudrücken. Lassen Sie uns beginnen, diese Werte direkt in einem Python-Skript zu untersuchen.

Öffnen Sie Ihren VS Code-Editor.
Erstellen Sie eine neue Datei mit dem Namen boolean_values.py in Ihrem ~/project-Verzeichnis.
```
cd ~/project
```

Fügen Sie den folgenden Inhalt zur Datei boolean_values.py hinzu:

## Assign True and False to variables
is_true = True
is_false = False

## Print the values and their types
print("Value of is_true:", is_true)
print("Type of is_true:", type(is_true))

print("Value of is_false:", is_false)
print("Type of is_false:", type(is_false))

Dieses Skript weist die booleschen Werte True und False den Variablen is_true und is_false zu. Anschließend werden die Werte und ihre entsprechenden Typen mit der print()-Funktion ausgegeben.

Führen Sie das Skript mit dem Python-Befehl aus:
```
python boolean_values.py
```
Sie sollten die folgende Ausgabe sehen:
```
Value of is_true: True
Type of is_true: <class 'bool'>
Value of is_false: False
Type of is_false: <class 'bool'>
```
Diese Ausgabe bestätigt, dass True und False in Python boolesche Werte sind und dass ihr Typ <class 'bool'> ist.

Direkten Vergleich mit True verwenden

In diesem Schritt lernen wir, wie man direkte Vergleiche mit dem booleschen Wert True durchführt. Der direkte Vergleich ist ein grundlegendes Konzept in der Programmierung, das es Ihnen ermöglicht, zu prüfen, ob eine Bedingung wahr oder falsch ist.

In Python können Sie den Gleichheitsoperator == verwenden, um eine Variable oder einen Ausdruck direkt mit True zu vergleichen. Dies ist eine gängige Methode, um zu prüfen, ob eine Bedingung erfüllt ist. Erstellen wir ein Skript, um dies zu demonstrieren.

Öffnen Sie Ihren VS Code-Editor.
Erstellen Sie eine neue Datei mit dem Namen compare_with_true.py in Ihrem ~/project-Verzeichnis.
```
cd ~/project
```
Fügen Sie den folgenden Inhalt zur Datei compare_with_true.py hinzu:
```
## Assign a boolean value to a variable
is_valid = True

## Compare the variable directly with True
if is_valid == True:
    print("The condition is True.")
else:
    print("The condition is False.")

## Another example with a different variable
is_active = False

if is_active == True:
    print("The condition is True.")
else:
    print("The condition is False.")
```
In diesem Skript weisen wir zunächst den booleschen Wert True der Variable is_valid zu. Dann verwenden wir eine if-Anweisung, um zu prüfen, ob is_valid gleich True ist. Wenn dies der Fall ist, gibt das Skript "The condition is True." aus. Andernfalls gibt es "The condition is False." aus. Anschließend wiederholen wir diesen Vorgang mit einer Variable is_active, die auf False gesetzt ist.
Führen Sie das Skript mit dem Python-Befehl aus:
```
python compare_with_true.py
```
Sie sollten die folgende Ausgabe sehen:
```
The condition is True.
The condition is False.
```
Diese Ausgabe zeigt, dass das Skript korrekt erkennt, wann eine Variable gleich True ist und wann nicht.

Verständnis von truthy Werten

In diesem Schritt werden wir das Konzept von "wahrheitsähnlichen" (truthy) Werten in Python untersuchen. In Python ist nicht alles explizit True oder False, aber bestimmte Werte werden in einem booleschen Kontext als True behandelt, während andere als False behandelt werden. Das Verständnis von wahrheitsähnlichen Werten ist entscheidend für das Schreiben von kompakten und effektiven bedingten Anweisungen.

In Python gelten die folgenden Werte als "falschähnliche" (falsy) Werte (werden in einem booleschen Kontext als False behandelt):

False
None
0 (Null)
"" (leerer String)
[] (leere Liste)
{} (leeres Dictionary)
() (leeres Tupel)

Alle anderen Werte gelten als "wahrheitsähnliche" (truthy) Werte (werden in einem booleschen Kontext als True behandelt). Erstellen wir ein Skript, um dies zu demonstrieren.

Öffnen Sie Ihren VS Code-Editor.
Erstellen Sie eine neue Datei mit dem Namen truthy_values.py in Ihrem ~/project-Verzeichnis.
```
cd ~/project
```

Fügen Sie den folgenden Inhalt zur Datei truthy_values.py hinzu:

## Examples of truthy and falsy values

## Falsy values
falsy_bool = False
falsy_none = None
falsy_int = 0
falsy_string = ""
falsy_list = []
falsy_dict = {}
falsy_tuple = ()

## Truthy values
truthy_int = 1
truthy_string = "Hello"
truthy_list = [1, 2, 3]
truthy_dict = {"key": "value"}

## Check truthiness in if statements
if falsy_bool:
    print("falsy_bool is True")
else:
    print("falsy_bool is False")

if falsy_none:
    print("falsy_none is True")
else:
    print("falsy_none is False")

if falsy_int:
    print("falsy_int is True")
else:
    print("falsy_int is False")

if truthy_int:
    print("truthy_int is True")
else:
    print("truthy_int is False")

Dieses Skript definiert mehrere Variablen mit verschiedenen Werten, von denen einige falschähnlich (falsy) und einige wahrheitsähnlich (truthy) sind. Anschließend werden if-Anweisungen verwendet, um die Wahrheitsähnlichkeit jeder Variable zu prüfen und entsprechend eine Nachricht auszugeben.

Führen Sie das Skript mit dem Python-Befehl aus:
```
python truthy_values.py
```
Sie sollten die folgende Ausgabe sehen:
```
falsy_bool is False
falsy_none is False
falsy_int is False
truthy_int is True
```
Diese Ausgabe zeigt, wie verschiedene Werte in einem booleschen Kontext entweder als True oder False behandelt werden. Das Verständnis von wahrheitsähnlichen Werten ermöglicht es Ihnen, kompakteren und lesbareren Code zu schreiben, indem Sie implizit auf Bedingungen prüfen, ohne diese explizit mit True oder False zu vergleichen.

Zusammenfassung

In diesem Lab (Praktikum) haben wir zunächst die grundlegenden booleschen Werte True und False in Python untersucht. Wir haben gelernt, dass dies Schlüsselwörter sind, die die Wahrheit oder Falschheit einer Bedingung repräsentieren, und dass ihr Typ <class 'bool'> ist. Wir haben diese Werte Variablen zugewiesen und ihre Werte und Typen ausgegeben, um ihre Natur zu bestätigen.

Als nächstes haben wir begonnen, über den direkten Vergleich mit dem booleschen Wert True mithilfe des Gleichheitsoperators == zu lernen. Dies ermöglicht es uns, zu prüfen, ob eine Bedingung erfüllt ist.