Zahlentypen und Operationen in Python verstehen

PythonPythonBeginner
Jetzt üben

💡 Dieser Artikel wurde von AI-Assistenten übersetzt. Um die englische Version anzuzeigen, können Sie hier klicken

Einführung

In diesem Labor erhalten Sie ein grundlegendes Verständnis von Zahlentypen und Operationen in Python. Wir werden die Eigenschaften von Ganzzahl-, Booleschen-, Gleitkomma- und komplexen Zahlentypen untersuchen, einschließlich ihrer Unveränderlichkeit und wie Sie ihre Typen und Speicheradressen überprüfen können.

Durch praktische Übungen lernen Sie, wie Sie zwischen verschiedenen Zahlentypen konvertieren und grundlegende arithmetische Operationen durchführen, um Ihr Wissen über die numerischen Fähigkeiten von Python zu festigen.

Erkundung von Ganzzahl- und Booleschen Datentypen

In diesem Schritt werden wir die Ganzzahl- und Booleschen Datentypen in Python untersuchen. Ganzzahlen (int) sind ganze Zahlen, positiv oder negativ, ohne Dezimalstellen. Boolesche Werte (bool) sind ein Untertyp von Ganzzahlen und repräsentieren logische Wahrheitswerte: True und False.

In Python werden Datentypen entweder als veränderlich (mutable) oder unveränderlich (immutable) klassifiziert. Unveränderliche Datentypen, wie Zahlen, Zeichenketten und Tupel, erzeugen bei Wertänderung eine neue Speicheradresse. Veränderliche Datentypen, wie Listen, Mengen und Wörterbücher, behalten ihre Speicheradresse auch bei Wertänderungen bei.

Wir können die eingebaute Funktion type() verwenden, um den Typ eines Objekts zu überprüfen, und id(), um seine Speicheradresse zu ermitteln.

Erstellen wir ein Python-Skript, um dies zu demonstrieren. Öffnen Sie das integrierte Terminal in der WebIDE und navigieren Sie zum Verzeichnis ~/project, falls Sie sich nicht bereits dort befinden.

Erstellen Sie eine neue Datei namens number_types.py im Verzeichnis ~/project mithilfe des Dateiexplorers der WebIDE oder indem Sie den folgenden Befehl im Terminal ausführen:

touch ~/project/number_types.py

Öffnen Sie nun ~/project/number_types.py im Editor der WebIDE und 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)}")

a = 6
print(f"New value of a: {a}")
print(f"New ID of a: {id(a)}")

## Demonstrate boolean type
is_true = True
is_false = False
print(f"Value of is_true: {is_true}")
print(f"Type of is_true: {type(is_true)}")
print(f"Value of is_false: {is_false}")
print(f"Type of is_false: {type(is_false)}")

## Demonstrate boolean as a subtype of integer
print(f"True + 5: {True + 5}")
print(f"False * 3: {False * 3}")

Speichern Sie die Datei. Führen Sie nun das Skript im Terminal aus:

python ~/project/number_types.py

Sie sollten eine Ausgabe ähnlich der folgenden sehen:

Initial value of a: 5
Type of a: <class 'int'>
ID of a: <some_id_1>
New value of a: 6
New ID of a: <some_id_2>
Value of is_true: True
Type of is_true: <class 'bool'>
Value of is_false: False
Type of is_false: <class 'bool'>
True + 5: 6
False * 3: 0

Beachten Sie, wie sich die ID von a ändert, wenn sein Wert neu zugewiesen wird, was bestätigt, dass Ganzzahlen unveränderlich sind. Beobachten Sie auch, dass True in arithmetischen Operationen wie die Ganzzahl 1 und False wie die Ganzzahl 0 agiert.

Arbeiten mit Gleitkommazahlen und Präzision

In diesem Schritt werden wir mit Gleitkommazahlen (float) in Python arbeiten und Probleme im Zusammenhang mit ihrer Präzision untersuchen. Gleitkommazahlen werden zur Darstellung von reellen Zahlen verwendet und können mit einem Dezimalpunkt oder in wissenschaftlicher Notation geschrieben werden (z. B. 1.5e2 für 150,0).

