Lektion 1: Einführung in die Programmiersprache Python

Was ist Python?

Python ist eine höherwertige, interpretierte Programmiersprache, die 1986 von Guido van Rossum entwickelt wurde. Seit 1991 wird sie öffentlich genutzt.

Heute ist Python eine der beliebtesten und vielseitigsten Sprachen weltweit – für Web, Desktop, Automation, Spiele, Data Science und IT-Security.

• Desktop-Anwendungen
• Webentwicklung
• Automatisierung (Scripting)
• Spieleentwicklung
• Data Science & Machine Learning
• IT-Sicherheit und Penetration Testing

Gut zu wissen: Python funktioniert auf Windows, macOS, Linux & Co.

Vorteile von Python für Entwickler:innen

• Einfache Syntax: Lesbar & ideal für Einsteiger
• Große Community: Viele Ressourcen & Bibliotheken
• Plattformunabhängig: Lauffähig auf vielen Systemen
• Gefragte Sprache: Hohe Nachfrage am Arbeitsmarkt
• Vielfältiger Einsatz: Von Einsteiger- bis Profiprojekten

Was unterscheidet Python von anderen Programmiersprachen?

Kostenlos & Open Source

• Gratis nutzbar, auch für kommerzielle Projekte
• Quellcode ist offen einsehbar und anpassbar

Technische Vorteile

• Läuft auch auf schwächeren Geräten
• OOP mit Klassen, Vererbung etc.
• Multithreading möglich
• Anbindung an Datenbanken
• GUIs möglich
• Kompatibel mit C, C++, Java

Bildung & Lehre

• Weltweiter Einsatz in Schulen & Universitäten

Für wen ist dieser Kurs geeignet?

Dieser Kurs richtet sich an:

• Einsteiger ohne Vorkenntnisse
• Schüler, Studierende, Auszubildende
• Softwareentwickler:innen, die Neues lernen möchten

Egal ob neugierig, beim Umstieg oder zur Weiterbildung – dieser Kurs bringt dir alles bei.

Bin ich bereit, mit Python zu starten?

Wenn du noch keine Programmiererfahrung hast, empfehlen wir eine Einführung in die Programmierlogik:

• Wie denkt ein Programmierer?
• Was ist ein Algorithmus?
• Wie löst man Probleme strukturiert?

Was erwartet dich im nächsten Kapitel?

Du wirst lernen:

• Wie du Python installierst
• Welche Werkzeuge du brauchst
• Wie du dein erstes einfaches Programm startest

Lektion 2: Einrichtung der Entwicklungsumgebung

Funktionsweise eines Python-Programms

Grundsätzlich erstellen wir eine Datei mit der Endung .py, in die wir unsere Python-Befehle schreiben. Nach dem Speichern wird der Python-Interpreter gestartet, der die Befehle Zeile für Zeile ausführt.

Der von dir geschriebene Code heißt Source Code. Um diesen Code auszuführen, wird er an den Python-Interpreter übergeben. Dieser besteht aus zwei zentralen Komponenten:

• Compiler: Wandelt den Source Code in sogenannten Byte Code um (Dateiendung: .pyc).
• Virtual Machine: Führt den Byte Code auf dem Betriebssystem aus (Windows, Linux, macOS).

Technische Begriffe

• Source Code: Der Originalcode, den du schreibst.
• Byte Code: Vom Compiler erstellter Code, den die Maschine versteht (binär: 0 und 1).
• Compiler: Programm zur Umwandlung von Python-Code in Byte Code.
• Virtual Machine: Führt den Byte Code wie ein normales Programm aus.
• OS (Operating System): Das Betriebssystem – z. B. Windows, Linux, macOS.

Entwicklungsumgebung einrichten

Für diesen Kurs verwenden wir die neueste Version von Python sowie PyCharm – eine kostenfreie und benutzerfreundliche IDE, mit der du deine Projekte effizient verwalten und ausführen kannst.

• Warum PyCharm? Einfach zu bedienen, unterstützt Autovervollständigung und ist perfekt für Einsteiger.
• Alternativ kannst du auch einfache Texteditoren wie Visual Studio Code, Atom oder Notepad++ verwenden.

Tipp: In jeder neuen Programmier-Session sollte ein Projekt in der IDE erstellt werden.

Dein erstes Python-Programm

Im folgenden Beispiel erstellen wir ein einfaches Python-Programm, das die Phrase Hello World! ausgibt.

Test.py
print("Hello World!")
    

Hello World!

In den kommenden Kapiteln wirst du kleine und verständliche Einheiten kennenlernen, die dir die Grundprinzipien von Python näherbringen. Sobald du alle Konzepte verstanden hast, wirst du in der Lage sein, komplette Anwendungen mit grafischer Benutzeroberfläche zu entwickeln.

