Python-Datentypen und Operatoren

Einführung

In diesem Lab werden Sie die grundlegenden Python-Datentypen und Operatoren erkunden. Basierend auf Ihrem Wissen aus dem vorherigen Lab werden Sie über Ganzzahlen (integers), Fließkommazahlen (floating-point numbers), Zeichenketten (strings) und boolesche Werte (boolean values) lernen. Sie werden auch üben, verschiedene Operatoren zu verwenden, um Berechnungen und Vergleiche durchzuführen. Diese praktische Erfahrung wird Ihr Verständnis der Kernkonzepte von Python vertiefen und Sie auf anspruchsvollere Programmieraufgaben vorbereiten.

Skills Graph

Grundlegendes Verständnis numerischer Datentypen

In diesem Schritt werden Sie mit zwei primären numerischen Datentypen in Python arbeiten: Ganzzahlen (integers) und Fließkommazahlen (floating-point numbers).

1. Öffnen Sie den Python-Interpreter, indem Sie den folgenden Befehl in Ihrem Terminal eingeben:

   python

   Sie sollten die Python-Eingabeaufforderung (>>>) sehen, was darauf hinweist, dass Sie jetzt in der interaktiven Python-Shell sind.

2. Beginnen wir mit der Erkundung von Ganzzahlen. Geben Sie im Python-Interpreter Folgendes ein:

   >>> age = 25
   >>> print(f"I am {age} years old.")
   I am 25 years old.
   >>> type(age)
   <class 'int'>

   Hier ist age eine Ganzzahlvariable. Die type()-Funktion bestätigt, dass es sich um einen int (Ganzzahl)-Datentyp handelt. Ganzzahlen sind ganze Zahlen ohne Dezimalstellen.

3. Jetzt arbeiten wir mit Fließkommazahlen:

   >>> height = 1.75
   >>> print(f"My height is {height} meters.")
   My height is 1.75 meters.
   >>> type(height)
   <class 'float'>

   height ist eine Fließkommazahl, die im Python durch den float-Datentyp repräsentiert wird. Fließkommazahlen werden für Zahlen mit Dezimalstellen verwendet.

4. Führen wir eine Berechnung mit diesen numerischen Typen durch:

   >>> weight = 70  ## Definieren wir zunächst das Gewicht
   >>> bmi = weight / (height ** 2)
   >>> print(f"My BMI is {bmi:.2f}")
   My BMI is 22.86

   Hier definieren wir zunächst weight. Der **-Operator wird für die Potenzierung verwendet. Das .2f in der f-String-Formatierung sorgt dafür, dass die Ausgabe nur zwei Dezimalstellen zeigt.

   # wird in Python für Kommentare verwendet. Kommentare werden vom Interpreter ignoriert und dienen zur Dokumentation des Codes.

Wenn Sie einen Fehler machen oder verschiedene Werte ausprobieren möchten, keine Sorge! Sie können einfach die Variablen neu definieren und die Berechnungen erneut ausführen.

Arbeiten mit Zeichenketten (Strings)

In diesem Schritt werden Sie lernen, wie Sie mit Zeichenketten (strings) arbeiten, die in Python Sequenzen von Zeichen sind.

1. Erstellen Sie im Python-Interpreter eine Zeichenkettenvariable:

   >>> name = "Alice"
   >>> print(f"Hello, {name}!")
   Hello, Alice!
   >>> type(name)
   <class 'str'>

   Der str-Datentyp repräsentiert Zeichenketten in Python. Zeichenketten werden entweder in einfache Anführungszeichen ('') oder doppelte Anführungszeichen ("") eingeschlossen.

2. Zeichenketten unterstützen verschiedene Operationen. Lassen Sie uns einige davon erkunden:

   >>> ## String concatenation (Verknüpfen von Zeichenketten)
   >>> first_name = "John"
   >>> last_name = "Doe"
   >>> full_name = first_name + " " + last_name
   >>> print(full_name)
   John Doe
   
   >>> ## String repetition (Wiederholung von Zeichenketten)
   >>> echo = "Hello " * 3
   >>> print(echo)
   Hello Hello Hello
   
   >>> ## String length (Länge einer Zeichenkette)
   >>> print(len(full_name))
   8
   
   >>> ## Accessing characters in a string (Zugriff auf Zeichen in einer Zeichenkette)
   >>> print(full_name[0])  ## First character (index 0)
   J
   >>> print(full_name[-1])  ## Last character
   e

   Denken Sie daran, dass in Python die Indizierung bei 0 beginnt, sodass das erste Zeichen am Index 0 steht.

3. Zeichenketten in Python sind unveränderlich (immutable), was bedeutet, dass Sie einzelne Zeichen nicht ändern können. Sie können jedoch neue Zeichenketten auf der Grundlage vorhandener erstellen:

   >>> uppercase_name = full_name.upper()
   >>> print(uppercase_name)
   JOHN DOE
   
   >>> lowercase_name = full_name.lower()
   >>> print(lowercase_name)
   john doe

   Diese Methoden ändern die ursprüngliche Zeichenkette nicht, sondern erstellen neue.