Aufgrund der Art und Weise, wie Gleitkommazahlen binär dargestellt werden, können einige Dezimalzahlen nicht exakt dargestellt werden. Dies kann zu unerwarteten Ergebnissen bei Berechnungen führen.

Erstellen wir ein Python-Skript, um dies zu demonstrieren. Öffnen Sie ~/project/number_types.py im Editor der WebIDE und fügen Sie den folgenden Code am Ende der Datei hinzu:

## Demonstrate floating-point precision issue
print("\n--- Floating-Point Precision ---")
print(f"1.1 + 2.2: {1.1 + 2.2}")

## Using round() for approximation
a = 1.1 + 2.2
print(f"round(a): {round(a)}")
print(f"round(a, 2): {round(a, 2)}")

## Another example with round()
b = 1.119
print(f"round(1.119, 2): {round(b, 2)}")
c = 1.265
print(f"round(1.265, 2): {round(c, 2)}")

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

print("\n--- Decimal Module ---")
d = Decimal('1.1') + Decimal('2.2')
print(f"Decimal('1.1') + Decimal('2.2'): {d}")
print(f"float(d): {float(d)}")

Speichern Sie die Datei. Führen Sie nun das Skript im Terminal aus:

python ~/project/number_types.py

Sie sollten zusätzlich zur Ausgabe aus dem vorherigen Schritt eine Ausgabe ähnlich der folgenden sehen:

--- Floating-Point Precision ---
1.1 + 2.2: 3.3000000000000003
round(a): 3
round(a, 2): 3.3
round(1.119, 2): 1.12
round(1.265, 2): 1.26

--- Decimal Module ---
Decimal('1.1') + Decimal('2.2'): 3.3
float(d): 3.3

Beachten Sie die Ausgabe von 1.1 + 2.2. Sie ist nicht exakt 3.3. Die Funktion round() kann bei der Annäherung helfen, aber wie bei 1.265 gezeigt, verhält sie sich aufgrund der zugrunde liegenden Gleitkommadarstellung möglicherweise nicht immer wie erwartet.

Das Modul decimal bietet eine Möglichkeit, genaue Dezimalarithmetik durchzuführen. Beachten Sie, wie die Verwendung von Decimal('1.1') + Decimal('2.2') das präzise Ergebnis 3.3 liefert. Denken Sie daran, Zahlen als Strings an den Decimal()-Konstruktor zu übergeben, um anfängliche Ungenauigkeiten bei Gleitkommazahlen zu vermeiden.

Einführung in komplexe Zahlen

In diesem Schritt führen wir komplexe Zahlen in Python ein. Komplexe Zahlen bestehen aus einem Realteil und einem Imaginärteil. Sie können als a + bj oder mithilfe des Konstruktors complex(a, b) dargestellt werden, wobei a der Realteil und b der Imaginärteil ist. Sowohl der Real- als auch der Imaginärteil sind Gleitkommazahlen.

Sie können auf den Real- und Imaginärteil einer komplexen Zahl z mit z.real bzw. z.imag zugreifen.

Fügen wir Code zu ~/project/number_types.py hinzu, um komplexe Zahlen zu untersuchen. Öffnen Sie die Datei im Editor der WebIDE und fügen Sie den folgenden Code am Ende hinzu:

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

b = complex(2, 3)
print(f"Complex number b: {b}")
print(f"Real part of b: {b.real}")
print(f"Imaginary part of b: {b.imag}")

Speichern Sie die Datei. Führen Sie nun das Skript im Terminal aus:

python ~/project/number_types.py

Sie sollten zusätzlich zu den Ausgaben aus den vorherigen Schritten eine Ausgabe ähnlich der folgenden sehen:

--- Complex Numbers ---
Complex number a: (5+6j)
Type of a: <class 'complex'>
Real part of a: 5.0
Imaginary part of a: 6.0
Complex number b: (2+3j)
Real part of b: 2.0
Imaginary part of b: 3.0