Lektion 3: Stil und Struktur beim Schreiben von Python-Code

Groß- und Kleinschreibung

In Python ist die Groß- und Kleinschreibung entscheidend. note und Note sind zwei verschiedene Variablen:

Benennungsregeln für Variablen, Funktionen und Klassen

Benennungen in Python folgen klaren Konventionen:

• Variablen: Kleinbuchstaben, evtl. mit Unterstrichen
• Funktionen: Wie Variablen (z. B. calculate_sum)
• Klassen: Großschreibung (CamelCase, z. B. DataModel)

Kommentare – Klarheit im Code

Kommentare machen deinen Code verständlich:

Mehrere Anweisungen in einer Zeile?

Vermeide es, mehrere Anweisungen auf eine Zeile zu schreiben – auch wenn es erlaubt ist:

Mehrzeilige Anweisungen sauber schreiben

Nutze Backslashes \ oder runde Klammern:

Gültige Namen verwenden

Variablennamen dürfen mit Buchstaben oder Unterstrich beginnen, nicht mit Zahlen oder Sonderzeichen:

• ✅ _name, user1, Test
• ❌ 1name, -value, @user

Reservierte Wörter (Schlüsselwörter)

Diese Wörter sind Teil der Python-Syntax und dürfen nicht als Namen verwendet werden:

Einrückung ist Pflicht!

Python verwendet Einrückung statt geschweifter Klammern:

Formatierungstipps für sauberen Code

• Immer 4 Leerzeichen zur Einrückung
• Keine Tabs verwenden
• Max. 79 Zeichen pro Zeile
• Zwischen Funktionen/Klassen Leerzeilen lassen
• Kommentare klar und prägnant schreiben

Tabs in Leerzeichen umwandeln (z. B. in PyCharm)

1. Strg + Alt + S für Einstellungen öffnen
2. Editor → Code Style → Python
3. „Use tab character“ deaktivieren
4. Tabs auf 4 Spaces einstellen

Beispielcode: Prüfung bestanden?

Innerhalb einer Klasse:

Lektion 4: Variablentypen in Python (Detaillierte Erklärung)

Was sind Variablen?

Variablen sind benannte Speicherplätze im Arbeitsspeicher, die während der Programmausführung Daten aufnehmen. Sie ermöglichen es, Werte zu speichern, zu verändern und wiederzuverwenden.
Wichtig: Variablen helfen, Programme flexibel und nachvollziehbar zu gestalten. Sie können verschiedene Datentypen aufnehmen und sind ein zentrales Element jeder Programmiersprache.

Hinweis: In Python muss bei der Erstellung einer Variable sofort ein Wert zugewiesen werden. Der Name sollte beschreibend sein und keine Leerzeichen oder Sonderzeichen enthalten.

Mehrere Variablen mit dem gleichen Wert definieren

Manchmal möchte man mehrere Variablen auf denselben Wert setzen. In Python geht das in einer Zeile. Alle Variablen zeigen dann auf denselben Wert im Speicher.

Technischer Hinweis: Alle Variablen referenzieren denselben Wert im Speicher. Ändert man den Wert einer Variable, sind die anderen nicht betroffen, wenn es sich um unveränderliche Datentypen wie str handelt.

Typ einer Variable herausfinden

Python erkennt den Typ einer Variable automatisch anhand des zugewiesenen Wertes. Mit type() kann man den Typ abfragen.
Warum ist das wichtig? Der Typ bestimmt, welche Operationen mit der Variable möglich sind.

Dynamische Typisierung: In Python kann sich der Typ einer Variable im Programmverlauf ändern. Das macht Python flexibel, aber man muss aufpassen, dass die Typen zu den Operationen passen.

Grundlegende Variablentypen in Python

Details:
int ist für ganze Zahlen ohne Komma.
float ist für Zahlen mit Dezimalstellen.
complex ist für mathematische Berechnungen mit Imaginärteil.

Texte (str)

Zeichenketten (str) sind für Text. Sie können mit einfachen (' ') oder doppelten (" ") Anführungszeichen geschrieben werden.
Mehrzeilige Strings werden mit drei Anführungszeichen (''' ''' oder """ """) erstellt.

String-Methoden: Strings besitzen viele Methoden, z. B. .upper(), .lower(), .replace(), .split().

Boolesche Werte (bool)

Boolesche Werte (True oder False) sind wichtig für Bedingungen und Steuerung des Programmablaufs.
Sie entstehen oft durch Vergleiche (==, >, <).

Praxis: Boolesche Werte werden oft in if-Abfragen genutzt, um Entscheidungen im Programm zu treffen.

