Python - Zahlen: Ihr Schlüssel zur Welt der numerischen Programmierung

Hallo da, zukünftige Python-Zauberer! Ich bin begeistert, Ihr Führer auf dieser spannenden Reise in die Welt der Python-Zahlen zu sein. Als jemand, der seit Jahren Programmierung lehrt, kann ich Ihnen sagen, dass das Verständnis von Zahlen in Python wie das Lernen des Alphabets vor dem Schreiben eines Romans ist - es ist essential! Also, tauchen wir ein und machen wir Zahlen zu unseren neuen besten Freunden.

Python - Zahlenarten

In Python sind Zahlen wie die verschiedenen Sorten von Eis - jede Art hat ihre eigenen einzigartigen Merkmale und Verwendungen. Lassen Sie uns die Haupttypen erkunden:

Python − Ganze Zahlen

Ganze Zahlen, kurz 'int', sind Zahlen ohne Dezimalpunkte. Sie sind wie die stabilen Steine, die wir verwenden, um unseren numerischen Burg zu bauen.

alter = 25
anzahl_der_haustiere = 3
negative_zahl = -10

print(f"Ich bin {alter} Jahre alt und habe {anzahl_der_haustiere} Haustiere.")
print(f"Die Temperatur ist um {abs(negative_zahl)} Grad gefallen.")

In diesem Beispiel sind alter, anzahl_der_haustiere und negative_zahl alle ganzen Zahlen. Beachten Sie, wie wir sie in Berechnungen verwenden und sogar Funktionen wie abs() anwenden, um den Absolutwert zu erhalten.

Python − Fließkommazahlen

Fließkommazahlen sind Zahlen mit Dezimalpunkten. Sie sind die präzisen Werkzeuge in unserer numerischen Werkzeugkiste.

pi = 3.14159
hoehe = 1.75
kleine_zahl = 1.23e-4  # Wissenschaftliche Notation

print(f"Der Wert von pi auf 5 Dezimalstellen: {pi}")
print(f"Ich bin {hoehe} Meter groß.")
print(f"Eine sehr kleine Zahl: {kleine_zahl}")

Hier sind pi, hoehe und kleine_zahl Fließkommazahlen. Beachten Sie, wie wir wissenschaftliche Notation für sehr kleine (oder große) Zahlen verwenden.

Python − Komplexe Zahlen

Komplexe Zahlen sind die Superhelden der Zahlwelt, mit sowohl realen als auch imaginären Teilen.

komplexe_zahl = 3 + 4j
print(f"Eine komplexe Zahl: {komplexe_zahl}")
print(f"Reeller Teil: {komplexe_zahl.real}, Imaginärer Teil: {komplexe_zahl.imag}")

Keine Sorge, wenn komplexe Zahlen, wohl, komplex erscheinen! Sie werden nicht so oft im täglichen Programmieren verwendet, sind aber entscheidend in spezifischen wissenschaftlichen und ingenieurtechnischen Anwendungen.

Umwandlung von Zahlenarten

Manchmal müssen wir den Typ einer Zahl ändern, wie z.B. einen Fließkommawert in eine ganze Zahl umwandeln. Python macht dies einfach:

x = 10.6
y = "20"

int_x = int(x)  # Wandelt Fließkommazahl in Ganzzahl um (rundet ab)
float_y = float(y)  # Wandelt Zeichenkette in Fließkommazahl um
komplexe_x = complex(x)  # Wandelt in komplexe Zahl um

print(f"{x} als ganze Zahl: {int_x}")
print(f"{y} als Fließkommazahl: {float_y}")
print(f"{x} als komplexe Zahl: {komplexe_x}")

Beachten Sie, dass Python bei der Umwandlung von Fließkommazahlen in Ganzzahlen immer abrundet. Es ist wie das Abtrennen der Dezimalteile mit Scheren!

Theoretische und Darstellungs-Funktionen

Python bietet mehrere Funktionen, um uns zu helfen, Zahlen besser zu verstehen und darzustellen:

Funktion	Beschreibung	Beispiel
abs(x)	Liefert den Absolutwert von x	abs(-5) = 5
ceil(x)	Liefert die kleinste ganze Zahl größer oder gleich x	ceil(4.2) = 5
floor(x)	Liefert die größte ganze Zahl kleiner oder gleich x	floor(4.2) = 4
round(x, n)	Rundet x auf n Dezimalstellen	round(3.14159, 2) = 3.14

import math

x = -4.7

print(f"Absolutwert von {x}: {abs(x)}")
print(f"Oberfläche von {x}: {math.ceil(x)}")
print(f"Boden von {x}: {math.floor(x)}")
print(f"{x} gerundet auf 1 Dezimalstelle: {round(x, 1)}")