Grundlegendes Verständnis von booleschen Werten und Vergleichsoperatoren

In diesem Schritt werden Sie über boolesche Werte und die Verwendung von Vergleichsoperatoren in Python lernen.

1. Boolesche Werte in Python sind entweder True oder False. Erstellen wir einige boolesche Variablen:

   >>> is_student = True
   >>> is_employed = False
   >>> print(f"Is a student: {is_student}")
   Is a student: True
   >>> print(f"Is employed: {is_employed}")
   Is employed: False
   >>> type(is_student)
   <class 'bool'>

   Boolesche Werte werden oft in bedingten Anweisungen und Schleifen verwendet, über die Sie in zukünftigen Labs lernen werden.

2. Vergleichsoperatoren geben boolesche Werte zurück. Lassen Sie uns einige Vergleiche erkunden:

   >>> x = 5
   >>> y = 10
   >>> print(x < y)   ## Less than (kleiner als)
   True
   >>> print(x > y)   ## Greater than (größer als)
   False
   >>> print(x == y)  ## Equal to (gleich)
   False
   >>> print(x!= y)  ## Not equal to (ungleich)
   True
   >>> print(x <= y)  ## Less than or equal to (kleiner oder gleich)
   True
   >>> print(x >= y)  ## Greater than or equal to (größer oder gleich)
   False

   Diese Operatoren vergleichen Werte und geben True oder False basierend auf dem Vergleich zurück.

3. Sie können Vergleichsoperatoren auch mit anderen Datentypen verwenden:

   >>> name1 = "Alice"
   >>> name2 = "Bob"
   >>> print(name1 < name2)  ## Alphabetical comparison (alphabetischer Vergleich)
   True
   
   >>> print(len(name1) == len(name2))  ## Comparing string lengths (Vergleich der Zeichenkettenlängen)
   False

   Beim Vergleichen von Zeichenketten verwendet Python die lexikographische Ordnung (Wörterbuchreihenfolge).

4. Boolesche Operatoren (and, or, not) können verwendet werden, um boolesche Werte zu kombinieren:

   >>> a = True
   >>> b = False
   >>> print(a and b)  ## True if both are True (True, wenn beide True sind)
   False
   >>> print(a or b)   ## True if at least one is True (True, wenn mindestens einer True ist)
   True
   >>> print(not a)    ## Negation (Negation)
   False

   Diese Operatoren sind nützlich, um komplexe Bedingungen in Ihren Programmen zu erstellen.

Erkundung der Typkonvertierung

In diesem Schritt werden Sie lernen, wie Sie zwischen verschiedenen Datentypen in Python konvertieren können.

1. Manchmal müssen Sie einen Datentyp in einen anderen umwandeln. Python bietet dafür eingebaute Funktionen. Beginnen wir mit der Konvertierung von Zeichenketten in Zahlen:

   >>> ## Converting string to integer (Konvertieren einer Zeichenkette in eine Ganzzahl)
   >>> age_str = "25"
   >>> age_int = int(age_str)
   >>> print(f"Age: {age_int}")
   Age: 25
   >>> print(type(age_int))
   <class 'int'>
   
   >>> ## Converting string to float (Konvertieren einer Zeichenkette in eine Fließkommazahl)
   >>> height_str = "1.75"
   >>> height_float = float(height_str)
   >>> print(f"Height: {height_float} meters")
   Height: 1.75 meters
   >>> print(type(height_float))
   <class 'float'>

   Die Funktionen int() und float() konvertieren Zeichenketten in Ganzzahlen bzw. Fließkommazahlen. Achten Sie darauf: Wenn die Zeichenkette nicht konvertiert werden kann, erhalten Sie einen Fehler.

2. Sie können auch Zahlen in Zeichenketten umwandeln:

   >>> ## Converting integer to string (Konvertieren einer Ganzzahl in eine Zeichenkette)
   >>> count = 42
   >>> count_str = str(count)
   >>> print(f"The count is: {count_str}")
   The count is: 42
   >>> print(type(count_str))
   <class 'str'>
   
   >>> ## Converting float to string (Konvertieren einer Fließkommazahl in eine Zeichenkette)
   >>> pi = 3.14159
   >>> pi_str = str(pi)
   >>> print(f"Pi is approximately {pi_str}")
   Pi is approximately 3.14159
   >>> print(type(pi_str))
   <class 'str'>

   Die Funktion str() kann die meisten Python-Objekte in Zeichenketten umwandeln.

3. Boolesche Werte können in andere Typen und aus anderen Typen konvertiert werden:

   >>> ## Converting to boolean (Konvertieren in einen booleschen Wert)
   >>> print(bool(1))     ## Non-zero numbers are True (Nicht-null-Zahlen sind True)
   True
   >>> print(bool(0))     ## Zero is False (Null ist False)
   False
   >>> print(bool(""))    ## Empty string is False (Leere Zeichenkette ist False)
   False
   >>> print(bool("Hello"))  ## Non-empty string is True (Nicht-leere Zeichenkette ist True)
   True
   
   >>> ## Converting boolean to integer (Konvertieren eines booleschen Werts in eine Ganzzahl)
   >>> true_int = int(True)
   >>> false_int = int(False)
   >>> print(f"True as integer: {true_int}")
   True as integer: 1
   >>> print(f"False as integer: {false_int}")
   False as integer: 0

   In Python wird jede nicht-null-Zahl oder nicht-leere Zeichenkette als True angesehen, wenn sie in einen booleschen Wert konvertiert wird.