Datenstrukturen in Python

Datenstrukturen sind spezielle Variablentypen, die mehrere Werte speichern können. Sie sind essenziell für die Organisation und Verarbeitung von Daten.

🔹 list – Veränderbare Reihenfolge

• Reihenfolge: Ja
• Veränderbar: Ja
• Duplikate: Erlaubt

Details: Listen sind sehr flexibel. Man kann Elemente hinzufügen, entfernen und sortieren. Sie werden mit [] geschrieben.

🔹 tuple – Unveränderliche Liste

• Reihenfolge: Ja
• Veränderbar: Nein
• Duplikate: Erlaubt

Details: Tupel sind wie Listen, aber unveränderlich. Sie werden mit () geschrieben.

🔹 set – Ungeordnete Sammlung

• Reihenfolge: Nein
• Veränderbar: Ja
• Duplikate: Nicht erlaubt

Details: Sets sind Mengen ohne Reihenfolge und ohne Duplikate. Sie werden mit {} geschrieben.

🔹 dict – Schlüssel-Wert-Paare

• Reihenfolge: Ja (ab Python 3.7)
• Veränderbar: Ja
• Duplikate bei Keys: Nicht erlaubt

Details: Dictionaries speichern Werte unter einem Schlüssel. Sie sind sehr praktisch für strukturierte Daten.

Alles ist ein Objekt

In Python ist alles ein Objekt. Das bedeutet, jede Variable besitzt Methoden und Attribute, die man nutzen kann.
Beispiel: Strings haben Methoden wie .upper(), .lower(), .replace().

Details: Auch Zahlen, Listen und Dictionaries sind Objekte und besitzen Methoden.

Fazit

Variablen sind die Grundlage jeder Programmierlogik. Python bietet mit seinen dynamischen Datentypen eine flexible Handhabung.
Ob Zahlen, Texte oder komplexe Datenstrukturen: Das Verständnis der Variablentypen ist essenziell für das effiziente Programmieren in Python.
Tipp: Experimentiere mit verschiedenen Typen und Methoden, um Python besser zu verstehen!

Lektion 5: Operatoren in Python

Das Konzept der Operatoren

Operatoren sind Symbole oder Schlüsselwörter, mit denen du Werte und Variablen in Python verarbeiten kannst. Sie ermöglichen mathematische Berechnungen, Vergleiche, logische Verknüpfungen und vieles mehr. Das Verständnis der Operatoren ist essenziell für jede Programmieraufgabe.

Arithmetische Operatoren

Arithmetische Operatoren führen mathematische Operationen aus. Sie sind die Grundlage für Berechnungen in Python.

# Zuweisung
a = 5
b = a
print("a =", a)
print("b =", b)
# Ausgabe:
a = 5
b = 5

# Addition
a = 3
b = 4
c = a + b
print("Addition: c =", c)
# Ausgabe:
Addition: c = 7

# Subtraktion
a = 3
b = 4
c = a - b
print("Subtraktion: c =", c)
# Ausgabe:
Subtraktion: c = -1

# Multiplikation
a = 6
b = 5
c = a * b
print("Multiplikation: c =", c)
# Ausgabe:
Multiplikation: c = 30

# Division
a = 8
b = 5
c = a / b
print("Division: c =", c)
# Ausgabe:
Division: c = 1.6

# Ganzzahlige Division
a = 8
b = 5
c = a // b
print("Ganzzahlige Division: c =", c)
# Ausgabe:
Ganzzahlige Division: c = 1

# Modulo
a = 8
b = 5
c = a % b
print("Modulo: c =", c)
# Ausgabe:
Modulo: c = 3

# Potenzierung
a = 2
b = 5
c = a ** b
print("Potenzierung: c =", c)
# Ausgabe:
Potenzierung: c = 32

Vergleichsoperatoren

Vergleichsoperatoren vergleichen zwei Werte und liefern True oder False.

# Gleichheit (==)
a = 5
b = 5
print("a == b:", a == b)
# Ausgabe:
a == b: True

# Ungleichheit (!=)
a = 5
b = 3
print("a != b:", a != b)
# Ausgabe:
a != b: True

# Größer als (>)
a = 7
b = 4
print("a > b:", a > b)
# Ausgabe:
a > b: True

# Kleiner als (<)
a = 2
b = 5
print("a < b:", a < b)
# Ausgabe:
a < b: True

# Größer oder gleich (>=)
a = 5
b = 5
print("a >= b:", a >= b)
# Ausgabe:
a >= b: True

# Kleiner oder gleich (<=)
a = 3
b = 6
print("a <= b:", a <= b)
# Ausgabe:
a <= b: True

Bitweise Operatoren