Potenz- und Logarithmus-Funktionen

Diese Funktionen sind wie die Schwergewichts-Champions der mathematischen Operationen:

Funktion	Beschreibung	Beispiel
pow(x, y)	Liefert x hoch y	pow(2, 3) = 8
sqrt(x)	Liefert die Wurzel von x	sqrt(16) = 4
log(x)	Liefert den natürlichen Logarithmus von x	log(2.71828) ≈ 1
log10(x)	Liefert den Logarithmus zur Basis 10 von x	log10(100) = 2

import math

basis = 2
exponent = 3

print(f"{basis} hoch {exponent}: {pow(basis, exponent)}")
print(f"Quadratwurzel von 16: {math.sqrt(16)}")
print(f"Natürlicher Logarithmus von e: {math.log(math.e)}")
print(f"Logarithmus zur Basis 10 von 100: {math.log10(100)}")

Trigonometrische Funktionen

Trigonometrie mag schrecklich klingen, aber diese Funktionen sind nur Werkzeuge, um mit Winkeln und Dreiecken zu arbeiten:

Funktion	Beschreibung
sin(x)	Sinus von x (x in Radiant)
cos(x)	Kosinus von x (x in Radiant)
tan(x)	Tangens von x (x in Radiant)

import math

winkel = math.pi / 4  # 45 Grad in Radiant

print(f"Sinus von 45°: {math.sin(winkel):.4f}")
print(f"Kosinus von 45°: {math.cos(winkel):.4f}")
print(f"Tangens von 45°: {math.tan(winkel):.4f}")

Winkel-Umwandlungs-Funktionen

Diese Funktionen helfen uns, zwischen Grad und Radiant umzuschalten:

Funktion	Beschreibung
degrees(x)	Konvertiert Winkel x von Radiant in Grad
radians(x)	Konvertiert Winkel x von Grad in Radiant

import math

winkel_rad = math.pi / 2
winkel_grad = 180

print(f"{winkel_rad} Radiant entspricht {math.degrees(winkel_rad)} Grad")
print(f"{winkel_grad} Grad entspricht {math.radians(winkel_grad)} Radiant")

Mathematische Konstanten

Pythons math-Modul bietet einige häufig verwendete mathematische Konstanten:

import math

print(f"Pi: {math.pi}")
print(f"Eulersche Zahl (e): {math.e}")
print(f"Tau (2*pi): {math.tau}")

Diese Konstanten sind wie die berühmten Zahlen der Mathematikwelt - berühmt und weit verbreitet!

Zufallszahl-Funktionen

Manchmal brauchen wir einen Hauch von Unvorhersehbarkeit in unseren Programmen. Hier kommen Zufallszahlen ins Spiel:

import random

print(f"Eine zufällige Fließkommazahl zwischen 0 und 1: {random.random()}")
print(f"Eine zufällige ganze Zahl zwischen 1 und 10: {random.randint(1, 10)}")
print(f"Eine zufällige Wahl aus einer Liste: {random.choice(['Apfel', 'Banane', 'Kirsche'])}")

Zufallszahlen sind wie das Gewürz in Ihrem Programmgericht - sie fügen dem Extra-Kick von Spannung hinzu!

Eingebaute mathematische Funktionen

Python bietet einige praktische eingebaute Funktionen für gängige mathematische Operationen:

Funktion	Beschreibung	Beispiel
max(x, y, ...)	Liefert das größte Argument	max(5, 10, 15) = 15
min(x, y, ...)	Liefert das kleinste Argument	min(5, 10, 15) = 5
sum(iterable)	Liefert die Summe aller Elemente in einem iterierbaren	sum([1, 2, 3, 4]) = 10

zahlen = [1, 2, 3, 4, 5]

print(f"Die größte Zahl ist: {max(zahlen)}")
print(f"Die kleinste Zahl ist: {min(zahlen)}")
print(f"Die Summe aller Zahlen ist: {sum(zahlen)}")

Und so haben Sie es, meine lieben Schüler! Wir haben die Reise durch die Welt der Python-Zahlen gemacht, vom bescheidenen Integer zur mächtigen trigonometrischen Funktion. Erinnern Sie sich, dass Übung macht den Meister, also zögern Sie nicht, diese Konzepte in Ihrem eigenen Code zu experimentieren.

Wie ich meinen Schülern immer sage, Programmierung ist wie das Lernen, ein Fahrrad zu fahren - es mag am Anfang wackelig erscheinen, aber mit Übung werden Sie in kürzester Zeit wie der Wind fahren. Also, weiter coden, weiter erkunden und vor allem, weiter Spaß mit Python-Zahlen haben!

Credits: Image by storyset