Alles zusammenführen

In diesem letzten Schritt werden Sie ein einfaches Programm erstellen, das die Konzepte nutzt, die Sie in diesem Lab gelernt haben.

1. Beenden Sie den Python-Interpreter, indem Sie exit() eingeben oder Strg+D drücken.

2. Wechseln Sie im LabEx VM zum Tab WebIDE. WebIDE ist ein Online-Code-Editor, der es Ihnen ermöglicht, Python-Skripte direkt in Ihrem Browser zu schreiben und auszuführen. Es eignet sich für längere Skripte und Projekte.

3. Erstellen Sie eine neue Datei mit dem Namen data_types_practice.py im Verzeichnis ~/project mit dem folgenden Befehl:

   touch ~/project/data_types_practice.py

4. Klicken Sie auf die neu erstellte Datei, um sie im Editor zu öffnen.

5. Kopieren Sie den folgenden Code und fügen Sie ihn in die Datei ein:

   ## Data types and operators practice (Übung mit Datentypen und Operatoren)
   
   ## Get user input (Benutzereingabe erhalten)
   name = input("Enter your name: ")
   age_str = input("Enter your age: ")
   height_str = input("Enter your height in meters: ")
   
   ## Convert input to appropriate types (Eingabe in die passenden Typen umwandeln)
   age = int(age_str)
   height = float(height_str)
   
   ## Perform calculations (Berechnungen durchführen)
   ## You may need to change the year to the current year (Sie müssen möglicherweise das Jahr in das aktuelle Jahr ändern)
   birth_year = 2025 - age
   is_adult = age >= 18
   
   ## Create output string (Ausgabestring erstellen)
   output = f"""
   Name: {name}
   Age: {age}
   Height: {height:.2f} meters
   Birth Year: {birth_year}
   Is Adult: {is_adult}
   """
   
   ## Print the result (Ergebnis ausgeben)
   print(output)
   
   ## Bonus: String manipulation (Bonus: Zeichenkettenmanipulation)
   uppercase_name = name.upper()
   name_length = len(name)
   
   print(f"Your name in uppercase: {uppercase_name}")
   print(f"Your name has {name_length} characters")

   Dieses Programm demonstriert die Verwendung verschiedener Datentypen, Typkonvertierung, Zeichenkettenformatierung und grundlegende Berechnungen.

6. Speichern Sie die Datei (Autospeichern ist aktiviert) und führen Sie sie mit dem folgenden Befehl aus:

   python ~/project/data_types_practice.py

7. Geben Sie bei entsprechender Aufforderung Ihre Informationen ein. Sie sollten eine Ausgabe ähnlich der folgenden sehen:

   Enter your name: Alice
   Enter your age: 25
   Enter your height in meters: 1.75
   
   Name: Alice
   Age: 25
   Height: 1.75 meters
   Birth Year: 1999
   Is Adult: True
   
   Your name in uppercase: ALICE
   Your name has 5 characters

Wenn Sie einen Fehler beim Eingeben der Daten machen, müssen Sie das Programm erneut ausführen. Dies ist eine gute Gelegenheit, das Ausführen von Python-Skripten mehrmals mit verschiedenen Eingaben zu üben.

Zusammenfassung

In diesem Lab haben Sie die grundlegenden Python-Datentypen und Operatoren erkundet. Sie haben gelernt, wie Sie mit Ganzzahlen, Fließkommazahlen, Zeichenketten und booleschen Werten arbeiten. Sie haben verschiedene Operatoren eingesetzt, um Berechnungen und Vergleiche durchzuführen, und Erfahrung mit der Typkonvertierung gesammelt. Schließlich haben Sie diese Konzepte angewandt, um ein einfaches Programm zu erstellen, das Benutzereingaben entgegennimmt, verarbeitet und formatierte Ausgaben erzeugt.

Diese Fähigkeiten bilden die Grundlage für die Python-Programmierung und werden unerlässlich sein, wenn Sie fortfahren und komplexere Programme entwickeln. Denken Sie daran, diese Konzepte regelmäßig zu üben, um Ihr Verständnis zu festigen und sich mit der Python-Syntax und der Datenmanipulation besser vertraut zu machen.

Wenn Sie voranschreiten, zögern Sie nicht, mit dem Python-Interpreter zu experimentieren. Es ist ein ausgezeichnetes Werkzeug, um kleine Code-Schnipsel zu testen und zu verstehen, wie verschiedene Operationen funktionieren. Wenn Sie auf Fehler stoßen, lesen Sie die Fehlermeldungen sorgfältig - sie geben oft Hinweise darauf, was schief gelaufen ist und wie Sie es beheben können.