Zahlentypen und Operationen in Python verstehen | Python Zahlenlabor

Einführung

In diesem Lab erlangen Sie ein grundlegendes Verständnis der Zahlentypen und Operationen in Python. Wir werden die Eigenschaften von Ganzzahl-, Booleschen, Gleitkomma- und komplexen Zahlentypen untersuchen, einschließlich ihrer Unveränderlichkeit (Immutability) und wie man ihre Typen und Speicheradressen überprüft. Durch praktische Übungen lernen Sie, wie man zwischen verschiedenen Zahlentypen konvertiert und grundlegende arithmetische Operationen durchführt, wodurch Ihr Wissen über Pythons numerische Fähigkeiten gefestigt wird.

Integer- und Boolean-Typen untersuchen

In diesem Schritt untersuchen wir die Datentypen Integer (int) und Boolesch (bool) in Python. Ganzzahlen sind ganze Zahlen wie 10, -5 oder 0. Boolesche Werte repräsentieren einen von zwei Werten: True oder False, und sind ein Subtyp von Ganzzahlen.

Ein wichtiges Konzept in Python ist die Unveränderlichkeit (Immutability). Zahlentypen sind unveränderlich, was bedeutet, dass der Wert eines Zahlenobjekts nach seiner Erstellung nicht geändert werden kann. Wenn Sie einer Variablen einen neuen Zahlenwert zuweisen, verweist sie auf ein neues Objekt im Speicher. Wir können dies mithilfe der eingebauten Funktion id(), die die eindeutige Speicheradresse eines Objekts zurückgibt, und der Funktion type(), die seinen Datentyp anzeigt, überprüfen.

Die Laborumgebung hat bereits eine Datei für Sie erstellt. Öffnen Sie im WebIDE-Dateiexplorer auf der linken Seite die Datei ~/project/number_types.py. Fügen Sie den folgenden Code hinzu:

## Demonstrate immutability of integers
a = 5
print(f"Initial value of a: {a}")
print(f"Type of a: {type(a)}")
print(f"ID of a: {id(a)}")

## Reassign 'a' to a new value
a = 6
print(f"\nNew value of a: {a}")
print(f"New ID of a: {id(a)}")

## Demonstrate boolean type
print("\n--- Boolean Types ---")
is_true = True
is_false = False
print(f"Value of is_true: {is_true}, Type: {type(is_true)}")
print(f"Value of is_false: {is_false}, Type: {type(is_false)}")

## Booleans behave like integers (1 and 0) in arithmetic
print(f"\nTrue + 5: {True + 5}")
print(f"False * 3: {False * 3}")

Nachdem Sie den Code hinzugefügt haben, speichern Sie die Datei. Um das Skript auszuführen, öffnen Sie das integrierte Terminal in der WebIDE und führen Sie den folgenden Befehl aus:

python ~/project/number_types.py

Sie sollten eine Ausgabe sehen, die der folgenden ähnelt. Beachten Sie, dass die Speicheradressen (ID) auf Ihrem System unterschiedlich sein werden.

Initial value of a: 5
Type of a: <class 'int'>
ID of a: <memory_address_1>

New value of a: 6
New ID of a: <memory_address_2>

--- Boolean Types ---
Value of is_true: True, Type: <class 'bool'>
Value of is_false: False, Type: <class 'bool'>

True + 5: 6
False * 3: 0

Die Ausgabe zeigt, dass sich die ID von a änderte, als es von 5 auf 6 neu zugewiesen wurde, was bestätigt, dass ein neues Integer-Objekt erstellt wurde. Es wird auch demonstriert, dass True in Berechnungen als 1 und False als 0 behandelt wird.

Mit Gleitkommazahlen (Floating-Point Numbers) arbeiten

In diesem Schritt arbeiten wir mit Gleitkommazahlen (float), die reelle Zahlen mit einem Dezimalpunkt darstellen. Ein häufiges Problem bei Floats ist ihre begrenzte Präzision, da sie im Binärformat gespeichert werden. Dies kann manchmal zu kleinen Ungenauigkeiten bei Berechnungen führen.

Lassen Sie uns dieses Verhalten untersuchen. Öffnen Sie erneut ~/project/number_types.py und fügen Sie den folgenden Code am Ende der Datei hinzu. Dieser Code demonstriert das Präzisionsproblem und führt zwei Methoden ein, um damit umzugehen: die Funktion round() für einfaches Runden und das Modul decimal für hochpräzise Arithmetik.