Bitweise Operatoren arbeiten auf der Binärdarstellung von Ganzzahlen. Sie sind nützlich für Systemprogrammierung und Hardwaresteuerung.

# Bitweises UND (&)
a = 10   # Binär: 1010
b = 6    # Binär: 0110
print(a & b)  # Ausgabe: 2 (Binär: 0010)
2

# Bitweises ODER (|)
a = 10   # Binär: 1010
b = 6    # Binär: 0110
print(a | b)  # Ausgabe: 14 (Binär: 1110)
14

# Bitweises exklusives ODER (^)
a = 10   # Binär: 1010
b = 6    # Binär: 0110
print(a ^ b)  # Ausgabe: 12 (Binär: 1100)
12

# Bitweise Negation (~)
a = 10    # Binär: 1010
print(~a)   # Ausgabe: -11
-11

# Linksverschiebung (<<)
a = 5     # Binär: 0101
print(a << 2)   # Ausgabe: 20 (Binär: 10100)
20

# Rechtsverschiebung (>>)
a = 20    # Binär: 10100
print(a >> 2)   # Ausgabe: 5 (Binär: 0101)
5

Identitätsoperatoren

Identitätsoperatoren prüfen, ob zwei Variablen auf dasselbe Objekt im Speicher zeigen. Sie sind besonders wichtig beim Vergleich von Listen, Dictionaries und anderen komplexen Datentypen.

# Identität mit "is"
a = [1, 2, 3]
b = a
print(a is b)  # Ausgabe: True
True

# Identität mit "is not"
a = [1, 2, 3]
c = [1, 2, 3]
print(a is not c)  # Ausgabe: True
True

# Vergleich mit Zahlen
x = 5
y = 5
print(x is y)  # Ausgabe: True (bei kleinen Zahlen)
True

Tipp: is prüft die Identität (Speicheradresse), == prüft den Wert. Zwei Listen mit gleichem Inhalt sind == gleich, aber nur is gleich, wenn sie dasselbe Objekt sind.

Lektion 6: Bedingungen & Verschachtelung in Python

Grundlagen von Bedingungen

Bedingungen (conditions) steuern den Ablauf eines Programms abhängig von bestimmten Kriterien. Mit ihnen kannst du verschiedene Aktionen ausführen, je nachdem, ob eine Bedingung erfüllt ist oder nicht.

Beispiel: Ist ein Nutzer angemeldet, darf er Daten bearbeiten. Ist er nicht angemeldet, bekommt er eine entsprechende Meldung.

Bedingungen können beliebig verschachtelt werden – also Bedingungen innerhalb von Bedingungen.

Haupt-Bedingungssätze

Beispiele für Bedingungssätze

alter = 21
if alter >= 18:
    print("Zugang erlaubt.")

Prüft, ob alter mindestens 18 ist. Wenn ja, wird die Meldung ausgegeben.

angemeldet = False
if angemeldet:
    print("Fortschritt speichern möglich.")
else:
    print("Bitte melden Sie sich an, um fortzufahren.")

Wenn angemeldet True ist, wird der erste Block ausgeführt, sonst der else-Block.

rolle = "redakteur"
if rolle == "administrator":
    print("Zugriff für Administrator.")
elif rolle == "redakteur":
    print("Zugriff für Redakteur.")
elif rolle == "autor":
    print("Zugriff für Autor.")
else:
    print("Zugriff für Gast.")

Es wird der erste zutreffende Block ausgeführt, danach werden die restlichen elif oder else-Blöcke übersprungen.

Logische Operatoren & verschachtelte Bedingungen

nummer = 15
if nummer >= 0 and nummer <= 20:
    print("Nummer liegt im erlaubten Bereich.")
else:
    print("Nummer nicht erlaubt.")

Beide Bedingungen müssen erfüllt sein (nummer zwischen 0 und 20).

wert = 3
if wert == 1 or wert == 2 or wert == 3:
    print("Wert ist zulässig.")
else:
    print("Wert ist nicht zulässig.")

Es reicht aus, wenn eine der Bedingungen erfüllt ist.

geschlecht = "weiblich"
alter = 17
if geschlecht == "männlich":
    print("Geschlecht: männlich")
    if alter < 21:
        print("Er ist ein junger Mann.")
elif geschlecht == "weiblich":
    print("Geschlecht: weiblich")
    if alter < 21:
        print("Sie ist ein junges Mädchen.")

Hier befindet sich eine Bedingung innerhalb einer anderen.

Verschachtelte Bedingungen – Praxis

mitgliederstatus = 'premium'
alter = 30
if mitgliederstatus == 'standard':
    print('Standard-Mitgliedschaft erkannt.')
    if alter < 18:
        print('Eingeschränkter Zugang für Minderjährige.')
    else:
        print('Voller Zugang für erwachsene Standard-Mitglieder.')
