# Erste Schritte in Python

> For AI agents: use [llms.txt](https://nakafa.com/llms.txt) for the site index. Markdown versions are available by appending `.md` to content URLs or sending `Accept: text/markdown`.

URL: https://nakafa.com/de/faecher/ki-und-data-science/ki-programmierung/erster-schritt-mit-python
Source: https://raw.githubusercontent.com/nakafaai/aksara/992eb09ded1422859aca3966c80b52a16b2832f4/packages/corpus/material/lesson/ai-ds/ai-programming/python-step-1/de.mdx

Führe Python interaktiv, als Skript und in Jupyter aus und schreibe Programme mit Variablen sowie Ein- und Ausgabe.

---

## Ein erstes Programm in Python ausführen

<Highlight>Python kennzeichnet Codeblöcke durch Einrückung</Highlight> und verwendet kurze Schlüsselwörter für häufige Operationen. In den ersten Beispielen lassen sich Zuweisungen, Funktionsaufrufe und Bedingungen erkennen, bevor jedes Syntaxdetail bekannt ist.

Dieselbe Sprache wird in der Webentwicklung, Datenanalyse, im maschinellen Lernen und in der künstlichen Intelligenz eingesetzt. Das erste Beispiel ist ein kleines Programm, das Text ausgibt.

Wenn du die Syntax prüfen oder eine Funktion in der Standardbibliothek suchen möchtest, öffne die [offizielle Python-Dokumentation](https://docs.python.org). Wähle dort dieselbe Python-Version aus, die du ausführst, damit die Beispiele und verfügbaren Funktionen zu deinem Programm passen.

## Hello World Programm

Ein verbreitetes erstes Programm gibt den **Text „Hello World!“** aus. Wenn es läuft, kann Python eine Datei ausführen, und du hast zugleich ein kleines, vollständiges Programm zum Untersuchen.

File: hello.py
```python
print("Hello World!")
```

`print()` ist eine eingebaute Python-Funktion. Sie gibt den Text oder Wert in den Klammern auf dem Bildschirm aus.

## Drei Möglichkeiten Programme in Python auszuführen

Python-Code lässt sich auf drei verbreitete Arten ausführen. Die interaktive Eingabeaufforderung eignet sich zum Ausprobieren einzelner Ausdrücke, eine gespeicherte Skriptdatei für ein Programm, das du wiederholt startest, und ein Notebook für die **Verbindung von Code und Notizen**.

### Interaktiver Modus

Im interaktiven Modus kannst du Python-Code direkt im Terminal schreiben und ausführen. Das eignet sich gut, um **kurze Ausdrücke zu prüfen** oder etwas schnell auszuprobieren.

Öffne ein Terminal, gib `python` oder `python3` ein und drücke die Eingabetaste. Die Eingabeaufforderung `>>>` zeigt, dass Python bereit ist. Gib danach eine Python-Anweisung ein und bestätige erneut mit der Eingabetaste.

File: terminal
```bash
$ python3
>>> print("Hello World!")
Hello World!
>>> 2 + 3
5
>>> name = "Alice"
>>> print(f"Hello, {name}!")
Hello, Alice!
>>>
```

### Skriptmodus

Im Skriptmodus wird eine **gespeicherte Python-Datei** ausgeführt. Das eignet sich für längere Programme und für Code, den du später erneut verwenden möchtest.

Erstelle dazu mit einem Texteditor eine Datei mit der Endung `.py`, schreibe den Python-Code hinein und speichere die Datei. Öffne anschließend ein Terminal, wechsle in den Ordner der Datei und führe `python3 dateiname.py` aus.

File: greeting.py
```python
# Einfaches Programm zur Begrüßung von Benutzern
name = input("Wie heißt du? ")
age = input("Wie alt bist du? ")

print(f"Hallo {name}!")
print(f"Du bist {age} Jahre alt.")
print("Viel Spaß beim Lernen von Python!")
```

So führst du die Datei aus:

File: terminal
```bash
$ python3 greeting.py
Wie heißt du? John
Wie alt bist du? 20
Hallo John!
Du bist 20 Jahre alt.
Viel Spaß beim Lernen von Python!
```

### Jupyter Lab und Notebooks

Jupyter ist eine interaktive Umgebung, die häufig für Data Science und interaktives Lernen verwendet wird. Ein Notebook verbindet **ausführbaren Code**, dessen Ausgabe und schriftliche Erklärungen in einem Dokument.

Jede Zelle lässt sich einzeln ausführen, und ihre Ausgabe erscheint direkt darunter. Code, Ergebnisse, Erklärungen und Diagramme bleiben in einem Dokument. So kann ein Notebook jeden Schritt eines Experiments oder einer Datenanalyse festhalten.

Die Zellen teilen den Zustand desselben Kernels. Führe sie nach einem Kernel-Neustart von oben nach unten aus: Eine Zelle mit `math` oder einer Funktion benötigt die vorherige Definition dieses Namens.

Installiere JupyterLab in einer eigenen Python-Umgebung, damit seine Pakete nicht mit anderen Projekten in Konflikt geraten:

Diese Befehle verwenden macOS/Linux-Pfade. Unter Windows nutzt du `py -m venv .venv`, danach `.venv\Scripts\python -m pip install jupyterlab` und `.venv\Scripts\jupyter lab`.

File: terminal
```bash
# JupyterLab mit dem gewählten Python-Interpreter installieren
python3 -m venv .venv
.venv/bin/python -m pip install jupyterlab
```

Starte danach JupyterLab:

File: terminal
```bash
# JupyterLab starten
.venv/bin/jupyter lab

# Öffnet die Jupyter-Oberfläche im Browser
```

Erstelle anschließend ein Notebook mit der Endung `.ipynb`. Schreibe Code in eine Zelle und führe sie mit Umschalt+Eingabetaste aus.

Beispielverwendung in Jupyter:

File: jupyter_example.ipynb
```python
# Zelle 1: Import und Einrichtung
import math

# Zelle 2: Variablen und Operationen
radius = 5
area = math.pi * radius ** 2
print(f"Kreisfläche mit Radius {radius} ist {area:.2f}")

# Zelle 3: Funktion erstellen
def calculate_circle_area(r):
  """Funktion zur Berechnung der Kreisfläche"""
  return math.pi * r ** 2

# Zelle 4: Testfunktion
test_radius = 7
result = calculate_circle_area(test_radius)
print(f"Kreisfläche mit Radius {test_radius} ist {result:.2f}")
```

## Grundlegende Syntax von Python

Ein erstes Python-Programm liest seine Anweisungen von oben nach unten. Eine Variable speichert einen Wert, ein **Datentyp legt fest**, welche Operationen dieser Wert unterstützt, und Eingabe, Ausgabe und Rechenoperationen ergeben zusammen ein vollständiges Programm.

### Variablen und Datentypen

Python kennt mehrere grundlegende Datentypen. Ein **Variablenname verweist auf einen Wert**. Eine neue Zuweisung ändert diese Bindung, statt jeden Wert in einen veränderbaren Behälter zu verwandeln.

File: data_types.py
```python
# Grundlegende Datentypen in Python

# Zeichenfolge (Text)
name = "John Doe"
message = 'Hello Python!'

# Ganzzahl (ganze Zahlen)
age = 25
year = 2025

# Float (Gleitkommazahlen)
height = 175.5
pi = 3.14159

# Boolean (True/False)
is_student = True
is_graduated = False

# Liste (Sammlung von Elementen)
fruits = ["Apfel", "orange", "Mango", "Banane"]
numbers = [1, 2, 3, 4, 5]

# Dictionary (key-value pairs)
person = {
  "name": "Alice",
  "age": 22,
  "major": "Computer Science"
}

# Datentypen anzeigen
print(type(name))        # <class 'str'>
print(type(age))         # <class 'int'>
print(type(height))      # <class 'float'>
print(type(is_student))  # <class 'bool'>
print(type(fruits))      # <class 'list'>
print(type(person))      # <class 'dict'>
```

### Eingabe und Ausgabe

Programme können Eingaben abfragen und daraus eine Ausgabe erzeugen. `input()` liest zunächst **Text ein**, während `print()` Werte ausgibt.

File: input_output.py
```python
# Eingabe vom Benutzer
user_name = input("Gib deinen Namen ein: ")
user_age = input("Gib dein Alter ein: ")

# Datentypkonvertierung
age_number = int(user_age)  # Zeichenkette in eine Ganzzahl umwandeln

# Ausgabe mit sauberer Formatierung
print(f"Hallo {user_name}!")
print(f"Du bist {age_number} Jahre alt.")

# Mathematische Operationen
next_year = age_number + 1
print(f"Nächstes Jahr bist du {next_year} Jahre alt.")

# Ausgabe mit unterschiedlichem Format
print("Name:", user_name)
print("Alter:", age_number)
print("Alter nächstes Jahr:", next_year)
```

### Grundlegende mathematische Operationen

Python unterstützt verschiedene **mathematische Operationen**:

File: math_operations.py
```python
# Grundlegende mathematische Operationen
a = 10
b = 3

# Arithmetische Operationen
addition = a + b      # 13
subtraction = a - b   # 7
multiplication = a * b # 30
division = a / b      # 3.333...
floor_division = a // b # 3 (Divisionsergebnis abgerundet)
modulus = a % b       # 1 (Rest)
exponent = a ** b     # 1000 (10 hoch 3)

print(f"{a} + {b} = {addition}")
print(f"{a} - {b} = {subtraction}")
print(f"{a} * {b} = {multiplication}")
print(f"{a} / {b} = {division}")
print(f"{a} // {b} = {floor_division}")
print(f"{a} % {b} = {modulus}")
print(f"{a} ** {b} = {exponent}")

# Zuweisungsoperatoren
x = 5
x += 3  # x = x + 3, Ergebnis ist x = 8
x *= 2  # x = x * 2, Ergebnis ist x = 16
print(f"Aktueller Wert von x: {x}")
```

## Praktische Übungen

Bearbeite die folgenden Übungen zu **Variablen, Ein- und Ausgabe** sowie grundlegenden Operationen. Schreibe jede Lösung zuerst selbst auf, denn geübt wird der Lösungsweg. Die Lösungen folgen derselben Reihenfolge wie die Aufgaben.

### Einfacher Rechner

Dieses Programm liest **zwei Zahlen und einen Operator** und gibt das Ergebnis aus. Es verbindet Eingabe, Typumwandlung und Verzweigung in einer Datei.

File: calculator.py
```python
# Einfacher Rechner
print("=== EINFACHER RECHNER ===")

# Eingabe vom Benutzer
number1 = float(input("Gib die erste Zahl ein: "))
operator = input("Gib den Operator (+, -, *, /) ein: ")
number2 = float(input("Gib die zweite Zahl ein: "))

# Berechnungsprozess
if operator == "+":
  result = number1 + number2
elif operator == "-":
  result = number1 - number2
elif operator == "*":
  result = number1 * number2
elif operator == "/":
  if number2 != 0:
      result = number1 / number2
  else:
      print("Fehler: Division durch Null nicht möglich!")
      result = None
else:
  print("Ungültiger Operator!")
  result = None

# Ausgabeergebnis
if result is not None:
  print(f"Ergebnis: {number1} {operator} {number2} = {result}")
```

### Temperaturumrechnung

Dieses Programm rechnet eine **Celsius-Temperatur in Fahrenheit und Kelvin** um und weist einen Wert unterhalb des absoluten Nullpunkts zurück.

Die Aussagen zu Gefrier- und Siedepunkt beziehen sich näherungsweise auf reines Wasser bei einer Atmosphäre. Probiere `26.85`: Die Umrechnung ergibt `80.3 °F` und `300.0 K`.

File: temperature_converter.py
```python
import math

# Temperaturkonverter von Celsius in Fahrenheit und Kelvin
print("=== TEMPERATURKONVERTER ===")

# Eingabetemperatur in Celsius
celsius = float(input("Temperatur in Celsius eingeben: "))

if not math.isfinite(celsius) or celsius < -273.15:
  raise ValueError("Die Temperatur muss endlich sein und mindestens dem absoluten Nullpunkt entsprechen")

# In Fahrenheit und Kelvin umrechnen
fahrenheit = (celsius * 9/5) + 32
kelvin = celsius + 273.15

# Konvertierungsergebnisse ausgeben
print(f"\nKonvertierungsergebnisse von {celsius}°C:")
print(f"Fahrenheit: {fahrenheit:.1f}°F")
print(f"Kelvin: {kelvin:.1f}K")

# Bonus: Zusätzliche Informationen
if celsius < 0:
  print("Diese Temperatur liegt unter dem Gefrierpunkt des Wassers!")
elif celsius == 0:
  print("Diese Temperatur ist der Gefrierpunkt von Wasser!")
elif celsius == 100:
  print("Diese Temperatur ist der Siedepunkt von Wasser!")
elif celsius > 100:
  print("Diese Temperatur liegt über dem Siedepunkt von Wasser!")
```

### Studentenprofil

Dieses Programm fragt die Angaben einer Studierenden ab, speichert sie in Variablen und gibt **ein kurzes Profil** aus.

File: personal_info.py
```python
# Programm zum Sammeln und Anzeigen persönlicher Informationen
print("=== STUDIERENDENPROFIL ===")

# Eingabeinformationen
name = input("Vollständiger Name: ")
student_id = input("Matrikelnummer: ")
major = input("Studiengang: ")
semester = int(input("Semester: "))
if semester < 1:
  raise ValueError("Das Semester muss mindestens 1 sein")
hobby = input("Lieblingshobby: ")
current_year = int(input("Beginnjahr des aktuellen Studienjahrs: "))

# Schätzung mit zwei Semestern pro Studienjahr
entry_year = current_year - (semester - 1) // 2
estimated_graduation = entry_year + 4

# Vollständiges Profil anzeigen
print("\n" + "="*40)
print("STUDIERENDENPROFIL")
print("="*40)
print(f"Name: {name}")
print(f"Matrikelnummer: {student_id}")
print(f"Studiengang: {major}")
print(f"Semester    : {semester}")
print(f"Hobby: {hobby}")
print(f"Studienbeginn: {entry_year}")
print(f"Voraussichtlicher Abschluss: {estimated_graduation}")
print("="*40)

# Motivierende Botschaft
if semester <= 2:
  print("Viel Erfolg beim Studienstart!")
elif semester <= 6:
  print("Viel Erfolg im weiteren Studium!")
else:
  print("Viel Erfolg beim Studienabschluss!")
```

### Ergebnis prüfen

**Deine Übungsprogramme funktionieren wie vorgesehen**, wenn:

- Der Rechner fragt nach zwei Zahlen und einem Operator und zeigt dann das Ergebnis der ausgewählten Operation an.
- Der Temperaturkonverter zeigt Fahrenheit- und Kelvin-Werte vom Celsius-Eingang an.
- Im Studierendenprofil werden die eingegebenen Daten, das Eintrittsjahr, das voraussichtliche Abschlussjahr und die semesterbezogene Nachricht angezeigt.