## Demonstrate floating-point numbers and precision
print("\n--- Floating-Point Numbers ---")
result = 1.1 + 2.2
print(f"1.1 + 2.2 = {result}")

## Using round() for approximation
print(f"round(result, 1) = {round(result, 1)}")

## Using the decimal module for accurate calculations
from decimal import Decimal

## Pass numbers as strings to Decimal to avoid initial float inaccuracy
d1 = Decimal('1.1')
d2 = Decimal('2.2')
decimal_result = d1 + d2
print(f"Decimal('1.1') + Decimal('2.2') = {decimal_result}")

Speichern Sie die Datei und führen Sie das Skript erneut im Terminal aus:

python ~/project/number_types.py

Ihre Ausgabe wird nun den folgenden Abschnitt enthalten:

--- Floating-Point Numbers ---
1.1 + 2.2 = 3.3000000000000003
round(result, 1) = 3.3
Decimal('1.1') + Decimal('2.2') = 3.3

Wie Sie sehen können, ergibt die Standard-Float-Addition 1.1 + 2.2 nicht exakt 3.3. Während round() helfen kann, die Ausgabe zu formatieren, bietet das decimal-Modul eine Möglichkeit, Berechnungen mit der exakten Dezimaldarstellung durchzuführen und somit die präzise Antwort zu liefern.

Einführung in komplexe Zahlen (Complex Numbers)

Python bietet eingebaute Unterstützung für komplexe Zahlen, die in vielen wissenschaftlichen und technischen Bereichen unerlässlich sind. Eine komplexe Zahl hat einen Realteil und einen Imaginärteil und wird in der Form a + bj geschrieben, wobei j die imaginäre Einheit darstellt.

Sie können komplexe Zahlen mit dieser Notation oder mit dem Konstruktor complex(real, imag) erstellen. Auf den Real- und Imaginärteil kann über die Attribute .real und .imag zugegriffen werden.

Bearbeiten Sie weiterhin die Datei ~/project/number_types.py. Fügen Sie den folgenden Code am Ende hinzu, um komplexe Zahlen zu untersuchen:

## Demonstrate complex numbers
print("\n--- Complex Numbers ---")
c1 = 3 + 4j
print(f"Complex number c1: {c1}")
print(f"Type of c1: {type(c1)}")
print(f"Real part of c1: {c1.real}")
print(f"Imaginary part of c1: {c1.imag}")

## Creating a complex number with the constructor
c2 = complex(5, -2)
print(f"\nComplex number c2: {c2}")
print(f"Real part of c2: {c2.real}")
print(f"Imaginary part of c2: {c2.imag}")

Speichern Sie die Datei und führen Sie das Skript erneut im Terminal aus:

python ~/project/number_types.py

Die neue Ausgabe wird lauten:

--- Complex Numbers ---
Complex number c1: (3+4j)
Type of c1: <class 'complex'>
Real part of c1: 3.0
Imaginary part of c1: 4.0

Complex number c2: (5-2j)
Real part of c2: 5.0
Imaginary part of c2: -2.0

Beachten Sie, dass sowohl der Realteil als auch der Imaginärteil als Gleitkommazahlen gespeichert werden, selbst wenn Sie sie mit Ganzzahlen definieren.

Konvertierung zwischen Zahlentypen

Python bietet eingebaute Funktionen zur Konvertierung zwischen verschiedenen Zahlentypen, wie int(), float() und complex(). Dies wird als Typumwandlung (Type Casting) bezeichnet.

int(x): Konvertiert x in eine Ganzzahl (Integer). Beim Konvertieren eines Floats wird der Dezimalteil abgeschnitten (trunkiert), es findet keine Rundung statt.
float(x): Konvertiert x in eine Gleitkommazahl.
complex(real, imag): Erstellt eine komplexe Zahl.

Lassen Sie uns die Typumwandlung üben. Fügen Sie den folgenden Code am Ende Ihres Skripts ~/project/number_types.py hinzu:

## Demonstrate type conversion
print("\n--- Type Conversion ---")

## Convert float to int (truncation)
float_num = 9.9
int_num = int(float_num)
print(f"float_num = {float_num}")
print(f"int(float_num) = {int_num}")