elif mitgliederstatus == 'premium':
    print('Premium-Mitgliedschaft erkannt.')
    if alter < 18:
        print('Jugendlicher Premium-Zugang mit zusätzlichen Inhalten.')
    else:
        print('Voller Premium-Zugang mit exklusiven Vorteilen.')
else:
    print('Mitgliedschaft unbekannt – bitte anmelden.')

1. Der Interpreter prüft zuerst, ob mitgliederstatus 'standard' ist.
2. Da mitgliederstatus 'premium' ist, wird diese Bedingung übersprungen.
3. Python prüft elif: mitgliederstatus == 'premium' – das trifft zu, also wird dieser Block ausgeführt.
4. Innerhalb dieses Blocks wird alter < 18 geprüft. Da alter 30 ist, wird die else-Anweisung ausgeführt.

Zusammenfassung

Verschachtelte Bedingungen sind ein fundamentaler Bestandteil der Programmierung. Sie erlauben es, komplexe Entscheidungsbäume abzubilden und verschiedene Eingabekombinationen differenziert zu behandeln.

In Python werden solche Bedingungen mit Einrückungen dargestellt, wodurch der Code übersichtlich und gut lesbar bleibt.

Nutze if, elif und else sowie logische Operatoren, um flexible und präzise Programmabläufe zu gestalten.

Lektion 7: Schleifen in Python – Ein umfassender Überblick

Einführung in das Konzept von Schleifen

Schleifen sind ein zentrales Konzept in der Programmierung und ermöglichen die wiederholte Ausführung von Codeblöcken. In Python dienen Schleifen dazu, bestimmte Anweisungen mehrfach auszuführen – entweder eine fest definierte Anzahl von Durchläufen oder so lange, wie eine Bedingung erfüllt ist. Dies reduziert Redundanz, erhöht die Effizienz und macht Programme flexibler.

Schleifentypen in Python

1. Die for-Schleife

Die for-Schleife in Python erlaubt es, über jedes Element einer Sequenz zu iterieren – sei es eine Liste, ein String oder ein durch range() erzeugter Bereich. Dabei entfällt die manuelle Definition eines Zählers, wie es in vielen anderen Sprachen notwendig ist.

for element in sequence:
    # Anweisungen

element: Eine temporäre Variable, die in jedem Schleifendurchlauf ein neues Element der Sequenz annimmt.
sequence: Eine iterierbare Datenstruktur (z. B. Liste, Tuple, String).
Die eingerückten Anweisungen werden in jedem Schleifendurchlauf ausgeführt.

Beispiel 1: Iteration über eine Liste

wochentage = ['Montag', 'Dienstag', 'Mittwoch', 'Donnerstag', 'Freitag']

for tag in wochentage:
    print(f"Heute ist {tag}")

Beispiel 2: Iteration über Zeichen in einem String

text = "Python"

for buchstabe in text:
    print(f"Buchstabe: {buchstabe}")

Die Funktion range()

Die Funktion range() erzeugt eine Folge von Ganzzahlen und wird häufig in Kombination mit der for-Schleife verwendet.

for i in range(1, 6):
    print(i)

Absteigende Iteration:

for i in range(5, 0, -1):
    print(i)

2. Die while-Schleife

Die while-Schleife führt eine Anweisung so lange aus, wie eine Bedingung erfüllt ist (True). Sie ist ideal für Situationen, in denen nicht im Voraus feststeht, wie oft ein Vorgang wiederholt werden soll.

zähler = 1

while zähler <= 5:
    print(zähler)
    zähler += 1

else-Block mit while

x = 1

while x <= 3:
    print(x)
    x += 1
else:
    print("Bedingung nicht mehr erfüllt.")

Unendliche Schleifen (Infinite Loops)

while True:
    print("Ich höre nie auf!")

⚠ Achtung: Unendliche Schleifen können Programme blockieren und das System belasten.

Kontrollanweisungen in Schleifen

Kontrollanweisungen ermöglichen eine flexible Steuerung des Ablaufs innerhalb von Schleifen. Zu den wichtigsten gehören:

• break: Beendet die Schleife vollständig, sobald sie erreicht wird.
• continue: Springt zur nächsten Iteration und überspringt den restlichen Code der aktuellen Schleifendurchlaufes.

Beispiel: break

for zahl in range(1, 10):
    if zahl == 5:
        break
    print(zahl)

Beispiel: continue (Nur ungerade Zahlen ausgeben)

for zahl in range(1, 7):
    if zahl % 2 == 0:
        continue
    print(zahl)