Beachten Sie, dass der Real- und Imaginärteil als Gleitkommazahlen gespeichert werden, auch wenn Sie beim Erstellen der komplexen Zahl ganze Zahlen angeben.

Konvertierung zwischen Zahlentypen

In diesem Schritt lernen wir, wie man in Python mit den integrierten Konstruktorfunktionen int(), float() und complex() zwischen verschiedenen Zahlentypen konvertiert.

Die Funktion int() kann Zahlen und Zeichenketten in eine Ganzzahl konvertieren. Bei der Konvertierung eines Floats in eine Ganzzahl erfolgt eine Abschneidung (Entfernung des Dezimalteils), keine Rundung. Bei der Konvertierung einer Zeichenkette muss die Zeichenkette eine Ganzzahl darstellen. Sie können auch Zeichenketten konvertieren, die Zahlen in anderen Basen (wie Binär oder Hexadezimal) darstellen, indem Sie das Argument base angeben.

Die Funktion float() kann Ganzzahlen, Floats und Zeichenketten in einen Float konvertieren. Die Zeichenkette kann eine Ganzzahl oder einen Float darstellen.

Die Funktion complex() kann eine Zahl in eine komplexe Zahl mit dem Imaginärteil 0 konvertieren, oder sie kann eine komplexe Zahl aus einem als Argument bereitgestellten Real- und Imaginärteil erstellen.

Fügen wir Code zu ~/project/number_types.py hinzu, um die Typkonvertierung zu demonstrieren. Öffnen Sie die Datei im Editor der WebIDE und fügen Sie den folgenden Code am Ende hinzu:

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

## int() conversions
print("int() conversions:")
print(f"int(): {int()}")
print(f"int(1): {int(1)}")
print(f"int(1.3): {int(1.3)}")
print(f"int(1.9): {int(1.9)}")
print(f"int(0b101): {int(0b101)}") ## Binary to integer
print(f"int(0x32): {int(0x32)}")   ## Hexadecimal to integer
print(f"int('10'): {int('10')}")
print(f"int('0b101', base=0): {int('0b101', base=0)}")
print(f"int('0x32', base=0): {int('0x32', base=0)}")
print(f"int('0b101', base=2): {int('0b101', base=2)}")
print(f"int('0x32', base=16): {int('0x32', base=16)}")

## int() with float string (will cause error)
## try:
##     int('1.5')
## except ValueError as e:
##     print(f"int('1.5') error: {e}")

## float() conversions
print("\nfloat() conversions:")
print(f"float(1): {float(1)}")
print(f"float(1.5): {float(1.5)}")
print(f"float('1'): {float('1')}")
print(f"float('1.5'): {float('1.5')}")

## Converting a float string to integer via float()
float_string = '3.1415926'
float_value = float(float_string)
int_value = int(float_value)
print(f"int(float('{float_string}')): {int_value}")
print(f"int(float('3.1415926')): {int(float('3.1415926'))}")


## complex() conversions
print("\ncomplex() conversions:")
print(f"complex(5): {complex(5)}")
print(f"complex(5, 3): {complex(5, 3)}")

Speichern Sie die Datei. Führen Sie nun das Skript im Terminal aus:

python ~/project/number_types.py

Sie sollten zusätzlich zu den Ausgaben aus den vorherigen Schritten eine Ausgabe ähnlich der folgenden sehen:

--- Type Conversion ---
int() conversions:
int(): 0
int(1): 1
int(1.3): 1
int(1.9): 1
int(0b101): 5
int(0x32): 50
int('10'): 10
int('0b101', base=0): 5
int('0x32', base=0): 50
int('0b101', base=2): 5
int('0x32', base=16): 50

float() conversions:
float(1): 1.0
float(1.5): 1.5
float('1'): 1.0
float('1.5'): 1.5

int(float('3.1415926')): 3
int(float('3.1415926')): 3

complex() conversions:
complex(5): (5+0j)
complex(5, 3): (5+3j)