## Convert int to float
int_val = 10
float_val = float(int_val)
print(f"\nint_val = {int_val}")
print(f"float(int_val) = {float_val}")

## Convert string to number
str_num = "123.45"
converted_float = float(str_num)
converted_int = int(float(str_num)) ## Must convert to float first
print(f"\nstr_num = '{str_num}'")
print(f"float(str_num) = {converted_float}")
print(f"int(float(str_num)) = {converted_int}")

Speichern Sie die Datei und führen Sie das Skript noch einmal aus:

python ~/project/number_types.py

Die Ausgabe wird nun diesen Abschnitt enthalten:

--- Type Conversion ---
float_num = 9.9
int(float_num) = 9

int_val = 10
float(int_val) = 10.0

str_num = '123.45'
float(str_num) = 123.45
int(float(str_num)) = 123

Diese Ausgabe zeigt deutlich, wie int() die Dezimalstelle von 9.9 auf 9 abschneidet (trunkiert). Sie veranschaulicht auch den zweistufigen Prozess, der erforderlich ist, um einen String, der eine Dezimalzahl enthält, in eine Ganzzahl umzuwandeln.

Durchführung grundlegender arithmetischer Operationen

Python unterstützt alle Standard-Arithmetikoperationen. Wenn Sie eine Operation mit Operanden unterschiedlicher numerischer Typen durchführen (z. B. einem int und einem float), "erweitert" Python das Ergebnis automatisch auf den allgemeineren Typ. Die Hierarchie lautet int -> float -> complex.

Hier sind die gängigen Operatoren:

+ (Addition)
- (Subtraktion)
* (Multiplikation)
/ (Division – ergibt immer einen Float)
// (Ganzzahl-Division / Floor Division – dividiert und rundet auf die nächste ganze Zahl ab)
% (Modulo – gibt den Rest einer Division zurück)
** (Exponentiation / Potenzierung)

Um unsere Erkundung abzuschließen, fügen wir einen letzten Abschnitt zu ~/project/number_types.py hinzu, um diese Operationen zu üben.

## Demonstrate basic arithmetic operations
print("\n--- Basic Arithmetic Operations ---")
a = 10
b = 3

print(f"{a} + {b} = {a + b}")
print(f"{a} - {b} = {a - b}")
print(f"{a} * {b} = {a * b}")
print(f"{a} / {b} = {a / b}")
print(f"{a} // {b} = {a // b}")
print(f"{a} % {b} = {a % b}")
print(f"{a} ** {b} = {a ** b}")

## Demonstrate mixed-type operations
print("\n--- Mixed-Type Operations ---")
int_op = 5
float_op = 2.5
result_mixed = int_op * float_op
print(f"{int_op} (int) * {float_op} (float) = {result_mixed} ({type(result_mixed)})")

Speichern Sie die Datei und führen Sie das vollständige Skript aus:

python ~/project/number_types.py

Die endgültige Ausgabe wird Folgendes enthalten:

--- Basic Arithmetic Operations ---
10 + 3 = 13
10 - 3 = 7
10 * 3 = 30
10 / 3 = 3.3333333333333335
10 // 3 = 3
10 % 3 = 1
10 ** 3 = 1000

--- Mixed-Type Operations ---
5 (int) * 2.5 (float) = 12.5 (<class 'float'>)

Diese Ausgabe bestätigt das Verhalten jedes Operators. Beachten Sie, dass die Standarddivision / einen Float ergibt, während die Ganzzahl-Division // eine Ganzzahl ergibt. Die Operation mit gemischten Typen zwischen einer Ganzzahl und einem Float führt wie erwartet zu einem Float.

Zusammenfassung

In diesem Lab haben Sie eine solide Grundlage in Pythons numerischen Datentypen erworben. Sie haben sich über Ganzzahlen (Integers), Booleans, Gleitkommazahlen (Floats) und komplexe Zahlen informiert. Sie haben das Konzept der Unveränderlichkeit (Immutability) untersucht und die Funktionen id() sowie type() zur Inspektion von Objekten verwendet. Sie haben geübt, Probleme mit der Gleitkommapräzision mithilfe des decimal-Moduls zu behandeln, zwischen verschiedenen Zahlentypen mittels int(), float() und complex() zu konvertieren und eine Reihe arithmetischer Operationen durchzuführen. Dieses Wissen ist entscheidend für alle weiteren Programmier- oder Datenanalyseaufgaben in Python.