Gültigkeitsbereich von Variablen in Schleifen

In Python bleiben Variablen, die innerhalb einer Schleife deklariert wurden, auch außerhalb der Schleife gültig. Das unterscheidet Python von vielen anderen Sprachen.

for i in range(3):
    print(i)

print("Letzter Wert von i:", i)

Fazit

Python bietet eine intuitive und flexible Handhabung von Schleifen. Die for-Schleife eignet sich hervorragend für Iterationen über Sequenzen, während die while-Schleife für bedingungsbasierte Wiederholungen ideal ist. Kontrollanweisungen wie break und continue erweitern die Steuerungsmöglichkeiten erheblich. Das Verständnis dieser Konzepte ist essenziell für saubere, effiziente und lesbare Python-Programme.

Lektion 8: Arbeiten mit Zahlen

Einleitung

Diese Lerneinheit vermittelt ein fundiertes Verständnis über die in Python verfügbaren Zahlentypen. Neben der Differenzierung zwischen ganzzahligen, gleitkomma- sowie komplexen Zahlen widmen wir uns ebenfalls den integrierten Funktionen der Sprache, die zur Typumwandlung, zur Durchführung arithmetischer Berechnungen und zur Generierung von Zufallswerten eingesetzt werden können.

Ein wesentliches Merkmal numerischer Datentypen in Python ist ihre Unveränderlichkeit (Immutability). Das bedeutet: Wird einer Variablen ein numerischer Wert zugewiesen, reserviert das System einen bestimmten Speicherbereich. Sobald dieser Variablen jedoch ein neuer Wert zugewiesen wird, erfolgt keine direkte Überschreibung, sondern eine Neuzuweisung in einem separaten Speicherbereich. Der zuvor belegte Speicher wird anschließend – in der Regel automatisch – vom sogenannten Garbage Collector freigegeben, welcher in Python für das effiziente Speicher- und Ressourcenmanagement zuständig ist.

Zahlentypen in Python

Durch diese automatische Typisierung wird die Handhabung numerischer Werte in Python deutlich vereinfacht und fördert eine intuitive, leserfreundliche Programmierung.

Darstellung von Ganzzahlen in verschiedenen Zahlensystemen

Python erlaubt es, ganze Zahlen nicht nur im bekannten Dezimalsystem (Basis 10), sondern auch im Binärsystem (Basis 2), Oktalsystem (Basis 8) und Hexadezimalsystem (Basis 16) darzustellen. Diese Flexibilität ist besonders im Bereich der Softwareentwicklung mit Hardwarebezug, bei Netzwerkanwendungen oder auch in der Kryptographie hilfreich.

Typumwandlung numerischer Werte in Python

Python bietet eine Reihe integrierter Funktionen zur expliziten Typkonvertierung, mit denen sich Zahlen zwischen verschiedenen Datentypen konvertieren lassen. Solche Konvertierungen sind insbesondere dann relevant, wenn etwa Benutzereingaben als Zeichenkette (String) vorliegen oder wenn Berechnungen mit unterschiedlichen Zahlentypen harmonisiert werden sollen.

int(x) – Umwandlung in einen Ganzzahltyp

• Funktionssignatur: int(x=0)
• Parameter: x – Ein Wert beliebigen Typs, der numerisch interpretierbar sein muss (z. B. Float, String mit Ziffern etc.).
• Gültige Eingaben:
  • int("42") → erlaubt
  • int(3.9) → erlaubt
  • int(" 42 ") → nicht erlaubt, da Leerzeichen enthalten sind

int(x, base) – Umwandlung von Zeichenketten in Ganzzahlen mit Basisangabe

• Funktionssignatur: int(x, base=10)
• Parameter:
  • x: Eine Zeichenkette, die eine ganze Zahl in der entsprechenden Basis repräsentiert, z. B. "1010" für Binär oder "1F" für Hexadezimal.
  • base: Ein ganzzahliger Wert zwischen 2 und 36, der die numerische Basis (das Zahlensystem) angibt. Standardwert ist 10 (Dezimalsystem).

float(x) – Umwandlung in eine Gleitkommazahl

• Funktionssignatur: float(x)
• Parameter: x: Ein numerischer Ausdruck (z. B. int, str oder sogar float). Auch Zeichenketten, die eine gültige Dezimalzahl enthalten, sind zulässig.

complex(real, imag) – Erzeugung einer komplexen Zahl

• Funktionssignatur: complex(real=0, imag=0)
• Parameter:
  • real: Der reale Anteil der Zahl. Kann vom Typ int, float oder eine Zeichenkette mit numerischem Inhalt sein.
  • imag: Der imaginäre Anteil der Zahl (optional). Auch hier sind int, float oder numerische Strings erlaubt.