Beobachten Sie die Ergebnisse der int()-Konvertierungen, insbesondere wie Floats abgeschnitten werden. Beachten Sie auch, dass Sie eine Zeichenkette, die einen Float darstellt, nicht direkt mit int() in eine Ganzzahl konvertieren können. Sie müssen sie zuerst mit float() in einen Float und dann mit int() in eine Ganzzahl konvertieren.

Grundlegende arithmetische Operationen durchführen

In diesem Schritt führen wir grundlegende arithmetische Operationen mit den integrierten Operatoren von Python durch. Python unterstützt gängige arithmetische Operationen wie Addition, Subtraktion, Multiplikation, Division, Ganzzahldivision (Floor Division), Modulo und Potenzierung.

Python verarbeitet auch gemischte Typoperationen. Wenn Operationen verschiedene numerische Typen beinhalten, konvertiert Python automatisch den "schmaleren" Typ zum "breiteren" Typ. Die Reihenfolge der Erweiterung ist Ganzzahl -> Float -> Komplex.

Fügen wir Code zu ~/project/number_types.py hinzu, um diese Operationen zu demonstrieren. Öffnen Sie die Datei im Editor der WebIDE und fügen Sie den folgenden Code am Ende hinzu:

## Demonstrate basic arithmetic operations
print("\n--- Basic Arithmetic Operations ---")
print(f"3 + 5: {3 + 5}")       ## Addition
print(f"9 - 3: {9 - 3}")       ## Subtraction
print(f"3 * 5: {3 * 5}")       ## Multiplication
print(f"10 / 3: {10 / 3}")     ## Division (results in float)
print(f"10 // 3: {10 // 3}")   ## Floor Division (results in integer, rounds down)
print(f"10 % 3: {10 % 3}")     ## Modulo (remainder)
print(f"2 ** 10: {2 ** 10}")   ## Exponentiation (2 to the power of 10)

## Demonstrate mixed-type operations
print("\n--- Mixed-Type Operations ---")
a = 5       ## int
b = 3.1     ## float
c = complex(3) ## complex

d = a + b
e = a + c

print(f"Type of a + b ({a} + {b}): {type(d)}")
print(f"Type of a + c ({a} + {c}): {type(e)}")

Speichern Sie die Datei. Führen Sie nun das Skript im Terminal aus:

python ~/project/number_types.py

Sie sollten zusätzlich zu den Ausgaben aus den vorherigen Schritten eine Ausgabe ähnlich der folgenden sehen:

--- Basic Arithmetic Operations ---
3 + 5: 8
9 - 3: 6
3 * 5: 15
10 / 3: 3.3333333333333335
10 // 3: 3
10 % 3: 1
2 ** 10: 1024

--- Mixed-Type Operations ---
Type of a + b (5 + 3.1): <class 'float'>
Type of a + c (5 + (3+0j)): <class 'complex'>

Beobachten Sie die Ergebnisse der verschiedenen arithmetischen Operatoren. Beachten Sie, dass die Standarddivision (/) immer einen Float zurückgibt, während die Ganzzahldivision (//) eine Ganzzahl zurückgibt (die das Ergebnis abschneidet). Sehen Sie auch, wie Python den Ergebnistyp bei gemischten Typoperationen automatisch anpasst.

Zusammenfassung

In diesem Lab haben wir grundlegende Zahlentypen in Python untersucht, darunter Ganzzahlen (int) und Booleans (bool). Wir haben gelernt, dass Ganzzahlen ganze Zahlen sind und Booleans ein Untertyp von Ganzzahlen sind, die True und False darstellen. Wir haben auch das Konzept der Unveränderlichkeit (immutability) in Python verstanden und beobachtet, wie die Änderung des Werts einer Ganzzahl einen neuen Speicherort erstellt, im Gegensatz zu veränderlichen Typen (mutable types). Wir haben die Funktionen type() und id() verwendet, um Datentypen und Speicheradressen zu inspizieren.

Darüber hinaus werden wir uns mit Gleitkommazahlen (float) und deren Genauigkeit befassen, komplexe Zahlen (complex) einführen und lernen, wie man zwischen verschiedenen Zahlentypen konvertiert. Abschließend werden wir grundlegende arithmetische Operationen mit diesen Zahlentypen üben.