Funktionen zur Arbeit mit Zahlen

In Python ist die Flexibilität beim Umgang mit verschiedenen Zahlentypen ein zentraler Bestandteil der Sprache. Um sicherzustellen, dass numerische Werte korrekt verarbeitet, verglichen oder weiterverwendet werden können, stellt Python mehrere eingebaute Funktionen bereit.

Diese Funktionen ermöglichen es, Werte gezielt in andere numerische Typen umzuwandeln – z. B. von Gleitkomma- zu Ganzzahlen, von Text zu Zahlen oder zur Bildung komplexer Zahlen. Dies ist besonders wichtig bei der Verarbeitung von Benutzereingaben, bei mathematischen Operationen mit gemischten Datentypen sowie in wissenschaftlichen Berechnungen.

abs(x) – Betrag (Absolutwert) einer Zahl

Die Funktion abs() dient zur Berechnung des Absolutwerts einer Zahl – d. h. sie gibt stets den positiven Wert einer gegebenen Zahl zurück, unabhängig davon, ob der ursprüngliche Wert negativ war oder nicht.
Diese Funktion ist in Python integriert (built-in) und kann mit allen numerischen Typen verwendet werden: int, float sowie auch mit complex.

• Funktionssignatur: abs(x)
• Parameter: x: Eine Zahl vom Typ int, float oder complex.

round(x[, n]) – Rundung einer Zahl

Die Funktion round() rundet eine Zahl auf eine definierte Anzahl von Nachkommastellen. Standardmäßig wird auf die nächste ganze Zahl gerundet, wenn die Anzahl der Nachkommastellen nicht angegeben wird.

• Funktionssignatur: round(x[, n])
• Parameter:
  • x: Eine Zahl vom Typ int oder float, die gerundet werden soll.
  • n (optional): Anzahl der Dezimalstellen, auf die gerundet werden soll (int). Standardwert ist 0.

max(x1, x2, …) – Maximum aus mehreren Werten

Die Funktion max() gibt das größte Element aus einer Reihe von Werten oder aus einer iterierbaren Datenstruktur zurück.

• Funktionssignatur: max(iterable, *[, key, default]) oder max(arg1, arg2, *args, *[, key])
• Parameter:
  • arg1, arg2, *args: Zwei oder mehr Werte, aus denen das Maximum ermittelt wird.
  • iterable: Eine iterierbare Datenstruktur (z. B. Liste, Tuple, Set).
  • key (optional): Eine Funktion, die auf jedes Element angewendet wird, um den Vergleichswert zu bestimmen.
  • default (optional): Wert, der zurückgegeben wird, wenn das Iterable leer ist (nur bei Iterable-Variante).

min(x1, x2, …) – Minimum aus mehreren Werten

Die Funktion min() gibt das kleinste Element aus einer Reihe von Werten oder aus einer iterierbaren Datenstruktur zurück.

• Funktionssignatur: min(iterable, *[, key, default]) oder min(arg1, arg2, *args, *[, key])
• Parameter:
  • arg1, arg2, *args: Zwei oder mehr Werte, aus denen das Minimum ermittelt wird.
  • iterable: Eine iterierbare Datenstruktur (z. B. Liste, Tuple, Set).
  • key (optional): Eine Funktion, die auf jedes Element angewendet wird, um den Vergleichswert zu bestimmen.
  • default (optional): Wert, der zurückgegeben wird, wenn das Iterable leer ist (nur bei Iterable-Variante).

Bedeutung des Begriffs Modul

Ein Modul in Python ist eine eigenständige Datei, die Funktionen, Klassen, Variablen und weitere Bestandteile enthalten kann.
Um die Inhalte eines Moduls im eigenen Programm verwenden zu können, wird es mit dem Schlüsselwort import eingebunden. Anschließend stehen alle definierten Bestandteile direkt zur Verfügung.

Im weiteren Verlauf dieser Lernreihe wirst du Schritt für Schritt lernen, wie man eigene Module erstellt und effektiv einsetzt.
Zudem wirst du eine Vielzahl an nützlichen, bereits integrierten Modulen aus der Python-Standardbibliothek kennenlernen.

In diesem Abschnitt werfen wir einen genaueren Blick auf zwei häufig verwendete Module: math für mathematische Berechnungen und random zur Erzeugung von Zufallswerten.

Variablen und Konstanten des Moduls math

Das Python-Modul math stellt neben zahlreichen mathematischen Funktionen auch wichtige Konstanten und spezielle Variablen zur Verfügung, die in vielen mathematischen und wissenschaftlichen Anwendungen benötigt werden.
Diese Konstanten sind direkt im Modul definiert und können nach dem Import sofort verwendet werden.

Wichtigste Funktionen des Moduls math

ceil(x) – Aufrunden zur nächsten ganzen Zahl

Die Funktion math.ceil(x) rundet eine gegebene Zahl immer auf die nächstgrößere ganze Zahl auf, unabhängig vom Nachkommabetrag. Sie ist besonders nützlich, wenn man sicherstellen möchte, dass das Ergebnis nicht kleiner als der ursprüngliche Wert ist – beispielsweise bei Mengenkalkulationen oder der Reservierung ganzer Einheiten.

• Funktionssignatur: math.ceil(x)
• Parameter: x: Eine Gleitkommazahl (float) oder ein ganzzahliger Wert (int)
• Rückgabewert: Gibt den kleinsten ganzzahligen Wert zurück, der größer oder gleich x ist. Der Rückgabewert hat den Datentyp int.

floor(x) – Abrunden zur nächstkleineren ganzen Zahl

Die Funktion math.floor(x) rundet eine gegebene Zahl immer auf die nächstkleinere ganze Zahl ab, unabhängig davon, wie nahe sie an der nächsten Ganzzahl liegt. Sie ist das Gegenstück zu ceil(x).

• Funktionssignatur: math.floor(x)
• Parameter: x: Eine Gleitkommazahl (float) oder ein ganzzahliger Wert (int)
• Rückgabewert: Gibt den größten ganzzahligen Wert zurück, der kleiner oder gleich x ist. Der Rückgabewert ist vom Typ int.

pow(x, y) – Potenzieren (x hoch y)

Die Funktion math.pow(x, y) berechnet die Potenz von zwei Zahlen, d. h. sie hebt die Zahl x zur Potenz y:
math.pow(x, y) = xy

• Funktionssignatur: math.pow(x, y)
• Parameter:
  • x: Die Basis (Zahl, die potenziert wird)
  • y: Der Exponent (Zahl, auf die potenziert wird)
• Rückgabewert: Gibt das Ergebnis von xy als Gleitkommazahl (float) zurück – auch wenn das Ergebnis eine ganze Zahl ist.

sqrt(x) – Quadratwurzel berechnen

Die Funktion math.sqrt(x) berechnet die Quadratwurzel einer Zahl, also die Zahl, die mit sich selbst multipliziert das Argument x ergibt:
math.sqrt(x) = √x

• Funktionssignatur: math.sqrt(x)
• Parameter: x: Eine nicht-negative Zahl (int oder float), von der die Quadratwurzel berechnet werden soll.
• Rückgabewert: Gibt die Quadratwurzel von x als Gleitkommazahl (float) zurück.

exp(x) – Exponentialfunktion berechnen

Die Funktion math.exp(x) berechnet den Exponentialwert der Zahl x, also:
math.exp(x) = ex
Dabei ist e die Eulersche Zahl (≈ 2.71828), eine wichtige mathematische Konstante, die u. a. in Naturwissenschaften, Statistik und Finanzmathematik eine zentrale Rolle spielt.

• Funktionssignatur: math.exp(x)
• Parameter: x: Eine reelle Zahl (int oder float), als Exponent der Eulerschen Zahl.
• Rückgabewert: Gibt den Wert von ex als Gleitkommazahl (float) zurück.

log(x[, base]) – Logarithmus berechnen

Die Funktion math.log(x[, base]) berechnet den Logarithmus einer Zahl x zur angegebenen Basis base. Wird keine Basis angegeben, verwendet die Funktion automatisch die natürliche Basis e (≈ 2.71828).

• Funktionssignatur: math.log(x, base) oder einfach math.log(x) (entspricht ln(x))
• Parameter:
  • x: Eine positive Zahl (int oder float)
  • base (optional): Die Basis des Logarithmus (z. B. 2, 10, e)
• Rückgabewert: Gibt den Logarithmus von x zur angegebenen Basis als Gleitkommazahl (float) zurück.

Bedeutung:
math.log(x, b) = logb(x) bzw. math.log(x) = ln(x)

log2(x) – Logarithmus zur Basis 2 berechnen

Die Funktion math.log2(x) berechnet den Logarithmus einer Zahl zur Basis 2. Sie ist eine speziell optimierte Variante der allgemeinen math.log(x, 2)-Berechnung.

• Funktionssignatur: math.log2(x)
• Parameter: x: Eine positive Zahl (int oder float)
• Rückgabewert: Gibt den binären Logarithmus von x zurück, also die Potenz, auf die man 2 heben muss, um x zu erhalten. Der Rückgabewert ist vom Typ float.

Bedeutung:
math.log2(x) = log2(x)
Beispiel: log2(8) = 3, denn 23 = 8